"""Schemas — unified Manager Clones REST (CRUD + actions)."""

from __future__ import annotations

from datetime import datetime
from enum import Enum
from typing import Any, Literal
from uuid import UUID

from pydantic import BaseModel, Field, model_validator

from app.schemas.common import StubMeta, utc_now
from app.schemas.enterprise import ManagerProfile


class ManagerCloneModule(str, Enum):
    KNOWLEDGE = "knowledge"
    VOICE = "voice"
    MARKET_RESEARCH = "market_research"
    VERSION = "version"


class ManagerCloneActionName(str, Enum):
    UPLOAD_KNOWLEDGE = "upload_knowledge"
    GENERATE_VOICE = "generate_voice"
    GENERATE_QUESTIONS = "generate_questions"
    CREATE_DRAFT = "create_draft"
    PUBLISH = "publish"
    ARCHIVE = "archive"
    ROLLBACK = "rollback"


# module -> allowed actions
MODULE_ACTIONS: dict[ManagerCloneModule, set[ManagerCloneActionName]] = {
    ManagerCloneModule.KNOWLEDGE: {ManagerCloneActionName.UPLOAD_KNOWLEDGE},
    ManagerCloneModule.VOICE: {ManagerCloneActionName.GENERATE_VOICE},
    ManagerCloneModule.MARKET_RESEARCH: {ManagerCloneActionName.GENERATE_QUESTIONS},
    ManagerCloneModule.VERSION: {
        ManagerCloneActionName.CREATE_DRAFT,
        ManagerCloneActionName.PUBLISH,
        ManagerCloneActionName.ARCHIVE,
        ManagerCloneActionName.ROLLBACK,
    },
}


class KnowledgeUploadInput(BaseModel):
    filename: str = Field(..., min_length=1, max_length=512)
    content_base64: str | None = Field(
        default=None,
        description="Base64 file bytes (.txt / .pdf). Provide this or text.",
    )
    text: str | None = Field(
        default=None,
        description="Plain-text knowledge when not uploading a binary file.",
    )

    @model_validator(mode="after")
    def require_content(self) -> KnowledgeUploadInput:
        if not self.content_base64 and not (self.text and self.text.strip()):
            raise ValueError("Provide content_base64 or text")
        lower = self.filename.lower()
        if self.content_base64 and not (
            lower.endswith(".txt") or lower.endswith(".pdf")
        ):
            raise ValueError("filename must end with .txt or .pdf when using content_base64")
        if self.text and not lower.endswith(".txt"):
            # allow .txt for text-only; coerce name if needed
            if "." not in self.filename:
                object.__setattr__(self, "filename", f"{self.filename}.txt")
            elif not lower.endswith(".txt"):
                raise ValueError("text uploads require a .txt filename")
        return self


class VoiceGenerateInput(BaseModel):
    """Voice cloning from an **uploaded** speaker sample (not a builtin like coral)."""

    voice_name: str = Field(..., min_length=1, max_length=128)
    sample_audio_base64: str | None = Field(
        default=None,
        description="Uploaded speaker sample (base64). Required unless sample_url is set.",
    )
    sample_url: str | None = Field(
        default=None,
        description="URL to uploaded speaker sample audio. Required unless sample_audio_base64 is set.",
    )
    sample_mime_type: str = Field(default="audio/wav")
    consent_id: str | None = Field(
        default=None,
        description="Existing OpenAI voice consent id (cons_…). Provide this or consent_audio_base64.",
    )
    consent_audio_base64: str | None = Field(
        default=None,
        description="Consent phrase recording (same speaker as sample), base64.",
    )
    consent_language: str = Field(default="en", min_length=2, max_length=10)
    options: dict[str, Any] = Field(default_factory=dict)

    @model_validator(mode="after")
    def require_uploaded_sample(self) -> "VoiceGenerateInput":
        if not self.sample_audio_base64 and not self.sample_url:
            raise ValueError(
                "Voice cloning requires an uploaded sample: "
                "provide sample_audio_base64 or sample_url "
                "(builtin voice names like 'coral' are not used for cloning)"
            )
        if not self.consent_id and not self.consent_audio_base64:
            raise ValueError(
                "Voice cloning requires consent_id or consent_audio_base64 "
                "(same speaker as the uploaded sample)"
            )
        return self


class ManagerCloneCreateRequest(BaseModel):
    """POST /api/v1/manager-clones — create + optional setup (knowledge / voice)."""

    correlation_id: UUID | None = None
    company_id: str = Field(..., min_length=1)
    manager_profile: ManagerProfile | None = None
    sample_questions: list[str] = Field(default_factory=list)
    options: dict[str, Any] = Field(default_factory=dict)
    knowledge: KnowledgeUploadInput | None = Field(
        default=None,
        description="Optional knowledge file/text applied during create setup",
    )
    voice: VoiceGenerateInput | None = Field(
        default=None,
        description=(
            "Optional voice clone from uploaded speaker audio "
            "(sample_audio_base64/sample_url + consent). Not a builtin voice name."
        ),
    )


class ManagerClonePatchRequest(BaseModel):
    """PATCH /api/v1/manager-clones/{clone_id} — partial profile + optional setup updates."""

    correlation_id: UUID | None = None
    manager_profile: ManagerProfile | None = None
    sample_questions: list[str] | None = None
    style_summary: str | None = None
    options: dict[str, Any] | None = None
    knowledge: KnowledgeUploadInput | None = Field(
        default=None,
        description="Optional knowledge re-upload during setup edit",
    )
    voice: VoiceGenerateInput | None = Field(
        default=None,
        description=(
            "Optional re-clone from uploaded speaker audio "
            "(sample_audio_base64/sample_url + consent). Not a builtin voice name."
        ),
    )


class ManagerCloneDetailResponse(StubMeta):
    correlation_id: UUID | None = None
    company_id: str
    clone_id: str
    style_summary: str | None = None
    manager_profile: dict[str, Any] | None = None
    sample_questions: list[str] = Field(default_factory=list)
    options: dict[str, Any] = Field(default_factory=dict)
    voice_id: str | None = Field(
        default=None,
        description="Voice id from create/patch setup or last voice.generate_voice",
    )
    knowledge_files: list[str] = Field(
        default_factory=list,
        description="Knowledge filenames associated with this clone",
    )
    setup: dict[str, Any] = Field(
        default_factory=dict,
        description="Results from optional knowledge/voice applied on this request",
    )
    version_id: str | None = None
    version_status: Literal["draft", "published", "archived"] | None = None
    created_at: datetime | None = None


class MarketResearchGenerateInput(BaseModel):
    role_title: str = Field(..., min_length=1)
    industry: str | None = None
    region: str | None = None
    count: int = Field(default=5, ge=1, le=20)
    options: dict[str, Any] = Field(default_factory=dict)


class VersionCreateDraftInput(BaseModel):
    created_by: str = Field(..., min_length=1)
    snapshot: dict[str, Any] = Field(default_factory=dict)


class VersionPublishInput(BaseModel):
    version_id: str = Field(..., min_length=1)


class VersionArchiveInput(BaseModel):
    version_id: str = Field(..., min_length=1)


class VersionRollbackInput(BaseModel):
    target_version_id: str = Field(..., min_length=1)
    created_by: str = Field(..., min_length=1)


INPUT_BY_ACTION: dict[
    tuple[ManagerCloneModule, ManagerCloneActionName], type[BaseModel]
] = {
    (ManagerCloneModule.KNOWLEDGE, ManagerCloneActionName.UPLOAD_KNOWLEDGE): KnowledgeUploadInput,
    (ManagerCloneModule.VOICE, ManagerCloneActionName.GENERATE_VOICE): VoiceGenerateInput,
    (
        ManagerCloneModule.MARKET_RESEARCH,
        ManagerCloneActionName.GENERATE_QUESTIONS,
    ): MarketResearchGenerateInput,
    (ManagerCloneModule.VERSION, ManagerCloneActionName.CREATE_DRAFT): VersionCreateDraftInput,
    (ManagerCloneModule.VERSION, ManagerCloneActionName.PUBLISH): VersionPublishInput,
    (ManagerCloneModule.VERSION, ManagerCloneActionName.ARCHIVE): VersionArchiveInput,
    (ManagerCloneModule.VERSION, ManagerCloneActionName.ROLLBACK): VersionRollbackInput,
}


class ManagerCloneActionRequest(BaseModel):
    """POST /api/v1/manager-clones/{clone_id}/actions"""

    correlation_id: UUID | None = None
    module: ManagerCloneModule
    action: ManagerCloneActionName
    input: dict[str, Any] = Field(default_factory=dict)

    @model_validator(mode="after")
    def module_action_pair(self) -> ManagerCloneActionRequest:
        allowed = MODULE_ACTIONS.get(self.module, set())
        if self.action not in allowed:
            raise ValueError(
                f"action '{self.action.value}' is not valid for module "
                f"'{self.module.value}'. Allowed: "
                f"{sorted(a.value for a in allowed)}"
            )
        model = INPUT_BY_ACTION[(self.module, self.action)]
        model.model_validate(self.input or {})
        return self

    def parsed_input(self) -> BaseModel:
        model = INPUT_BY_ACTION[(self.module, self.action)]
        return model.model_validate(self.input or {})


class ManagerCloneActionResponse(StubMeta):
    correlation_id: UUID | None = None
    clone_id: str
    action_id: str
    module: str
    action: str
    result: dict[str, Any] = Field(default_factory=dict)


class ManagerCloneVersionItem(BaseModel):
    version_id: str
    clone_id: str
    created_by: str
    status: Literal["draft", "published", "archived"]
    created_at: datetime | None = None
    published_at: datetime | None = None
    configuration_snapshot: dict[str, Any] = Field(default_factory=dict)


class ManagerCloneVersionListResponse(StubMeta):
    clone_id: str
    versions: list[ManagerCloneVersionItem] = Field(default_factory=list)


class ManagerCloneActionDetailResponse(StubMeta):
    correlation_id: UUID | None = None
    clone_id: str
    action_id: str
    module: str
    action: str
    action_status: str = Field(
        ...,
        description="Persisted action outcome (succeeded|failed|…)",
    )
    result: dict[str, Any] = Field(default_factory=dict)
    created_at: datetime | None = None
    error: str | None = None


MANAGER_CLONE_ACTION_OPENAPI_EXAMPLES: dict[str, Any] = {
    "knowledge_upload": {
        "summary": "knowledge.upload_knowledge",
        "value": {
            "module": "knowledge",
            "action": "upload_knowledge",
            "input": {
                "filename": "guide.txt",
                "text": "Interview for ownership and concrete outcomes.",
            },
        },
    },
    "voice_generate": {
        "summary": "voice.generate_voice (upload sample)",
        "value": {
            "module": "voice",
            "action": "generate_voice",
            "input": {
                "voice_name": "Acme Interviewer",
                "sample_url": "https://example.com/samples/manager-voice.wav",
                "consent_audio_base64": "UklGRiQAAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YQAAAAA=",
                "consent_language": "en",
                "sample_mime_type": "audio/wav",
            },
        },
    },
    "market_research": {
        "summary": "market_research.generate_questions",
        "value": {
            "module": "market_research",
            "action": "generate_questions",
            "input": {
                "role_title": "Backend Engineer",
                "industry": "SaaS",
                "count": 5,
            },
        },
    },
    "version_draft": {
        "summary": "version.create_draft",
        "value": {
            "module": "version",
            "action": "create_draft",
            "input": {
                "created_by": "recruiter@acme.example",
                "snapshot": {
                    "style_summary": "Structured technical interviewer",
                    "notes": "Draft snapshot",
                },
            },
        },
    },
    "version_publish": {
        "summary": "version.publish",
        "value": {
            "module": "version",
            "action": "publish",
            "input": {"version_id": "paste-draft-version-id"},
        },
    },
    "version_archive": {
        "summary": "version.archive",
        "value": {
            "module": "version",
            "action": "archive",
            "input": {"version_id": "paste-published-version-id"},
        },
    },
    "version_rollback": {
        "summary": "version.rollback",
        "value": {
            "module": "version",
            "action": "rollback",
            "input": {
                "target_version_id": "paste-prior-version-id",
                "created_by": "recruiter@acme.example",
            },
        },
    },
}
