import argparse
import dataclasses
import os
import typing

from cool_domain import PKG_NAME
from cool_domain.constants import LANGS


@dataclasses.dataclass(frozen=True, slots=True)
class Parameters:
    debug: bool = False
    quiet: bool = False
    cache: bool = True
    count: int = 1
    words: int = 1
    dig: bool = True
    lang: str = "english"
    custom_words: str = "words.txt"

    @classmethod
    def from_namespace(cls, args: argparse.Namespace) -> "Parameters":
        return Parameters(**vars(args))


def __get_env_str(var: str, default: str) -> str:
    if (result := os.getenv(var)) is None:
        return default
    return result


def __get_env_int(var: str, default: int) -> int:
    value = __get_env_str(var, str(default))
    if value.isdecimal():
        return int(value)
    return default


def __add_arg_str(
    parser: argparse.ArgumentParser,
    *flags: str,
    env_var: str,
    default: str,
    help_txt: str,
) -> None:
    parser.add_argument(
        *flags,
        metavar=env_var,
        default=__get_env_str(env_var, default),
        help=f"{help_txt} (default: {default})" if len(default) else help_txt,
    )


def __add_arg_int(
    parser: argparse.ArgumentParser,
    *flags: str,
    env_var: str,
    default: int,
    help_txt: str,
) -> None:
    parser.add_argument(
        *flags,
        type=int,
        metavar=env_var,
        default=__get_env_int(env_var, default),
        help=f"{help_txt} (default: {default})",
    )


def __add_arg_bool(
    parser: argparse.ArgumentParser,
    *flags: str,
    default: bool,
    help_txt: str,
    dest: str | None = None,
) -> None:
    parser.add_argument(
        *flags,
        action=argparse.BooleanOptionalAction,
        help=f"{help_txt} (default: {str(default).lower()})",
        default=default,
        dest=dest,
    )


def parse_parameters(args: typing.Sequence[str]) -> Parameters:
    default_values = Parameters()
    parser = argparse.ArgumentParser(
        PKG_NAME,
    )
    __add_arg_int(
        parser,
        "--count",
        env_var="DOMAIN_COUNT",
        default=default_values.count,
        help_txt="number of domains to generate",
    )
    __add_arg_int(
        parser,
        "--words",
        env_var="WORD_COUNT",
        default=default_values.words,
        help_txt="number of words per domain",
    )
    parser.add_argument(
        "--lang",
        default=default_values.lang,
        help="word list lang (default: english)",
        choices=[*list(LANGS.keys()), "custom"],
    )
    __add_arg_str(
        parser,
        "--custom-words",
        env_var="CUSTOM_WORDS",
        default=default_values.custom_words,
        help_txt="custom word list location",
    )
    __add_arg_bool(
        parser,
        "--dig",
        default=default_values.dig,
        help_txt="check availability with dig",
    )
    parser.add_argument(
        "--debug", action=argparse.BooleanOptionalAction, default=default_values.debug
    )
    parser.add_argument(
        "--quiet", action=argparse.BooleanOptionalAction, default=default_values.quiet
    )
    parsed_args = parser.parse_args(args)
    return Parameters.from_namespace(parsed_args)