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

from uuid import uuid4

from app.schemas.common import JobStatus
from app.schemas.enterprise import (
    ManagerCloneRequest,
    ManagerCloneResponse,
    MarketResearchRequest,
    MarketResearchResponse,
    VoiceCloneRequest,
    VoiceCloneResponse,
)
from app.services.ai_generate import generate_json


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
        )
        return ManagerCloneResponse(
            correlation_id=payload.correlation_id,
            company_id=payload.company_id,
            clone_id=str(uuid4()),
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Manager clone via {provider}",
            style_summary=data.get("style_summary"),
        )


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:
        return VoiceCloneResponse(
            correlation_id=payload.correlation_id,
            company_id=payload.company_id,
            voice_id=str(uuid4()),
            status=JobStatus.SUCCEEDED,
            stub=True,
            message=(
                f"Voice clone accepted for '{payload.voice_name}' — "
                "live provider not wired yet"
            ),
            status_detail="accepted_local",
        )