"""Centralized resume input normalization for all resume-dependent flows.

Flow:
  Resume file / resume_text / candidate_id
    → ResumeInputProcessor
    → DocumentsService (via ResumeService) / stored profile
    → normalized resume_text (+ structured)
    → existing business logic

Does **not** reimplement parsing — always delegates to ``ResumeService`` /
``DocumentsService``.
"""

from __future__ import annotations

import base64
import logging
from typing import Any

from fastapi import UploadFile

from app.errors import GatewayError
from app.schemas.documents import DocumentType
from app.schemas.resume_input import has_resume_signal
from app.schemas.resume_profile import ResumeProfileResult
from app.services.screening.resume_service import ResumeService

logger = logging.getLogger(__name__)

_EXT_TO_TYPE: dict[str, DocumentType] = {
    ".pdf": DocumentType.PDF,
    ".docx": DocumentType.DOCX,
    ".doc": DocumentType.DOC,
    ".txt": DocumentType.TXT,
    ".md": DocumentType.MARKDOWN,
    ".markdown": DocumentType.MARKDOWN,
    ".html": DocumentType.HTML,
    ".htm": DocumentType.HTML,
    ".png": DocumentType.IMAGE,
    ".jpg": DocumentType.IMAGE,
    ".jpeg": DocumentType.IMAGE,
    ".webp": DocumentType.IMAGE,
}


def infer_document_type(
    *,
    filename: str | None = None,
    document_type: DocumentType | str | None = None,
    default: DocumentType = DocumentType.PDF,
) -> DocumentType:
    if isinstance(document_type, DocumentType):
        return document_type
    if isinstance(document_type, str) and document_type.strip():
        try:
            return DocumentType(document_type.strip().lower())
        except ValueError:
            pass
    name = (filename or "").strip().lower()
    for ext, dtype in _EXT_TO_TYPE.items():
        if name.endswith(ext):
            return dtype
    return default


class ResumeInputProcessor:
    """Validate + normalize resume inputs; parse only through ResumeService."""

    def __init__(self, *, resumes: ResumeService | None = None) -> None:
        self._resumes = resumes or ResumeService()

    @property
    def resumes(self) -> ResumeService:
        return self._resumes

    async def process(
        self,
        *,
        candidate_id: str | None = None,
        company_id: str | None = None,
        resume_text: str | None = None,
        resume_structured: dict[str, Any] | None = None,
        content_base64: str | None = None,
        source_url: str | None = None,
        file_bytes: bytes | None = None,
        filename: str | None = None,
        document_type: DocumentType | str | None = None,
        language: str = "en",
        force_reparse: bool = False,
        persist: bool | None = None,
        require_resume: bool = True,
    ) -> ResumeProfileResult:
        """Return a normalized profile with ``raw_text`` ready for business logic."""
        b64 = (content_base64 or "").strip() or None
        if file_bytes is not None:
            if not file_bytes:
                raise GatewayError(
                    "Uploaded resume file is empty",
                    code="empty_resume",
                    status_code=400,
                )
            b64 = base64.b64encode(file_bytes).decode("ascii")

        has_input = has_resume_signal(
            candidate_id=candidate_id,
            resume_text=resume_text,
            resume_structured=resume_structured,
            content_base64=b64,
            source_url=source_url,
        )
        if require_resume and not has_input:
            raise GatewayError(
                "Provide resume_text, resume_structured, content_base64/source_url "
                "(or multipart file), or candidate_id for a stored profile",
                code="missing_resume",
                status_code=400,
            )
        if not has_input:
            return ResumeProfileResult(
                candidate_id=(candidate_id or "").strip() or None,
                company_id=(company_id or "").strip() or None,
                raw_text="",
                structured={},
                reused=False,
                source="empty",
            )

        dtype = infer_document_type(
            filename=filename, document_type=document_type
        )
        should_persist = (
            bool(candidate_id and str(candidate_id).strip())
            if persist is None
            else persist
        )

        try:
            profile = await self._resumes.resolve(
                candidate_id=candidate_id,
                company_id=company_id,
                content_base64=b64,
                source_url=source_url,
                resume_text=resume_text,
                resume_structured=resume_structured,
                document_type=dtype,
                filename=filename,
                language=language,
                force_reparse=force_reparse,
                persist=should_persist,
            )
        except GatewayError:
            raise
        except Exception as exc:  # noqa: BLE001
            logger.exception("resume_input_processor_failed")
            raise GatewayError(
                f"Resume parse failed: {exc}",
                code="resume_parse_failed",
                status_code=400,
                details={"reason": str(exc)},
            ) from exc

        text = (profile.raw_text or "").strip()
        structured = dict(profile.structured or {})
        if require_resume and not text and not structured:
            raise GatewayError(
                "Resume document produced no extractable text",
                code="empty_resume",
                status_code=400,
                details={
                    "filename": filename,
                    "document_type": dtype.value,
                    "source": profile.source,
                },
            )

        # Ensure consumers always see normalized resume_text when structured-only.
        if not text and structured:
            skills = structured.get("skills") or []
            text = (
                f"{structured.get('name') or ''}\n"
                f"{structured.get('title') or ''}\n"
                f"{structured.get('summary') or ''}\n"
                f"Skills: {', '.join(str(s) for s in skills)}"
            ).strip()
            profile = profile.model_copy(update={"raw_text": text})

        return profile

    async def process_upload(
        self,
        upload: UploadFile,
        *,
        candidate_id: str | None = None,
        company_id: str | None = None,
        language: str = "en",
        document_type: DocumentType | str | None = None,
        force_reparse: bool = False,
        persist: bool | None = None,
        require_resume: bool = True,
    ) -> ResumeProfileResult:
        """Multipart helper — reads upload bytes then delegates to ``process``."""
        filename = upload.filename or "resume.bin"
        data = await upload.read()
        return await self.process(
            candidate_id=candidate_id,
            company_id=company_id,
            file_bytes=data,
            filename=filename,
            document_type=document_type,
            language=language,
            force_reparse=force_reparse,
            persist=persist,
            require_resume=require_resume,
        )

    def get_profile(self, candidate_id: str) -> ResumeProfileResult | None:
        return self._resumes.get_profile(candidate_id)
