"""Konfigūracijos užkrovimas ir prieiga.

YAML konfigūracija, su galimybe perrašyti reikšmes per aplinkos kintamuosius
(pvz. $TRENDS_DB_PASS perrašys database.password).
"""

from __future__ import annotations

import os
from dataclasses import dataclass, field
from pathlib import Path
from typing import Any, Dict, List

import yaml


_ENV_OVERRIDES = {
    "TRENDS_DB_HOST":   ("database", "host"),
    "TRENDS_DB_PORT":   ("database", "port"),
    "TRENDS_DB_USER":   ("database", "user"),
    "TRENDS_DB_PASS":   ("database", "password"),
    "TRENDS_DB_NAME":   ("database", "database"),
    "NEWSAPI_KEY":      ("api_keys", "newsapi"),
    "GNEWS_KEY":        ("api_keys", "gnews"),
    "MEDIASTACK_KEY":   ("api_keys", "mediastack"),
    "REDDIT_CLIENT_ID": ("api_keys", "reddit_client_id"),
    "REDDIT_CLIENT_SECRET": ("api_keys", "reddit_client_secret"),
}


@dataclass
class Config:
    raw: Dict[str, Any] = field(default_factory=dict)

    # -- Patogūs prieigos metodai ---------------------------------------
    def get(self, *keys, default=None):
        node: Any = self.raw
        for k in keys:
            if not isinstance(node, dict) or k not in node:
                return default
            node = node[k]
        return node

    @property
    def db(self) -> Dict[str, Any]:
        return self.raw.get("database", {})

    @property
    def countries(self) -> List[str]:
        c = self.raw.get("countries", [])
        if isinstance(c, str) and c.upper() == "ALL":
            return ["ALL"]
        return [s.upper() for s in c]

    @property
    def api_keys(self) -> Dict[str, str]:
        return self.raw.get("api_keys", {})

    @property
    def http(self) -> Dict[str, Any]:
        return self.raw.get("http", {})

    @property
    def collectors(self) -> Dict[str, Any]:
        return self.raw.get("collectors", {})

    @property
    def processing(self) -> Dict[str, Any]:
        return self.raw.get("processing", {})

    @property
    def export(self) -> Dict[str, Any]:
        return self.raw.get("export", {})

    @property
    def dashboard(self) -> Dict[str, Any]:
        return self.raw.get("dashboard", {})

    @property
    def logging_cfg(self) -> Dict[str, Any]:
        return self.raw.get("logging", {})


def _apply_env_overrides(data: Dict[str, Any]) -> None:
    for env_key, path in _ENV_OVERRIDES.items():
        val = os.environ.get(env_key)
        if val is None or val == "":
            continue
        node = data
        for k in path[:-1]:
            node = node.setdefault(k, {})
        # bandome konvertuoti į int, jei pavyksta
        if val.isdigit():
            try:
                val = int(val)  # type: ignore[assignment]
            except ValueError:
                pass
        node[path[-1]] = val


def load_config(path: str | os.PathLike = "config.yaml") -> Config:
    p = Path(path)
    if not p.exists():
        raise FileNotFoundError(f"Konfigūracijos failas nerastas: {p}")
    with p.open("r", encoding="utf-8") as f:
        data = yaml.safe_load(f) or {}
    _apply_env_overrides(data)
    return Config(raw=data)