"""Document / resume / JD parsing."""

from __future__ import annotations

import base64

from app.schemas.common import JobStatus
from app.schemas.documents import (
    DocumentParseRequest,
    DocumentParseResponse,
    ParseTarget,
    ParsedBlock,
)
from app.services.ai_generate import generate_json


class DocumentsService:
    async def parse(self, payload: DocumentParseRequest) -> DocumentParseResponse:
        raw_text = ""
        if payload.content_base64:
            try:
                raw_text = base64.b64decode(payload.content_base64).decode(
                    "utf-8", errors="replace"
                )
            except Exception:
                raw_text = ""
        source_hint = payload.source_url or payload.filename or "document"

        system = (
            "You extract structured data from documents. "
            "Return JSON: {\"raw_text\",\"blocks\":[{\"block_id\",\"block_type\",\"text\",\"page\"}],"
            "\"structured\":{...}}"
        )
        user = (
            f"parse_target={payload.parse_target.value}\n"
            f"document_type={payload.document_type.value}\n"
            f"language={payload.language}\n"
            f"source={source_hint}\n"
            f"content:\n{raw_text[:8000] or '(binary/url source — extract what you can)'}"
        )

        def local() -> dict:
            structured: dict = {}
            if payload.parse_target == ParseTarget.RESUME:
                structured = {
                    "name": None,
                    "email": None,
                    "skills": [],
                    "experience": [],
                    "education": [],
                    "summary": raw_text[:500] or None,
                }
            elif payload.parse_target == ParseTarget.JOB_DESCRIPTION:
                structured = {
                    "title": None,
                    "responsibilities": [],
                    "requirements": [],
                    "skills": [],
                }
            blocks = []
            if raw_text:
                for i, para in enumerate([p for p in raw_text.split("\n\n") if p.strip()][:20]):
                    blocks.append(
                        {
                            "block_id": f"b-{i + 1}",
                            "block_type": "paragraph",
                            "text": para.strip()[:2000],
                            "page": 1,
                        }
                    )
            return {"raw_text": raw_text or None, "blocks": blocks, "structured": structured}

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        blocks = [
            ParsedBlock(
                block_id=str(b.get("block_id", f"b-{i}")),
                block_type=str(b.get("block_type", "paragraph")),
                text=str(b.get("text", "")),
                page=b.get("page"),
                metadata=b.get("metadata") or {},
            )
            for i, b in enumerate(data.get("blocks") or [])
            if isinstance(b, dict)
        ]
        return DocumentParseResponse(
            correlation_id=payload.correlation_id,
            document_type=payload.document_type,
            parse_target=payload.parse_target,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Parsed document via {provider}",
            raw_text=data.get("raw_text") if data.get("raw_text") is not None else (raw_text or None),
            blocks=blocks,
            structured=data.get("structured") or {},
        )