"""Approval-first social media draft artifacts."""

from __future__ import annotations

from dataclasses import dataclass

from autoshorts.ideas.candidate import SUPPORTED_PLATFORMS, ValidationResult, VideoCandidate, validate_candidate
from autoshorts.rendering.preview import RenderPreview, validate_render_preview

_PLATFORM_LABELS = {
    "youtube": "YouTube Shorts",
    "tiktok": "TikTok",
    "instagram": "Instagram Reels",
}


@dataclass(frozen=True)
class SocialMediaDraft:
    candidate_id: str
    platforms: tuple[str, ...]
    platform_labels: tuple[str, ...]
    title_variants: tuple[str, ...]
    caption: str
    hashtags: tuple[str, ...]
    cta: str
    hook: str
    planned_duration_seconds: int
    quality_risk_summary: str
    preview_reference: str
    preview_type: str
    requires_human_approval: bool = True
    side_effects: tuple[str, ...] = ()


def _is_blank(value: str) -> bool:
    return not (value or "").strip()


def _quality_risk_summary(candidate: VideoCandidate) -> str:
    score = candidate.quality_score
    return (
        f"Quality average: {score.average_quality:.1f}; "
        f"AI-slop risk: {score.ai_slop_risk}; "
        f"Policy risk: {score.policy_risk}"
    )


def _source_brief_id(candidate: VideoCandidate) -> str | None:
    prefix = "Source brief: "
    for note in candidate.policy_notes:
        if note.startswith(prefix):
            return note.removeprefix(prefix).strip()
    return None


def build_social_media_draft(candidate: VideoCandidate, preview: RenderPreview) -> SocialMediaDraft:
    """Build a side-effect-free platform draft from a candidate and preview."""

    candidate_validation = validate_candidate(candidate)
    if not candidate_validation.is_valid:
        raise ValueError("; ".join(candidate_validation.errors))

    preview_validation = validate_render_preview(preview)
    if not preview_validation.is_valid:
        raise ValueError("; ".join(preview_validation.errors))

    source_brief_id = _source_brief_id(candidate)
    if source_brief_id is not None and preview.script_id != source_brief_id:
        raise ValueError("preview script_id must match candidate source brief")

    draft = SocialMediaDraft(
        candidate_id=candidate.candidate_id,
        platforms=candidate.platforms,
        platform_labels=tuple(_PLATFORM_LABELS[platform] for platform in candidate.platforms),
        title_variants=(candidate.title, candidate.hook),
        caption=candidate.caption,
        hashtags=candidate.hashtags,
        cta=candidate.cta,
        hook=candidate.hook,
        planned_duration_seconds=candidate.duration_seconds,
        quality_risk_summary=_quality_risk_summary(candidate),
        preview_reference="HTML timeline preview available",
        preview_type=preview.preview_type,
        requires_human_approval=True,
        side_effects=(),
    )
    validation = validate_social_media_draft(draft)
    if not validation.is_valid:
        raise ValueError("; ".join(validation.errors))
    return draft


def validate_social_media_draft(draft: SocialMediaDraft) -> ValidationResult:
    errors: list[str] = []
    for field_name, value in {
        "candidate_id": draft.candidate_id,
        "caption": draft.caption,
        "cta": draft.cta,
        "hook": draft.hook,
        "quality_risk_summary": draft.quality_risk_summary,
        "preview_reference": draft.preview_reference,
        "preview_type": draft.preview_type,
    }.items():
        if _is_blank(value):
            errors.append(f"{field_name} is required")

    if not draft.platforms:
        errors.append("at least one platform is required")
    for platform in draft.platforms:
        if platform not in SUPPORTED_PLATFORMS:
            errors.append(f"unsupported platform: {platform}")

    if len(draft.platform_labels) != len(draft.platforms):
        errors.append("platform_labels must match platforms")
    if not draft.title_variants:
        errors.append("at least one title variant is required")
    elif any(_is_blank(title) for title in draft.title_variants):
        errors.append("title variants must not be blank")
    if not draft.hashtags:
        errors.append("at least one hashtag is required")
    elif any(_is_blank(hashtag) for hashtag in draft.hashtags):
        errors.append("hashtags must not be blank")
    if not 10 <= draft.planned_duration_seconds <= 180:
        errors.append("planned_duration_seconds must be between 10 and 180")
    if not draft.requires_human_approval:
        errors.append("human approval is required")
    if draft.side_effects:
        errors.append("social media drafts must not have side effects")

    return ValidationResult(is_valid=not errors, errors=tuple(errors))