"""Enterprise AI — manager clone, market research, voice cloning."""

from __future__ import annotations

import logging
from uuid import uuid4
from uuid import UUID
from datetime import datetime
from fastapi import HTTPException
from app.schemas.common import JobStatus

from app.config import get_settings
from app.models.manager_clone import ManagerCloneVersion as VersionModel, CloneStatus
from app.schemas.enterprise import (
    ManagerCloneRequest,
    ManagerCloneResponse,
    MarketResearchRequest,
    MarketResearchResponse,
    VoiceCloneRequest,
    VoiceCloneResponse,
)
from app.services.shared.ai_generate import generate_json
from app.services.voice.voice_clone_openai import (
    VoiceCloneError,
    create_custom_voice,
    create_voice_consent,
    decode_audio_b64,
    resolve_sample_bytes,
)
from app.services.voice.voice_store import VoiceProfile, new_voice_id, voice_profile_store

logger = logging.getLogger(__name__)


class ManagerCloneService:
    async def create(self, payload: ManagerCloneRequest) -> ManagerCloneResponse:
        system = (
            "Infer a hiring-manager interview style. Return JSON: "
            "{\"style_summary\",\"clone_id_hint\"}"
        )
        user = (
            f"Company: {payload.company_id}\nProfile: {payload.manager_profile}\n"
            f"Samples: {payload.sample_questions}"
        )

        def local() -> dict:
            samples = payload.sample_questions or ["Tell me about a challenge you owned."]
            return {
                "style_summary": (
                    "Direct, behavioral, values ownership and concrete outcomes. "
                    f"Example probe style: {samples[0]}"
                ),
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        clone_id = str(uuid4())
        style_summary = data.get("style_summary")
        profile = {
            "manager_profile": (
                payload.manager_profile.model_dump()
                if payload.manager_profile is not None
                else None
            ),
            "sample_questions": list(payload.sample_questions or []),
            "style_summary": style_summary,
            "options": dict(payload.options or {}),
        }
        try:
            from app.services.enterprise.manager_store import save_manager_clone

            save_manager_clone(
                clone_id=clone_id,
                company_id=payload.company_id,
                profile=profile,
            )
        except Exception:
            # Persist is best-effort for versioning; LLM summary still returns.
            logger.exception("Failed to persist manager clone %s", clone_id)
        return ManagerCloneResponse(
            correlation_id=payload.correlation_id,
            company_id=payload.company_id,
            clone_id=clone_id,
            version_status=None,
            stub=stub,
            message=f"Manager clone via {provider}",
            style_summary=style_summary,
        )

    # Version lifecycle methods
    def draft_version(self, clone_id: str, created_by: str, snapshot: dict) -> VersionModel:
        """Create a new draft version for a manager clone."""
        from app.services.enterprise.manager_store import save_version

        # save_version ensures parent manager_clones row (FK).
        version = save_version(clone_id=clone_id, created_by=created_by, snapshot=snapshot)
        # Convert enum status to string for compatibility
        version.status = version.status.value
        return version

    def latest_version_id(
        self,
        *,
        status: CloneStatus,
        clone_id: str | None = None,
    ) -> str | None:
        """Most recent version_id matching status (optional clone filter)."""
        from app.models.manager_clone import ManagerCloneVersion as VersionModel
        from app.database import get_db

        db = next(get_db())
        try:
            # Match enum or stored string value (dialect quirks).
            q = db.query(VersionModel).filter(
                VersionModel.status.in_([status, status.value])
            )
            if clone_id:
                q = q.filter(VersionModel.clone_id == clone_id)
            row = q.order_by(VersionModel.created_at.desc()).first()
            return str(row.version_id) if row else None
        finally:
            db.close()

    def publish_version(self, version_id: str) -> VersionModel:
        """Publish a draft version, ensuring only one published per clone."""
        from app.models.manager_clone import ManagerCloneVersion as VersionModel
        from app.database import get_db
        version_id = str(version_id)
        db = next(get_db())
        version = db.query(VersionModel).filter(VersionModel.version_id == version_id).first()
        if not version:
            raise HTTPException(status_code=404, detail="Version not found")
        if version.status not in (CloneStatus.DRAFT, CloneStatus.DRAFT.value):
            raise HTTPException(status_code=400, detail="Only draft versions can be published")
        existing = (
            db.query(VersionModel)
            .filter(VersionModel.clone_id == version.clone_id, VersionModel.status == CloneStatus.PUBLISHED)
            .first()
        )
        if existing:
            raise HTTPException(status_code=400, detail="A published version already exists for this clone")
        version.status = CloneStatus.PUBLISHED
        version.published_at = datetime.utcnow()
        db.commit()
        db.refresh(version)
        db.close()
        version.status = version.status.value
        return version

    def archive_version(self, version_id: str) -> VersionModel:
        """Archive a published version."""
        from app.models.manager_clone import ManagerCloneVersion as VersionModel
        from app.database import get_db
        version_id = str(version_id)
        db = next(get_db())
        version = db.query(VersionModel).filter(VersionModel.version_id == version_id).first()
        if not version:
            raise HTTPException(status_code=404, detail="Version not found")
        if version.status != CloneStatus.PUBLISHED:
            raise HTTPException(status_code=400, detail="Only published versions can be archived")
        version.status = CloneStatus.ARCHIVED
        db.commit()
        db.refresh(version)
        db.close()
        version.status = version.status.value
        return version

    def rollback_version(self, clone_id: str, target_version_id: UUID, created_by: str) -> VersionModel:
        """Create a new draft version based on a previous published version."""
        from app.models.manager_clone import ManagerCloneVersion as VersionModel
        from app.database import get_db
        db = next(get_db())
        target = (
            db.query(VersionModel)
            .filter(
                VersionModel.clone_id == clone_id,
                VersionModel.version_id == str(target_version_id),
            )
            .first()
        )
        if not target:
            raise HTTPException(status_code=404, detail="Target version not found")
        snapshot = target.configuration_snapshot
        from app.services.enterprise.manager_store import save_version
        new_version = save_version(clone_id=clone_id, created_by=created_by, snapshot=snapshot)
        db.close()
        return new_version


class MarketResearchService:
    async def questions(self, payload: MarketResearchRequest) -> MarketResearchResponse:
        system = (
            "Generate market-aware interview questions. "
            "Return JSON: {\"questions\":[\"...\"],\"sources\":[\"...\"]}"
        )
        user = (
            f"Role: {payload.role_title}\nIndustry: {payload.industry}\n"
            f"Region: {payload.region}\nCount: {payload.count}"
        )

        def local() -> dict:
            return {
                "questions": [
                    f"How are recent trends in {payload.industry or 'the industry'} "
                    f"changing expectations for a {payload.role_title}?",
                    f"Which tools or practices should a modern {payload.role_title} evaluate in 2026?",
                    f"Describe a market signal that would change your roadmap for this role.",
                ][: payload.count],
                "sources": ["local-market-knowledge-baseline"],
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        return MarketResearchResponse(
            correlation_id=payload.correlation_id,
            role_title=payload.role_title,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Market research via {provider}",
            questions=list(data.get("questions") or []),
            sources=list(data.get("sources") or []),
        )


class VoiceCloningService:
    async def clone(self, payload: VoiceCloneRequest) -> VoiceCloneResponse:
        """Clone a TTS voice from an uploaded speaker sample (not a builtin name)."""
        settings = get_settings()
        tts_model = (settings.tts_model or "gpt-4o-mini-tts").strip()
        local_id = new_voice_id()

        sample_bytes, sample_sha = await resolve_sample_bytes(
            sample_audio_base64=payload.sample_audio_base64,
            sample_url=payload.sample_url,
        )
        if not sample_bytes:
            return VoiceCloneResponse(
                correlation_id=payload.correlation_id,
                company_id=payload.company_id,
                voice_id=None,
                voice_name=payload.voice_name,
                tts_model=tts_model,
                status=JobStatus.FAILED,
                stub=False,
                message=(
                    "Uploaded sample audio required for voice cloning "
                    "(sample_audio_base64 or sample_url)"
                ),
                status_detail="sample_required",
                warnings=["Upload speaker audio — do not select a builtin voice name"],
            )

        consent_id = payload.consent_id
        try:
            if not consent_id and payload.consent_audio_base64:
                consent_bytes = decode_audio_b64(payload.consent_audio_base64)
                if not consent_bytes:
                    raise VoiceCloneError("Empty consent audio", code="invalid_audio")
                consent_id = await create_voice_consent(
                    recording=consent_bytes,
                    name=f"{payload.voice_name}-consent",
                    language=payload.consent_language,
                    mime_type=payload.sample_mime_type,
                )
            if not consent_id:
                raise VoiceCloneError(
                    "consent_id or consent_audio_base64 required for voice cloning",
                    code="consent_required",
                )
            created = await create_custom_voice(
                name=payload.voice_name,
                audio_sample=sample_bytes,
                consent_id=consent_id,
                mime_type=payload.sample_mime_type,
            )
            openai_voice_id = str(created.get("id") or "")
            if not openai_voice_id:
                raise VoiceCloneError("Voice create missing id", code="voice_create_failed")
        except VoiceCloneError as exc:
            logger.info("Voice cloning failed: %s", exc.code)
            return VoiceCloneResponse(
                correlation_id=payload.correlation_id,
                company_id=payload.company_id,
                voice_id=None,
                voice_name=payload.voice_name,
                tts_model=tts_model,
                status=JobStatus.FAILED,
                stub=False,
                message=str(exc),
                status_detail=exc.code,
                warnings=[str(exc)],
            )

        profile = VoiceProfile(
            voice_id=local_id,
            company_id=payload.company_id,
            voice_name=payload.voice_name,
            tts_model=tts_model,
            mode="custom",
            openai_voice_id=openai_voice_id,
            builtin_voice=None,
            consent_id=consent_id,
            sample_sha256=sample_sha,
            meta={"status_detail": "openai_custom_voice"},
        )
        voice_profile_store.save(profile)

        return VoiceCloneResponse(
            correlation_id=payload.correlation_id,
            company_id=payload.company_id,
            voice_id=local_id,
            voice_name=payload.voice_name,
            tts_model=tts_model,
            mode="custom",
            openai_voice_id=openai_voice_id,
            builtin_voice=None,
            consent_id=consent_id,
            status=JobStatus.SUCCEEDED,
            stub=False,
            message=(
                f"Cloned voice '{payload.voice_name}' ready for {tts_model} "
                f"(use voice_id with POST /tts/synthesize)"
            ),
            status_detail="openai_custom_voice",
            warnings=[],
        )
