"""Configuration loading, filesystem layout and logging setup."""
from __future__ import annotations

import copy
import logging
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Any

import yaml

PROJECT_ROOT = Path(__file__).resolve().parent.parent


def load_yaml(path: Path) -> dict[str, Any]:
    with open(path, "r", encoding="utf-8") as fh:
        return yaml.safe_load(fh) or {}


def deep_update(base: dict, override: dict) -> dict:
    """Recursively merge ``override`` into ``base`` (in place) and return it."""
    for key, value in override.items():
        if isinstance(value, dict) and isinstance(base.get(key), dict):
            deep_update(base[key], value)
        else:
            base[key] = copy.deepcopy(value)
    return base


def load_config(path: str | Path | None = None, overrides: dict | None = None) -> dict[str, Any]:
    cfg_path = Path(path) if path else PROJECT_ROOT / "config" / "config.yaml"
    cfg = load_yaml(cfg_path)
    cfg["_config_dir"] = str(cfg_path.resolve().parent)
    if overrides:
        deep_update(cfg, overrides)
    return cfg


def load_taxonomy(cfg: dict) -> dict[str, Any]:
    return load_yaml(Path(cfg["_config_dir"]) / "taxonomy.yaml")


def load_queries(cfg: dict) -> dict[str, Any]:
    return load_yaml(Path(cfg["_config_dir"]) / "queries.yaml")


@dataclass(frozen=True)
class Paths:
    """Filesystem layout. Manifest paths are stored relative to ``data``."""

    base: Path
    data: Path
    originals: Path
    images: Path
    review: Path
    realworld: Path
    reports: Path
    splits: Path
    manifest_db: Path
    manifest_jsonl: Path

    def abs(self, rel: str | Path) -> Path:
        return self.data / rel

    def rel(self, path: str | Path) -> str:
        return str(Path(path).resolve().relative_to(self.data.resolve()))

    def ensure(self) -> None:
        for p in (self.data, self.originals, self.images, self.review, self.realworld,
                  self.reports, self.splits):
            p.mkdir(parents=True, exist_ok=True)


def get_paths(cfg: dict, base: str | Path | None = None) -> Paths:
    base_dir = Path(base).resolve() if base else PROJECT_ROOT
    pcfg = cfg.get("paths", {})
    data = base_dir / pcfg.get("data_dir", "data")
    return Paths(
        base=base_dir,
        data=data,
        originals=data / "originals",
        images=data / "images",
        review=data / "review",
        realworld=data / "realworld",
        reports=base_dir / pcfg.get("reports_dir", "reports"),
        splits=base_dir / pcfg.get("splits_dir", "splits"),
        manifest_db=data / "manifest.db",
        manifest_jsonl=data / "manifest.jsonl",
    )


def setup_logging(verbose: bool = False) -> None:
    """Configure logging *before* icrawler is imported.

    icrawler calls ``logging.basicConfig`` when a crawler is constructed; that is a
    no-op once the root logger already has handlers, so configuring first keeps our
    format and level in charge.
    """
    level = logging.DEBUG if verbose else logging.INFO
    root = logging.getLogger()
    if not root.handlers:
        handler = logging.StreamHandler(sys.stderr)
        handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-7s %(name)s: %(message)s",
                                               datefmt="%H:%M:%S"))
        root.addHandler(handler)
    root.setLevel(level)
    logging.getLogger("urllib3").setLevel(logging.WARNING)
    logging.getLogger("PIL").setLevel(logging.WARNING)