"""Central resume fetch / parse / normalize / versioned store.

All gateway flows should call ``ResumeService.resolve`` (or ``get_profile``)
instead of re-fetching, re-parsing, or re-structuring resumes ad hoc.
Uses ``DocumentsService.parse`` in-process — never HTTP self-calls.
"""

from __future__ import annotations

import hashlib
import json
import logging
from typing import Any

from app.schemas.documents import DocumentParseRequest, DocumentType, ParseTarget
from app.schemas.resume_profile import ResumeProfileResult
from app.services.screening.document_extract import structure_resume
from app.services.screening.documents import DocumentsService
from app.services.screening import resume_store

logger = logging.getLogger(__name__)


def _sha256_text(value: str) -> str:
    return hashlib.sha256(value.encode("utf-8")).hexdigest()


def _content_hash(
    *,
    content_base64: str | None = None,
    source_url: str | None = None,
    resume_text: str | None = None,
    resume_structured: dict[str, Any] | None = None,
) -> str | None:
    if content_base64 and content_base64.strip():
        return _sha256_text("b64:" + content_base64.strip())
    if source_url and source_url.strip():
        return _sha256_text("url:" + source_url.strip())
    if resume_text and resume_text.strip():
        return _sha256_text("text:" + resume_text.strip())
    if resume_structured:
        blob = json.dumps(resume_structured, sort_keys=True, default=str)
        return _sha256_text("struct:" + blob)
    return None


def _row_to_result(row: Any, *, reused: bool, source: str) -> ResumeProfileResult:
    blocks = row.blocks if isinstance(row.blocks, list) else []
    return ResumeProfileResult(
        profile_id=row.profile_id,
        candidate_id=row.candidate_id,
        company_id=row.company_id,
        resume_version=int(row.resume_version or 1),
        content_hash=row.content_hash,
        raw_text=row.raw_text or "",
        structured=dict(row.structured or {}),
        blocks=[b for b in blocks if isinstance(b, dict)],
        reused=reused,
        source=source,
        document_type=row.document_type,
        filename=row.filename,
        source_url=row.source_url,
    )


class ResumeService:
    def __init__(self, *, documents: DocumentsService | None = None) -> None:
        self._documents = documents or DocumentsService()

    def get_profile(self, candidate_id: str) -> ResumeProfileResult | None:
        """Return latest stored profile for candidate_id, or None."""
        row = resume_store.get_latest(candidate_id)
        if row is None:
            return None
        return _row_to_result(row, reused=True, source="cached")

    async def resolve(
        self,
        *,
        candidate_id: str | None = None,
        company_id: str | None = None,
        content_base64: str | None = None,
        source_url: str | None = None,
        resume_text: str | None = None,
        resume_structured: dict[str, Any] | None = None,
        document_type: DocumentType | str = DocumentType.PDF,
        filename: str | None = None,
        language: str = "en",
        force_reparse: bool = False,
        persist: bool = True,
    ) -> ResumeProfileResult:
        """Resolve a canonical resume profile.

        Reuse rules (when ``candidate_id`` is set and ``force_reparse`` is false):
        1. Same content_hash already stored → return that version (no parse).
        2. No new media/text provided → return latest stored profile.
        3. Otherwise parse (or normalize provided text) and save a new version.
        """
        cid = (candidate_id or "").strip() or None
        company = (company_id or "").strip() or None
        text_in = (resume_text or "").strip() or None
        structured_in = dict(resume_structured or {})
        has_media = bool(content_base64) or bool(source_url)
        has_provided = bool(text_in) or bool(structured_in)
        content_hash = _content_hash(
            content_base64=content_base64,
            source_url=source_url,
            resume_text=text_in,
            resume_structured=structured_in if structured_in else None,
        )

        if cid and not force_reparse:
            if content_hash:
                hit = resume_store.get_by_candidate_hash(cid, content_hash)
                if hit is not None:
                    logger.info(
                        "resume_cache_hit candidate_id=%s hash=%s version=%s",
                        cid,
                        content_hash[:12],
                        hit.resume_version,
                    )
                    return _row_to_result(hit, reused=True, source="cached")
            if not has_media and not has_provided:
                latest = resume_store.get_latest(cid)
                if latest is not None:
                    return _row_to_result(latest, reused=True, source="cached")

        # Parse from document bytes/URL via DocumentsService (shared pipeline).
        if has_media:
            dtype = document_type
            if isinstance(dtype, str):
                try:
                    dtype = DocumentType(dtype)
                except ValueError:
                    dtype = DocumentType.PDF
            parse_resp = await self._documents.parse(
                DocumentParseRequest(
                    document_type=dtype,
                    parse_target=ParseTarget.RESUME,
                    content_base64=content_base64,
                    source_url=source_url,
                    filename=filename,
                    language=language,
                )
            )
            raw = (parse_resp.raw_text or "").strip()
            structured = dict(parse_resp.structured or {})
            if not structured and raw:
                structured = structure_resume(raw)
            blocks = [
                b.model_dump(mode="json") if hasattr(b, "model_dump") else dict(b)
                for b in (parse_resp.blocks or [])
            ]
            ch = content_hash or _content_hash(resume_text=raw, resume_structured=structured)
            result = ResumeProfileResult(
                candidate_id=cid,
                company_id=company,
                content_hash=ch,
                raw_text=raw,
                structured=structured,
                blocks=blocks,
                reused=False,
                source="parsed",
                document_type=dtype.value if hasattr(dtype, "value") else str(dtype),
                filename=filename,
                source_url=source_url,
            )
            if cid and persist and ch:
                row = resume_store.save_profile(
                    candidate_id=cid,
                    company_id=company,
                    content_hash=ch,
                    raw_text=raw,
                    structured=structured,
                    blocks=blocks,
                    source_url=source_url,
                    filename=filename,
                    document_type=result.document_type,
                    meta={"source": "parsed"},
                )
                result.profile_id = row.profile_id
                result.resume_version = int(row.resume_version)
                result.reused = False
                result.source = "parsed"
            return result

        # Normalize provided text / structured without re-fetching a file.
        if has_provided:
            raw = text_in or ""
            structured = structured_in
            if raw and not structured:
                structured = structure_resume(raw)
            elif structured and not raw:
                # Reconstruct a lightweight text blob for consumers that need it
                skills = structured.get("skills") or []
                summary = structured.get("summary") or ""
                raw = (
                    f"{structured.get('name') or ''}\n"
                    f"{structured.get('title') or ''}\n"
                    f"{summary}\n"
                    f"Skills: {', '.join(str(s) for s in skills)}"
                ).strip()
            ch = content_hash or _content_hash(
                resume_text=raw or None,
                resume_structured=structured or None,
            )
            source = (
                "provided_structured"
                if structured_in and not text_in
                else "provided_text"
            )
            result = ResumeProfileResult(
                candidate_id=cid,
                company_id=company,
                content_hash=ch,
                raw_text=raw,
                structured=structured,
                blocks=[],
                reused=False,
                source=source,
                filename=filename,
                source_url=source_url,
            )
            if cid and persist and ch and (raw or structured):
                row = resume_store.save_profile(
                    candidate_id=cid,
                    company_id=company,
                    content_hash=ch,
                    raw_text=raw or None,
                    structured=structured,
                    blocks=[],
                    source_url=source_url,
                    filename=filename,
                    document_type=None,
                    meta={"source": source},
                )
                result.profile_id = row.profile_id
                result.resume_version = int(row.resume_version)
            return result

        # Nothing to resolve
        if cid:
            latest = resume_store.get_latest(cid)
            if latest is not None:
                return _row_to_result(latest, reused=True, source="cached")

        return ResumeProfileResult(
            candidate_id=cid,
            company_id=company,
            raw_text="",
            structured={},
            reused=False,
            source="empty",
        )
