"""
Lightweight dependency-injection container.

The Container is a plain dataclass that holds fully-configured service
instances. It is built once at CLI startup (or test setup) and threaded
through all commands via Typer's callback context object.

Usage (CLI):
    @app.callback()
    def main(ctx: typer.Context) -> None:
        ctx.obj = Container.build()

Usage (tests):
    container = Container.build(settings=fake_settings)
    container.collector = FakeCollector()
"""

from __future__ import annotations

from dataclasses import dataclass, field
from typing import TYPE_CHECKING

from app.utils.config import Settings, get_settings
from app.utils.logging import setup_logging

if TYPE_CHECKING:
    from app.collectors.base import CollectorProtocol
    from app.dedup.registry import DedupRegistry
    from app.exporters.hf import HFExporter
    from app.exporters.jsonl import JsonlExporter
    from app.exporters.parquet import ParquetExporter
    from app.metadata.extractor import MetadataExtractor
    from app.preview.renderer import PreviewRenderer
    from app.validators.content import ContentValidator
    from app.validators.schema import SchemaValidator


@dataclass
class Container:
    """
    Resolved service graph for the KDC application.

    All services are injected as concrete instances but typed against
    their Protocol / base class for testability.
    """

    settings: Settings

    # Services (populated by build())
    collector: CollectorProtocol | None = field(default=None, repr=False)
    extractor: MetadataExtractor | None = field(default=None, repr=False)
    renderer: PreviewRenderer | None = field(default=None, repr=False)
    schema_validator: SchemaValidator | None = field(default=None, repr=False)
    content_validator: ContentValidator | None = field(default=None, repr=False)
    dedup_registry: DedupRegistry | None = field(default=None, repr=False)
    parquet_exporter: ParquetExporter | None = field(default=None, repr=False)
    jsonl_exporter: JsonlExporter | None = field(default=None, repr=False)
    hf_exporter: HFExporter | None = field(default=None, repr=False)

    # ── Factory ───────────────────────────────────────────────────────────────

    @classmethod
    def build(cls, settings: Settings | None = None) -> Container:
        """
        Instantiate and wire all services from Settings.

        Imports are local to avoid circular dependencies at module level.
        """
        from app.collectors.local import LocalCollector
        from app.dedup.registry import DedupRegistry
        from app.exporters.hf import HFExporter
        from app.exporters.jsonl import JsonlExporter
        from app.exporters.parquet import ParquetExporter
        from app.metadata.extractor import MetadataExtractor
        from app.preview.renderer import PreviewRenderer
        from app.validators.content import ContentValidator
        from app.validators.schema import SchemaValidator

        cfg = settings or get_settings()

        # Configure logging from settings
        setup_logging(
            level=cfg.logging.level,
            sink_file=cfg.logging.sink_file,
            rotation=cfg.logging.rotation,
            retention=cfg.logging.retention,
        )

        return cls(
            settings=cfg,
            collector=LocalCollector(pdf_dir=cfg.paths.pdf_dir),
            extractor=MetadataExtractor(
                fallback_to_pypdf=cfg.metadata.fallback_to_pypdf,
            ),
            renderer=PreviewRenderer(
                out_dir=cfg.paths.preview_dir,
                dpi=cfg.preview.dpi,
                fmt=cfg.preview.format,
                max_pages=cfg.preview.max_pages,
            ),
            schema_validator=SchemaValidator(),
            content_validator=ContentValidator(
                min_file_size_kb=cfg.metadata.min_file_size_kb,
                max_file_size_mb=cfg.metadata.max_file_size_mb,
            ),
            dedup_registry=DedupRegistry(
                registry_path=cfg.paths.dedup_registry,
                enabled=cfg.dedup.enabled,
            ),
            parquet_exporter=ParquetExporter(
                out_dir=cfg.paths.datasets_dir,
            ),
            jsonl_exporter=JsonlExporter(
                out_dir=cfg.paths.datasets_dir,
            ),
            hf_exporter=HFExporter(
                repo_id=cfg.huggingface.repo_id,
                token=cfg.huggingface.token,
            ),
        )