"""Unified manager-clone actions dispatcher (reuses existing enterprise services)."""

from __future__ import annotations

import base64
import logging
from pathlib import Path
from uuid import UUID, uuid4

from fastapi import HTTPException

from app.schemas.common import JobStatus
from app.schemas.enterprise import (
    ManagerCloneRequest,
    MarketResearchRequest,
    VoiceCloneRequest,
)
from app.schemas.manager_clones import (
    KnowledgeUploadInput,
    ManagerCloneActionName,
    ManagerCloneActionRequest,
    ManagerCloneActionResponse,
    ManagerCloneModule,
    MarketResearchGenerateInput,
    VersionArchiveInput,
    VersionCreateDraftInput,
    VersionPublishInput,
    VersionRollbackInput,
    VoiceGenerateInput,
)
from app.services.enterprise.enterprise import (
    ManagerCloneService,
    MarketResearchService,
    VoiceCloningService,
)
from app.services.enterprise import manager_store as store

logger = logging.getLogger(__name__)

_MAX_KNOWLEDGE_BYTES = 5 * 1024 * 1024


class ManagerCloneActionsService:
    def __init__(self) -> None:
        self._manager = ManagerCloneService()
        self._market = MarketResearchService()
        self._voice = VoiceCloningService()

    async def dispatch(
        self, clone_id: str, payload: ManagerCloneActionRequest
    ) -> ManagerCloneActionResponse:
        clone = store.get_manager_clone(clone_id)
        if clone is None:
            raise HTTPException(status_code=404, detail="Manager clone not found")

        parsed = payload.parsed_input()
        action_id = str(uuid4())
        try:
            result = await self._run(
                clone_id=clone_id,
                company_id=clone.company_id,
                module=payload.module,
                action=payload.action,
                parsed=parsed,
            )
            row = store.save_action(
                clone_id=clone_id,
                module=payload.module.value,
                action=payload.action.value,
                status=JobStatus.SUCCEEDED.value,
                result=result,
                action_id=action_id,
            )
            return ManagerCloneActionResponse(
                correlation_id=payload.correlation_id,
                clone_id=clone_id,
                action_id=row.action_id,
                module=payload.module.value,
                action=payload.action.value,
                status=JobStatus.SUCCEEDED,
                stub=bool(result.get("stub", False)),
                message=str(result.get("message") or "OK"),
                result=result,
            )
        except HTTPException:
            raise
        except Exception as exc:
            logger.exception("manager-clone action failed %s.%s", payload.module, payload.action)
            store.save_action(
                clone_id=clone_id,
                module=payload.module.value,
                action=payload.action.value,
                status=JobStatus.FAILED.value,
                result={},
                error=str(exc),
                action_id=action_id,
            )
            raise HTTPException(status_code=500, detail=str(exc)) from exc

    async def _run(
        self,
        *,
        clone_id: str,
        company_id: str,
        module: ManagerCloneModule,
        action: ManagerCloneActionName,
        parsed,
    ) -> dict:
        if module == ManagerCloneModule.KNOWLEDGE:
            assert isinstance(parsed, KnowledgeUploadInput)
            return self._upload_knowledge(clone_id, parsed)

        if module == ManagerCloneModule.VOICE:
            assert isinstance(parsed, VoiceGenerateInput)
            voice_req = VoiceCloneRequest(
                company_id=company_id,
                voice_name=parsed.voice_name,
                sample_audio_base64=parsed.sample_audio_base64,
                sample_url=parsed.sample_url,
                sample_mime_type=parsed.sample_mime_type,
                consent_id=parsed.consent_id,
                consent_audio_base64=parsed.consent_audio_base64,
                consent_language=parsed.consent_language,
                options=parsed.options,
            )
            resp = await self._voice.clone(voice_req)
            result = resp.model_dump(mode="json")
            if resp.status != JobStatus.SUCCEEDED or not result.get("voice_id"):
                raise HTTPException(
                    status_code=400,
                    detail=result.get("message")
                    or result.get("status_detail")
                    or "Voice cloning failed — upload sample + consent audio",
                )
            clone = store.get_manager_clone(clone_id)
            if clone is not None:
                profile = dict(clone.profile or {})
                options = dict(profile.get("options") or {})
                options["voice_id"] = result["voice_id"]
                options["voice_name"] = parsed.voice_name
                profile["options"] = options
                store.update_manager_clone(clone_id, profile=profile)
            return result

        if module == ManagerCloneModule.MARKET_RESEARCH:
            assert isinstance(parsed, MarketResearchGenerateInput)
            market_req = MarketResearchRequest(
                role_title=parsed.role_title,
                industry=parsed.industry,
                region=parsed.region,
                count=parsed.count,
                options=parsed.options,
            )
            resp = await self._market.questions(market_req)
            return resp.model_dump(mode="json")

        if module == ManagerCloneModule.VERSION:
            return self._version_action(clone_id, action, parsed)

        raise HTTPException(status_code=400, detail=f"Unsupported module {module}")

    def _upload_knowledge(self, clone_id: str, parsed: KnowledgeUploadInput) -> dict:
        filename = parsed.filename.strip()
        lower = filename.lower()

        if parsed.text and parsed.text.strip() and not parsed.content_base64:
            contents = parsed.text.encode("utf-8")
            extracted = parsed.text
        else:
            try:
                contents = base64.b64decode(parsed.content_base64 or "", validate=False)
            except Exception as exc:
                raise HTTPException(status_code=400, detail="Invalid content_base64") from exc
            if not contents:
                raise HTTPException(status_code=400, detail="Empty file content")
            if len(contents) > _MAX_KNOWLEDGE_BYTES:
                raise HTTPException(status_code=400, detail="File too large")
            extracted = ""
            if lower.endswith(".txt"):
                extracted = contents.decode(errors="ignore")
            elif lower.endswith(".pdf"):
                upload_dir = Path("/tmp/manager_knowledge") / clone_id
                upload_dir.mkdir(parents=True, exist_ok=True)
                file_path = upload_dir / filename
                file_path.write_bytes(contents)
                try:
                    import PyPDF2

                    reader = PyPDF2.PdfReader(str(file_path))
                    extracted = "\n".join(page.extract_text() or "" for page in reader.pages)
                except Exception:
                    extracted = ""
            else:
                raise HTTPException(status_code=400, detail="Unsupported file type")

        if len(contents) > _MAX_KNOWLEDGE_BYTES:
            raise HTTPException(status_code=400, detail="File too large")

        upload_dir = Path("/tmp/manager_knowledge") / clone_id
        upload_dir.mkdir(parents=True, exist_ok=True)
        file_path = upload_dir / filename
        file_path.write_bytes(contents)

        store.save_knowledge(
            clone_id=clone_id,
            file_name=filename,
            file_path=str(file_path),
            extracted_text=extracted,
        )
        return {
            "message": "Knowledge uploaded successfully",
            "filename": filename,
            "bytes": len(contents),
            "extracted_chars": len(extracted or ""),
        }

    def _version_action(
        self,
        clone_id: str,
        action: ManagerCloneActionName,
        parsed,
    ) -> dict:
        if action == ManagerCloneActionName.CREATE_DRAFT:
            assert isinstance(parsed, VersionCreateDraftInput)
            version = self._manager.draft_version(
                clone_id=clone_id,
                created_by=parsed.created_by,
                snapshot=parsed.snapshot,
            )
            status = (
                version.status.value
                if hasattr(version.status, "value")
                else str(version.status)
            )
            return {
                "version_id": str(version.version_id),
                "version_status": status,
                "message": "Draft version created",
            }

        if action == ManagerCloneActionName.PUBLISH:
            assert isinstance(parsed, VersionPublishInput)
            version = self._manager.publish_version(parsed.version_id)
            if str(version.clone_id) != clone_id:
                raise HTTPException(
                    status_code=400, detail="version_id does not belong to this clone"
                )
            status = (
                version.status.value
                if hasattr(version.status, "value")
                else str(version.status)
            )
            return {
                "version_id": str(version.version_id),
                "version_status": status,
                "message": "Version published",
            }

        if action == ManagerCloneActionName.ARCHIVE:
            assert isinstance(parsed, VersionArchiveInput)
            version = self._manager.archive_version(parsed.version_id)
            if str(version.clone_id) != clone_id:
                raise HTTPException(
                    status_code=400, detail="version_id does not belong to this clone"
                )
            status = (
                version.status.value
                if hasattr(version.status, "value")
                else str(version.status)
            )
            return {
                "version_id": str(version.version_id),
                "version_status": status,
                "message": "Version archived",
            }

        if action == ManagerCloneActionName.ROLLBACK:
            assert isinstance(parsed, VersionRollbackInput)
            try:
                target = UUID(str(parsed.target_version_id))
            except ValueError as exc:
                raise HTTPException(
                    status_code=400, detail="target_version_id must be a UUID"
                ) from exc
            version = self._manager.rollback_version(
                clone_id, target, parsed.created_by
            )
            status = (
                version.status.value
                if hasattr(version.status, "value")
                else str(version.status)
            )
            return {
                "version_id": str(version.version_id),
                "version_status": status,
                "rolled_back_from": str(target),
                "message": "Rollback created new draft version",
            }

        raise HTTPException(status_code=400, detail=f"Unsupported version action {action}")


async def apply_setup_extras(
    clone_id: str,
    *,
    company_id: str,
    knowledge: KnowledgeUploadInput | None = None,
    voice: VoiceGenerateInput | None = None,
    profile: dict | None = None,
) -> dict:
    """Apply optional knowledge upload + voice generate during create/PATCH setup."""
    actions = ManagerCloneActionsService()
    setup: dict = {}
    profile = dict(profile or {})

    if knowledge is not None:
        know_result = actions._upload_knowledge(clone_id, knowledge)
        setup["knowledge"] = know_result
        store.save_action(
            clone_id=clone_id,
            module="knowledge",
            action="upload_knowledge",
            status=JobStatus.SUCCEEDED.value,
            result=know_result,
        )

    if voice is not None:
        voice_req = VoiceCloneRequest(
            company_id=company_id,
            voice_name=voice.voice_name,
            sample_audio_base64=voice.sample_audio_base64,
            sample_url=voice.sample_url,
            sample_mime_type=voice.sample_mime_type,
            consent_id=voice.consent_id,
            consent_audio_base64=voice.consent_audio_base64,
            consent_language=voice.consent_language,
            options=voice.options,
        )
        resp = await actions._voice.clone(voice_req)
        voice_result = resp.model_dump(mode="json")
        setup["voice"] = voice_result
        voice_id = voice_result.get("voice_id")
        ok = resp.status == JobStatus.SUCCEEDED and bool(voice_id)
        if ok:
            options = dict(profile.get("options") or {})
            options["voice_id"] = voice_id
            options["voice_name"] = voice.voice_name
            profile["options"] = options
            store.update_manager_clone(clone_id, profile=profile)
        else:
            raise HTTPException(
                status_code=400,
                detail=voice_result.get("message")
                or voice_result.get("status_detail")
                or "Voice cloning failed — upload sample + consent audio",
            )
        store.save_action(
            clone_id=clone_id,
            module="voice",
            action="generate_voice",
            status=JobStatus.SUCCEEDED.value,
            result=voice_result,
        )

    return setup


def clone_to_detail(
    clone,
    *,
    correlation_id=None,
    message: str = "OK",
    stub: bool = False,
    setup: dict | None = None,
):
    from app.schemas.manager_clones import ManagerCloneDetailResponse

    profile = dict(clone.profile or {})
    options = dict(profile.get("options") or {})
    knowledge_files: list[str] = []
    try:
        knowledge_files = [
            row.file_name for row in store.get_knowledge(str(clone.clone_id)) if row.file_name
        ]
    except Exception:
        logger.exception("Failed listing knowledge for clone %s", clone.clone_id)

    return ManagerCloneDetailResponse(
        correlation_id=correlation_id,
        company_id=clone.company_id,
        clone_id=str(clone.clone_id),
        style_summary=profile.get("style_summary"),
        manager_profile=profile.get("manager_profile"),
        sample_questions=list(profile.get("sample_questions") or []),
        options=options,
        voice_id=options.get("voice_id"),
        knowledge_files=knowledge_files,
        setup=dict(setup or {}),
        stub=stub,
        message=message,
        created_at=clone.created_at,
    )


async def create_clone_from_request(payload) -> "ManagerCloneDetailResponse":
    """Bridge CreateRequest → ManagerCloneService.create + optional knowledge/voice setup."""
    from app.schemas.manager_clones import ManagerCloneCreateRequest, ManagerCloneDetailResponse

    if not isinstance(payload, ManagerCloneCreateRequest):
        raise TypeError("expected ManagerCloneCreateRequest")

    legacy = ManagerCloneRequest(
        correlation_id=payload.correlation_id,
        company_id=payload.company_id,
        manager_profile=payload.manager_profile,
        sample_questions=payload.sample_questions,
        options=payload.options,
    )
    created = await ManagerCloneService().create(legacy)
    clone = store.get_manager_clone(created.clone_id or "")
    if clone is None:
        return ManagerCloneDetailResponse(
            correlation_id=payload.correlation_id,
            company_id=payload.company_id,
            clone_id=created.clone_id or "",
            style_summary=created.style_summary,
            sample_questions=list(payload.sample_questions or []),
            stub=created.stub,
            message=created.message,
        )

    setup = await apply_setup_extras(
        str(clone.clone_id),
        company_id=clone.company_id,
        knowledge=payload.knowledge,
        voice=payload.voice,
        profile=dict(clone.profile or {}),
    )
    refreshed = store.get_manager_clone(str(clone.clone_id)) or clone
    return clone_to_detail(
        refreshed,
        correlation_id=payload.correlation_id,
        message=created.message or "OK",
        stub=bool(created.stub),
        setup=setup,
    )
