"""
Silique (https://www.silique.fr)
Copyright (C) 2024-2026

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Mtools is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Mtools.  If not, see <http://www.gnu.org/licenses/>.
"""

import os
from warnings import filterwarnings
from pathlib import Path
from sys import exit
from warnings import warn

from tiramisu_cmdline_parser import TiramisuCmdlineParser
from tiramisu.error import PropertiesOptionError
from tiramisu import MetaConfig

from rougail import Rougail
from rougail.user_data import UserData, mandatories
from rougail.config import get_rougail_config
from rougail.utils import load_modules
from rougail.error import RougailWarning

try:
    from rougail.user_data_yaml import RougailUserDataYaml
except ImportError:
    RougailUserDataYaml = None
try:
    from rougail.user_data_environment import RougailUserDataEnvironment
except ImportError:
    RougailUserDataEnvironment = None
from .rougailconfig import load as rougailconfig_load

from .i18n import _


ENV_PREFIX = "ROUGAILCLI"


def _main(arguments, do_not_print):
    global print_traceback
    rougailconfig = get_rougail_config(
        backward_compatibility=False, add_extra_options=False
    )
    cmd_config = load_cmd_user_data(rougailconfig, arguments)
    print_traceback = rougailconfig["cli.debug"]
    if rougailconfig["cli.versions"]:
        versions = display_version(cmd_config)
        if do_not_print:
            return list(versions)
        for version in versions:
            print(version)
        exit()
    layer_datas, metaconfig, config, err_warn = load_user_data(rougailconfig)
    if config and (not rougailconfig["cli.load_config"] or not rougailconfig["cli.read_write"]):
        config.property.read_only()
    if rougailconfig["cli.mandatory"]:
        mandatories(config, err_warn["errors"])
    output = get_output(rougailconfig,
                        metaconfig,
                        config,
                        err_warn,
                        layer_datas,
                        )
    if do_not_print:
        return output.run()
    ret = output.print()
    if ret is False:
        exit(1)


def load_cmd_user_data(rougailconfig, arguments):
    rougailconfig.generate_config()
    cmd_config = rougailconfig.config
    origin_prop = cmd_config.property.default("read_write", "append")
    cmd_config.property.setdefault(
        frozenset(origin_prop | {"not_for_commandline"}), "read_write", "append"
    )
    cmd_config.property.read_write()
    config_files = None
    if RougailUserDataYaml:
        _config_files = os.environ.pop(f"{ENV_PREFIX}_CLI.CONFIG_FILE", None)
        if _config_files:
            _config_files = _config_files.split(',')
        else:
            _config_files = cmd_config.forcepermissive.option("cli.config_file").value.get()
        _config_files = [_config_file for _config_file in _config_files if Path(_config_file).is_file()]
        if _config_files:
            config_files = _config_files
    if RougailUserDataEnvironment:
        env_prefix = ENV_PREFIX
    else:
        env_prefix = None
    user_data = rougailconfig_load(rougailconfig, config_files, env_prefix, True, _arguments=arguments, _generate=False, _add_help=False)
    display_warnings = rougailconfig["cli.warnings"]
    manage_warnings(display_warnings)
    if not cmd_config.option("cli.versions").value.get():
        if display_warnings and user_data["warnings"]:
            for warning in user_data["warnings"]:
                if isinstance(warning, dict):
                    for w, var in warning.items():
                        if var:
                            warn(UserWarning(f'unable to load "{var.option.impl_get_display_name(var)}", {str(w)}'))
                        else:
                            warn(UserWarning(f'{str(w)}'))
                else:
                    warn(warning)
        if manage_warnings:
            # replays to display errors if needed
            parser = TiramisuCmdlineParser(
                cmd_config,
                short_name_max_len=2,
            )
            parser.parse_args(arguments)
        if user_data["errors"]:
            raise Exception(user_data["errors"][0])

    cmd_config.property.setdefault(origin_prop, "read_write", "append")
    cmd_config.property.read_only()
    cmd_config.property.remove("not_for_commandline")

    return cmd_config


def display_version(cmd_config):
    versions = []
    from tiramisu import __version__
    yield(f"tiramisu: {__version__}")

    from tiramisu_cmdline_parser import __version__
    yield(f"tiramisu-cmdline-parser: {__version__}")

    from rougail import __version__
    yield(f"rougail: {__version__}")

    from . import __version__
    yield(f"rougail-cli: {__version__}")

    for step in ["structural", "user_data", "output"]:
        display_step = step.replace("_", "-")
        for step_name in sorted(cmd_config.unrestraint.option(f"step.{step}").value.list()):
            path = (
                Path(__file__).parent.parent
                / (step + "_" + step_name)
                / "__init__.py"
            )
            if path.is_file():
                try:
                    module = load_modules(
                        "rougail." + step + "_" + step_name, str(path)
                    )
                    yield(
                        f"rougail-{display_step}-{step_name}: {module.__version__}"
                    )
                except Exception as err:
                    pass


def manage_warnings(warnings):
    if not warnings:
        filterwarnings("ignore", category=DeprecationWarning)
        filterwarnings("ignore", category=RougailWarning)
    else:
        filterwarnings("default", category=DeprecationWarning)
        filterwarnings("default", category=RougailWarning)


def load_user_data(rougailconfig):
    layer_datas = {}
    if not rougailconfig["cli.load_config"]:
        return None, None, None, {"errors": [], "warnings": []}
    try:
        user_data_names = rougailconfig["step.user_data"]
    except PropertiesOptionError:
        user_data_names = []
    has_layers = rougailconfig["cli.layers"]
    if has_layers:
        layers = [[ud] for ud in user_data_names]
        last_layers = len(layers) - 1
    else:
        layers = [user_data_names]
        last_layers = 0
    if rougailconfig["tiramisu_cache"]:
        load_from_tiramisu_cache = rougailconfig["cli.load_from_tiramisu_cache"]
    else:
        load_from_tiramisu_cache = False
    rougail = Rougail(rougailconfig, load_from_tiramisu_cache=load_from_tiramisu_cache)
    layer_name = "_".join(layers[-1])
    subconfig = rougail.run(name=layer_name)
    try:
        read_write = set()
        read_only = set()
        if rougailconfig["cli.inaccessible_read_write_modes"]:
            read_write = set(rougailconfig["cli.inaccessible_read_write_modes"])
        if rougailconfig["cli.inaccessible_read_only_modes"]:
            read_only = set(rougailconfig["cli.inaccessible_read_only_modes"])
        if rougailconfig["cli.inaccessible_modes"]:
            modes = set(rougailconfig["cli.inaccessible_modes"])
            read_only |= modes
            read_write |= modes
        if read_write:
            subconfig.property.setdefault(
                frozenset(subconfig.property.default("read_write", "append") | read_write), "read_write", "append"
            )
            subconfig.property.setdefault(
                frozenset(subconfig.property.default("read_only", "remove") | (read_write - read_only)), "read_only", "remove"
            )
            for p in read_write:
                subconfig.permissive.add(p)
        if read_only:
            subconfig.property.setdefault(
                frozenset(subconfig.property.default("read_only", "append") | read_only), "read_only", "append"
            )
            for p in read_only:
                subconfig.permissive.add(p)
        if read_write or read_only:
            subconfig.property.read_write()
    except:
        pass
    subconfig.information.set("description_type", rougailconfig["cli.description_type"])
    metaconfig = subconfig
    if last_layers:
        for layer in reversed(layers[:-1]):
            layer_name = "_".join(layer)
            metaconfig = MetaConfig([metaconfig], name=layer_name)
            metaconfig.owner.set(metaconfig.path())
    subconfig = metaconfig
    err_warn = {"errors": [], "warnings": []}
    invalid_user_data_error = rougailconfig["cli.invalid_user_data_error"]
    unknown_user_data_error = rougailconfig["cli.unknown_user_data_error"]
    interactive_user_data = {}
    for idx, layer in enumerate(layers):
        if idx:
            subconfig = subconfig.config("_".join(layer))
            subconfig.owner.set(subconfig.path())
        layer_name = subconfig.path()
        # data user
        user_data = []
        if has_layers:
            layer_datas[layer_name] = {}
        for user_data_name in layer:
            path = (
                Path(__file__).parent.parent
                / ("user_data_" + user_data_name)
                / "__init__.py"
            )
            if not path.is_file():
                raise Exception(
                    _('cannot find "user_data" module "{0}"').format(user_data_name)
                )
            module = load_modules("rougail.user_data_" + user_data_name, str(path))
            rougail_user_data = module.RougailUserData
            if hasattr(rougail_user_data, 'interactive_user_data') and rougail_user_data.interactive_user_data:
                interactive_user_data.setdefault(layer_name, {})[user_data_name] = rougail_user_data
                continue
            elif interactive_user_data:
                raise Exception(_('interactive user data "{0}" is loader before uninteractive user data "{1}"').format(list(interactive_user_data), user_data_name))
            for ud in rougail_user_data(
                    subconfig,
                    rougailconfig=rougailconfig,
                    ).run():
                if has_layers:
                    layer_datas[layer_name].setdefault(user_data_name, []).append(ud["source"])
                user_data.append(ud)
        if user_data:
            new_err_warn = UserData(subconfig).user_data(user_data, invalid_user_data_error=invalid_user_data_error, unknown_user_data_error=unknown_user_data_error)
            for level, datas in new_err_warn.items():
                if datas:
                    err_warn[level].extend(datas)
    for layer_name, interactive_user_data in interactive_user_data.items():
        for layer, rougail_user_data in interactive_user_data.items():
            if has_layers and len(layers) > 1:
                subconfig = subconfig.config("_".join(layer))
                subconfig.owner.set(subconfig.path())
            for user_data in rougail_user_data(
                subconfig,
                rougailconfig=rougailconfig,
                ).run():
                if has_layers:
                    layer_datas[layer_name].setdefault(user_data_name, []).append(user_data["source"])

    return layer_datas, metaconfig, subconfig, err_warn


def get_output(rougailconfig, metaconfig, config, err_warn, layer_datas):
    # output
    output_name = rougailconfig["step.output"]
    path = Path(__file__).parent.parent / ("output_" + output_name) / "__init__.py"
    if not path.is_file():
        raise Exception(
            _('cannot find cli file for "output_name" module "{0}"').format(output_name)
        )
    module = load_modules("rougail.output_" + output_name, str(path))
    root = rougailconfig["cli.root"]
    if root:
        subconfig = config.option(root)
    else:
        subconfig = config
    output = module.RougailOutput(
        config=subconfig,
        true_config=config,
        rougailconfig=rougailconfig,
        user_data_errors=err_warn["errors"],
        user_data_warnings=err_warn["warnings"],
        config_owner_is_path=True,
        root_config=metaconfig,
        layer_datas=layer_datas,
    )
    return output


def main(arguments=None, do_not_print=False):
    global print_traceback
    print_traceback = True
    try:
        return _main(arguments, do_not_print)
    except Exception as err:
        if print_traceback:
            import traceback

            traceback.print_exc()
        exit(_("ERROR: {0}").format(err))