"""Load and look up packages in lpip-sources.toml."""

from __future__ import annotations

import re
import tomllib
from dataclasses import dataclass, replace
from pathlib import Path

import tomlkit
from packaging.utils import canonicalize_name
from tomlkit.exceptions import TOMLKitError

from lpip.cache import (
    CatalogCachePaths,
    catalog_cache_paths,
    ensure_catalog_checkout,
    purge_catalog_cache,
)
from lpip.errors import (
    CatalogAlreadyExistsError,
    CatalogFileNotFoundError,
    CatalogSchemaError,
    DisallowedSchemeError,
    InvalidPackageNameError,
    MissingRevisionError,
    PackageAlreadyExistsError,
    SubdirectoryEscapeError,
    TomlParseError,
    UnknownPackageError,
    UnknownTomlKeyError,
    UnsupportedAuthoringUrlError,
)
from lpip.models import (
    EffectiveConfig,
    PackageSource,
    PolicyConfig,
    RefreshMode,
    SourceConfig,
    SourceType,
)
from lpip.validation import (
    CATALOG_TOP_KEYS,
    PACKAGE_FIELD_KEYS,
    first_unknown_key,
    normalize_authoring_git_url,
    optional_str,
    subdirectory_escapes_repo,
    url_scheme,
)

PACKAGE_NAME_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._+-]*$")
DEFAULT_CATALOG_FILENAME = "lpip-sources.toml"
CATALOG_INIT_TEMPLATE = """\
# lpip package catalog
# Commit this file in the catalog Git repository. Consumers fetch it
# (source.type = git). Add packages with: lpip catalog add

[packages]

# Example:
# [packages.libfoo]
# url = "git+ssh://git.company/libs/libfoo.git"
# revision = "main"
# subdirectory = "python"
"""


@dataclass(frozen=True)
class Catalog:
    path: Path
    packages: tuple[PackageSource, ...]

    def find(self, name: str) -> PackageSource | None:
        """Match a distribution name, ignoring PEP 503 normalization."""
        want = canonicalize_name(name)
        for pkg in self.packages:
            if canonicalize_name(pkg.name) == want:
                return pkg
        return None

    def get(self, name: str) -> PackageSource:
        for pkg in self.packages:
            if pkg.name == name:
                return pkg
        raise UnknownPackageError(name, catalog_path=self.path)

    def sorted_by_name(self) -> tuple[PackageSource, ...]:
        return tuple(sorted(self.packages, key=lambda p: p.name))


def load_catalog(path: Path, policy: PolicyConfig | None = None) -> Catalog:
    """Parse and validate a catalog file (AC-0003, AC-0010, AC-0011)."""
    policy = policy or PolicyConfig()
    catalog_path = path.expanduser()
    if not catalog_path.is_file():
        raise CatalogFileNotFoundError(catalog_path)

    try:
        with catalog_path.open("rb") as fh:
            data = tomllib.load(fh)
    except tomllib.TOMLDecodeError as exc:
        raise TomlParseError(catalog_path, detail=str(exc)) from exc

    unknown_top = first_unknown_key(data, CATALOG_TOP_KEYS)
    if unknown_top is not None:
        raise UnknownTomlKeyError(unknown_top, path=catalog_path, kind="catalog")
    if "packages" not in data:
        raise CatalogSchemaError(
            "Catalog is missing the packages table.",
            path=catalog_path,
            hint="Add a [packages.<name>] table for each installable package.",
        )
    packages_raw = data["packages"]
    if not isinstance(packages_raw, dict):
        raise CatalogSchemaError(
            "'packages' must be a TOML table of package names.",
            path=catalog_path,
        )

    loaded: list[PackageSource] = []
    for name, body in packages_raw.items():
        loaded.append(_package_from_table(name, body, catalog_path, policy))
    return Catalog(path=catalog_path, packages=tuple(loaded))


def _package_from_table(
    name: str,
    body: object,
    catalog_path: Path,
    policy: PolicyConfig,
) -> PackageSource:
    if not isinstance(body, dict):
        raise CatalogSchemaError(
            f"Package {name!r} must be a table of fields.",
            path=catalog_path,
        )
    unknown = first_unknown_key(body, PACKAGE_FIELD_KEYS)
    if unknown is not None:
        raise UnknownTomlKeyError(
            f"packages.{name}.{unknown}",
            path=catalog_path,
            kind="catalog",
        )
    if "url" not in body:
        raise CatalogSchemaError(
            f"Package {name!r} is missing required field 'url'.",
            path=catalog_path,
        )
    url = body["url"]
    if not isinstance(url, str) or not url.strip():
        raise CatalogSchemaError(
            f"Package {name!r} field 'url' must be a non-empty string.",
            path=catalog_path,
        )
    url = url.strip()
    scheme = url_scheme(url)
    if scheme not in {s.lower() for s in policy.allowed_schemes}:
        raise DisallowedSchemeError(
            url,
            allowed=policy.allowed_schemes,
            catalog_path=catalog_path,
        )

    try:
        revision = optional_str(body.get("revision"))
        subdirectory = optional_str(body.get("subdirectory"))
    except TypeError as exc:
        raise CatalogSchemaError(
            f"Package {name!r} has a non-string optional field: {exc}",
            path=catalog_path,
        ) from exc

    if policy.require_pinned_revision and revision is None:
        raise MissingRevisionError(name, catalog_path=catalog_path)

    if subdirectory is not None and subdirectory_escapes_repo(subdirectory):
        raise SubdirectoryEscapeError(subdirectory, catalog_path=catalog_path)

    return PackageSource(name=name, url=url, revision=revision, subdirectory=subdirectory)


def local_catalog_path(cfg: EffectiveConfig, *, cwd: Path) -> Path:
    return local_path_for_source(cfg.source, cwd=cwd)


def local_path_for_source(source: SourceConfig, *, cwd: Path) -> Path:
    raw = Path(source.path).expanduser()
    return raw if raw.is_absolute() else (cwd / raw)


@dataclass(frozen=True)
class ResolvedCatalogLocation:
    catalog_file: Path
    cache: CatalogCachePaths | None


def catalog_file_in_repo(repo: Path, source_path: str) -> Path:
    if subdirectory_escapes_repo(source_path.replace("\\", "/")):
        raise SubdirectoryEscapeError(source_path)
    path = repo / source_path
    if not path.is_file():
        raise CatalogFileNotFoundError(path)
    return path


def resolve_source_location(
    source: SourceConfig,
    *,
    cwd: Path,
    cache_home: Path | None = None,
    force_refresh: bool = False,
) -> ResolvedCatalogLocation:
    """Resolve one configured catalog (ADR-0021)."""
    if source.type is SourceType.FILE:
        return ResolvedCatalogLocation(
            catalog_file=local_path_for_source(source, cwd=cwd),
            cache=None,
        )
    if not source.url:
        raise CatalogSchemaError(
            "source.url is required when source.type is git.",
            hint="Set source.url in config.toml or LPIP_SOURCE_URL.",
        )
    refresh = source.refresh or RefreshMode.AUTO
    cache = ensure_catalog_checkout(
        source.url,
        source.revision,
        cache_home=cache_home,
        refresh=refresh,
        force_refresh=force_refresh,
    )
    return ResolvedCatalogLocation(
        catalog_file=catalog_file_in_repo(cache.repo, source.path),
        cache=cache,
    )


def resolve_catalog_location(
    cfg: EffectiveConfig,
    *,
    cwd: Path,
    cache_home: Path | None = None,
    force_refresh: bool = False,
) -> ResolvedCatalogLocation:
    """Resolve the first catalog source."""
    return resolve_source_location(
        cfg.source,
        cwd=cwd,
        cache_home=cache_home,
        force_refresh=force_refresh,
    )


def git_sources(cfg: EffectiveConfig) -> tuple[SourceConfig, ...]:
    return tuple(src for src in cfg.sources if src.type is SourceType.GIT and src.url)


def planned_git_cache_paths_for(source: SourceConfig) -> CatalogCachePaths:
    if source.type is not SourceType.GIT or not source.url:
        raise CatalogSchemaError(
            "source.type must be git with a url to use the catalog cache.",
            hint='Set source.type = "git" and source.url.',
        )
    return catalog_cache_paths(source.url, source.revision)


def planned_git_cache_paths(cfg: EffectiveConfig) -> CatalogCachePaths:
    return planned_git_cache_paths_for(cfg.source)


def purge_git_catalog_cache(cfg: EffectiveConfig) -> CatalogCachePaths:
    if cfg.source.type is not SourceType.GIT or not cfg.source.url:
        raise CatalogSchemaError(
            "source.type must be git with a url to purge the catalog cache.",
            hint='Set source.type = "git" and source.url.',
        )
    return purge_catalog_cache(cfg.source.url, cfg.source.revision)


def purge_all_git_catalog_caches(cfg: EffectiveConfig) -> tuple[CatalogCachePaths, ...]:
    caches = tuple(
        purge_catalog_cache(src.url, src.revision)
        for src in git_sources(cfg)
        if src.url is not None
    )
    if not caches:
        raise CatalogSchemaError(
            "source.type must be git with a url to purge the catalog cache.",
            hint='Set source.type = "git" and source.url.',
        )
    return caches


@dataclass(frozen=True)
class PackageNameClash:
    """One shadowed package name across catalog sources (AC-0026)."""

    name: str
    winner_source: str
    shadowed_source: str
    identical: bool


def _package_definition(package: PackageSource) -> tuple[str, str | None, str | None]:
    return (package.url, package.revision, package.subdirectory)


def load_merged_catalog(
    cfg: EffectiveConfig,
    *,
    cwd: Path,
    cache_home: Path | None = None,
    force_refresh: bool = False,
) -> tuple[Catalog, tuple[PackageNameClash, ...]]:
    """Load every configured source; first package name wins (ADR-0021)."""
    merged: list[PackageSource] = []
    first_by_key: dict[str, PackageSource] = {}
    clashes: list[PackageNameClash] = []
    first_path: Path | None = None
    for src in cfg.sources:
        location = resolve_source_location(
            src,
            cwd=cwd,
            cache_home=cache_home,
            force_refresh=force_refresh,
        )
        if first_path is None:
            first_path = location.catalog_file
        catalog = load_catalog(location.catalog_file, cfg.policy)
        for pkg in catalog.packages:
            tagged = replace(pkg, catalog_source=src.name)
            key = canonicalize_name(pkg.name)
            winner = first_by_key.get(key)
            if winner is None:
                first_by_key[key] = tagged
                merged.append(tagged)
                continue
            clashes.append(
                PackageNameClash(
                    name=winner.name,
                    winner_source=winner.catalog_source or "default",
                    shadowed_source=src.name,
                    identical=_package_definition(winner) == _package_definition(pkg),
                )
            )
    return (
        Catalog(
            path=first_path or (cwd / DEFAULT_CATALOG_FILENAME),
            packages=tuple(merged),
        ),
        tuple(clashes),
    )


def load_catalog_for_config(
    cfg: EffectiveConfig,
    *,
    cwd: Path,
    cache_home: Path | None = None,
    force_refresh: bool = False,
) -> Catalog:
    catalog, _clashes = load_merged_catalog(
        cfg,
        cwd=cwd,
        cache_home=cache_home,
        force_refresh=force_refresh,
    )
    return catalog


def normalize_package_for_catalog(package: PackageSource) -> PackageSource:
    """Normalize authoring URL; fail if the scheme is not a supported Git form."""
    stored = normalize_authoring_git_url(package.url)
    scheme = url_scheme(stored)
    if scheme not in {"git+ssh", "git+https", "git+file"}:
        raise UnsupportedAuthoringUrlError(package.url)
    return PackageSource(
        name=package.name,
        url=stored,
        revision=package.revision,
        subdirectory=package.subdirectory,
    )


def _validate_new_package(package: PackageSource, policy: PolicyConfig, catalog_path: Path) -> None:
    if not PACKAGE_NAME_RE.fullmatch(package.name):
        raise InvalidPackageNameError(package.name)
    _package_from_table(
        package.name,
        {
            "url": package.url,
            **({"revision": package.revision} if package.revision else {}),
            **({"subdirectory": package.subdirectory} if package.subdirectory else {}),
        },
        catalog_path,
        policy,
    )


def resolve_authoring_catalog_path(path: str | Path | None, *, cwd: Path) -> Path:
    """Working-tree catalog path (ADR-0015). Does not use consumer source.type."""
    raw = Path(path) if path is not None else Path(DEFAULT_CATALOG_FILENAME)
    raw = raw.expanduser()
    return raw if raw.is_absolute() else (cwd / raw)


def write_catalog_init_template(path: Path) -> Path:
    """Write a commented empty catalog. Fails if the path already exists."""
    if path.exists():
        raise CatalogAlreadyExistsError(path)
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(CATALOG_INIT_TEMPLATE, encoding="utf-8")
    return path


def add_package_to_catalog_file(
    path: Path,
    package: PackageSource,
    *,
    policy: PolicyConfig | None = None,
    force: bool = False,
) -> Path:
    """Append or replace a package table in a working-tree catalog (ADR-0015)."""
    path = path.expanduser()
    policy = policy or PolicyConfig()
    package = normalize_package_for_catalog(package)
    _validate_new_package(package, policy, path)

    if path.is_file():
        try:
            document = tomlkit.parse(path.read_text(encoding="utf-8"))
        except TOMLKitError as exc:
            raise TomlParseError(path, detail=str(exc)) from exc
    else:
        path.parent.mkdir(parents=True, exist_ok=True)
        document = tomlkit.document()
        document.add(tomlkit.comment("lpip package catalog"))

    packages = document.get("packages")
    if packages is None:
        packages = tomlkit.table()
        document["packages"] = packages
    elif not isinstance(packages, dict):
        raise CatalogSchemaError(
            "'packages' must be a TOML table of package names.",
            path=path,
        )
    if package.name in packages and not force:
        raise PackageAlreadyExistsError(package.name, catalog_path=path)

    entry = tomlkit.table()
    entry["url"] = package.url
    if package.revision:
        entry["revision"] = package.revision
    if package.subdirectory:
        entry["subdirectory"] = package.subdirectory
    packages[package.name] = entry
    path.write_text(tomlkit.dumps(document), encoding="utf-8")
    return path