"""Explicit, local-only source adapter for the first document-ingestion slice."""

from __future__ import annotations

import mimetypes
from dataclasses import dataclass
from pathlib import Path

from cyberbrain26.knowledge_plane.contracts import (
    DocumentRegistration,
    DocumentTrust,
    KnowledgeDocument,
    KnowledgeSource,
    Sensitivity,
)
from cyberbrain26.knowledge_plane.embedding_service import EmbeddingService
from cyberbrain26.knowledge_plane.repository import SQLiteKnowledgeRepository
from cyberbrain26.knowledge_plane.vector_store import KnowledgeVectorStore


@dataclass(frozen=True)
class LocalDirectorySource:
    """A user-approved directory that may supply registrations.

    This adapter registers metadata and a digest only.  It does not parse the
    file, create embeddings, copy originals, watch the directory, or grant any
    network access.  Those operations remain separate capabilities because
    their failure and privacy boundaries differ.
    """

    source_id: str
    root: Path
    trust: DocumentTrust = DocumentTrust.EXTERNAL
    sensitivity: Sensitivity = Sensitivity.PERSONAL

    def register_file(
        self,
        repository: SQLiteKnowledgeRepository,
        path: str | Path,
        *,
        vector_store: KnowledgeVectorStore | None = None,
        embedding_service: EmbeddingService | None = None,
    ) -> tuple[KnowledgeDocument, bool]:
        root = self.root.expanduser().resolve(strict=True)
        candidate = Path(path).expanduser().resolve(strict=True)
        if not candidate.is_file():
            raise ValueError("knowledge source path must be an existing regular file")
        try:
            relative_path = candidate.relative_to(root)
        except ValueError as error:
            raise PermissionError("knowledge source path is outside the approved root") from error

        media_type, _ = mimetypes.guess_type(candidate.name)
        registration = DocumentRegistration(
            source=KnowledgeSource(
                source_id=self.source_id,
                source_uri=f"file:///{relative_path.as_posix()}",
                trust=self.trust,
                sensitivity=self.sensitivity,
                approved=True,
                metadata={"root_name": root.name},
            ),
            content=candidate.read_bytes(),
            media_type=media_type or "application/octet-stream",
            metadata={"relative_path": relative_path.as_posix(), "filename": candidate.name},
        )
        return repository.register(
            registration,
            vector_store=vector_store,
            embedding_service=embedding_service,
        )


__all__ = ["LocalDirectorySource"]