# SPDX-FileCopyrightText: Peter Pentchev <roam@ringlet.net>
# SPDX-License-Identifier: BSD-2-Clause

"""Query a program's list of features."""

from __future__ import annotations

import dataclasses
import sys
from typing import Final

import click


try:
    import simplejson as js
except ImportError:
    import json as js  # type: ignore[no-redef]

from . import defs
from . import expr as fexpr
from . import obtain
from . import parser as fparser
from . import version as fver


@dataclasses.dataclass(frozen=True)
class Config:
    """Runtime configuration for this program."""

    args: list[str]
    display_version: bool
    features_prefix: str
    option_name: str
    output_format: str

    program: str = "(unknown)"


def arg_version(_ctx: click.Context, _self: click.Parameter, value: bool) -> bool:  # noqa: FBT001
    """Display program version information."""
    if not value:
        return value

    print(f"feature-check {defs.VERSION}")
    sys.exit(0)


def arg_features(_ctx: click.Context, _self: click.Parameter, value: bool) -> bool:  # noqa: FBT001
    """Display program features information."""
    if not value:
        return value

    print(f"{defs.DEFAULT_PREFIX}feature-check={defs.VERSION} single=1.0 list=1.0 simple=1.0")
    sys.exit(0)


def output_tsv(data: dict[str, fver.Version]) -> None:
    """List the obtained features as tab-separated name/value pairs."""
    for feature in sorted(data.keys()):
        print(f"{feature}\t{data[feature].value}")


def output_json(data: dict[str, fver.Version]) -> None:
    """List the obtained features as a JSON object."""
    print(
        js.dumps(
            {name: value.value for name, value in data.items()},
            sort_keys=True,
            indent=2,
        ),
    )


OUTPUT = {"tsv": output_tsv, "json": output_json}


def process(mode: defs.Mode, cfg: Config, data: dict[str, fver.Version]) -> None:
    """Perform the requested feature-check operation."""
    match mode:
        case defs.ModeList():
            OUTPUT[cfg.output_format](data)

        case defs.ModeSingle(feature, _):
            if feature in data:
                if cfg.display_version:
                    print(data[feature].value)
                sys.exit(0)
            else:
                sys.exit(1)

        case defs.ModeSimple(ast):
            res: Final = ast.evaluate(data)
            if not isinstance(res, fexpr.ResultBool):
                sys.exit(f"Internal error: did not expect a {type(res).__name__} object")
            sys.exit(not res.value)

        case _:
            sys.exit(f"Internal error: process(mode={mode!r}, cfg={cfg!r}, data={data!r}")


@click.command(name="feature-check")
@click.help_option("--help", "-h")
@click.option(
    "--version",
    "-V",
    is_flag=True,
    is_eager=True,
    callback=arg_version,
    help="display program version information and exit",
)
@click.option(
    "--features",
    is_flag=True,
    is_eager=True,
    callback=arg_features,
    help="display supported features and exit",
)
@click.option(
    "-v",
    "--display-version",
    is_flag=True,
    help="display the feature version",
)
@click.option(
    "-P",
    "--features-prefix",
    type=str,
    default=defs.DEFAULT_PREFIX,
    help="the features prefix in the program output",
)
@click.option(
    "-l",
    "--list",
    "opt_list",
    is_flag=True,
    help="list the features supported by a program",
)
@click.option(
    "-O",
    "--option-name",
    type=str,
    default=defs.DEFAULT_OPTION,
    help="the query-features option to pass",
)
@click.option(
    "-o",
    "--output-format",
    type=click.Choice(sorted(OUTPUT.keys())),
    default=defs.DEFAULT_OUTPUT_FMT,
    help="specify the output format for the list",
)
@click.argument("program", type=str)
@click.argument("feature", type=str, required=False)
@click.argument("op", type=str, required=False)
@click.argument("feature_version", type=str, required=False, metavar="VERSION")
@click.pass_context
def main(  # noqa: PLR0913  # yep, we accept a lot of command-line options
    ctx: click.Context,
    *,
    program: str,
    feature: str | None,
    op: str | None,
    display_version: bool,
    feature_version: str | None,
    features: bool,
    features_prefix: str,
    opt_list: bool,
    option_name: str,
    output_format: str,
    version: bool,
) -> None:
    """Parse command-line arguments, do things."""

    def parse_mode() -> defs.Mode:
        """Determine the mode of operation."""
        if opt_list:
            return defs.ModeList()

        if not cfg.args:
            ctx.fail("No feature specified")
        expr: Final = " ".join(cfg.args)
        try:
            return fparser.parse_expr(expr)
        except fparser.ParseError:
            ctx.fail("Only querying a single feature supported so far")

    if features or version:
        ctx.fail(f"How did we get to main() with {features=!r} and {version=!r}?")

    cfg: Final = Config(
        program=program,
        args=[value for value in [feature, op, feature_version] if value is not None],
        display_version=display_version,
        features_prefix=features_prefix,
        option_name=option_name,
        output_format=output_format,
    )

    mode: Final = parse_mode()

    try:
        data: Final = obtain.obtain_features(cfg.program, cfg.option_name, cfg.features_prefix)
    except obtain.ObtainError as exc:
        sys.exit(exc.code)

    process(mode, cfg, data)


if __name__ == "__main__":
    main()