import argparse
import dataclasses
import os
import pathlib
import tempfile
import typing

from . import PKG_NAME
from .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"
    cache_file: str = str(pathlib.Path(tempfile.gettempdir()) / ".cool-domain-cache")
    tld_list_uri: str = "https://publicsuffix.org/list/public_suffix_list.dat"

    @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,
        suggest_on_error=True,
    )
    __add_arg_int(
        parser,
        "--count",
        env_var="DOMAIN_COUNT",
        default=default_values.count,
        help_txt="number of domains to generate",
    )
    parser.add_argument(
        "--lang",
        default=default_values.lang,
        help="word list lang (default: english)",
        choices=LANGS.keys(),
    )
    __add_arg_int(
        parser,
        "--words",
        env_var="WORD_COUNT",
        default=default_values.words,
        help_txt="number of words per domain",
    )
    __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
    )
    __add_arg_bool(
        parser,
        "--cache",
        default=default_values.cache,
        help_txt="use cache",
    )
    __add_arg_str(
        parser,
        "--cache-file",
        env_var="CACHE_FILE",
        default=default_values.cache_file,
        help_txt="cache file location",
    )
    __add_arg_str(
        parser,
        "--tld-list-uri",
        env_var="TLD_LIST_URI",
        default=default_values.tld_list_uri,
        help_txt="Top Level Domains list",
    )
    parsed_args = parser.parse_args(args)
    return Parameters.from_namespace(parsed_args)