from typing import Literal

from pydantic import BaseModel, Field


class Delivery(BaseModel):
    voice: str
    pause_before_punchline_ms: int = Field(ge=0, le=5000)
    pause_after_punchline_ms: int = Field(ge=0, le=5000)
    gesture: str
    expression: str


class Beat(BaseModel):
    setup: str
    punchline: str
    humour_mechanism: str
    delivery: Delivery
    culture_notes: str
    risk_level: Literal["low", "medium", "high"]


class Routine(BaseModel):
    persona: str
    audience: str
    topic: str
    routine_title: str
    beats: list[Beat] = Field(min_length=3, max_length=8)


class ReviewItem(BaseModel):
    beat_index: int
    decision: Literal["keep", "revise", "drop"]
    reason: str
    risk_notes: str
    originality_score: int = Field(ge=1, le=5)
    funniness_score: int = Field(ge=1, le=5)
    revised_setup: str | None = None
    revised_punchline: str | None = None


class RoutineReview(BaseModel):
    overall_notes: str
    items: list[ReviewItem]

import os

import requests
from dotenv import load_dotenv

load_dotenv()


def call_llm(system_prompt: str, user_prompt: str, temperature: float = 0.8) -> str:
    url = os.environ["LLM_API_URL"]
    model = os.environ["LLM_MODEL"]
    api_key = os.environ.get("LLM_API_KEY", "")

    payload = {
        "model": model,
        "messages": [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_prompt},
        ],
        "temperature": temperature,
        "response_format": {"type": "json_object"},
    }

    headers = {"Content-Type": "application/json"}
    if api_key:
        headers["Authorization"] = f"Bearer {api_key}"

    response = requests.post(url, headers=headers, json=payload, timeout=120)
    response.raise_for_status()
    data = response.json()
    return data["choices"][0]["message"]["content"]

import argparse
from pathlib import Path

import yaml
from rich import print

from src.llm import call_llm
from src.schemas import Routine


def load_text(path: Path) -> str:
    return path.read_text(encoding="utf-8")


def load_yaml(path: Path) -> dict:
    return yaml.safe_load(path.read_text(encoding="utf-8"))


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--persona", required=True)
    parser.add_argument("--topic", required=True)
    parser.add_argument("--audience", default="일반 기술 세미나 참석자")
    args = parser.parse_args()

    persona_path = Path("personas") / f"{args.persona}.yaml"
    persona_config = load_yaml(persona_path)
    template = load_text(Path("prompts/generate_routine.txt"))

    user_prompt = (
        template
        .replace("", args.audience)
        .replace("", args.topic)
        .replace("", yaml.safe_dump(persona_config, allow_unicode=True))
    )

    system_prompt = (
        "You are a careful comedy writing assistant. "
        "You create original, safe, structured stand-up material with delivery markup."
    )

    raw = call_llm(system_prompt, user_prompt, temperature=0.85)
    routine = Routine.model_validate_json(raw)

    Path("outputs").mkdir(exist_ok=True)
    out_path = Path("outputs") / f"routine_{args.persona}.json"
    out_path.write_text(routine.model_dump_json(indent=2), encoding="utf-8")

    print(f"[green]saved:[/green] {out_path}")
    print(routine.routine_title)


if __name__ == "__main__":
    main()

import argparse
from pathlib import Path

from rich import print

from src.llm import call_llm
from src.schemas import RoutineReview


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--input", required=True)
    args = parser.parse_args()

    routine_json = Path(args.input).read_text(encoding="utf-8")
    template = Path("prompts/review_routine.txt").read_text(encoding="utf-8")
    user_prompt = template.replace("", routine_json)

    system_prompt = (
        "You are a strict but constructive comedy reviewer. "
        "Prefer safe revisions over risky jokes."
    )

    raw = call_llm(system_prompt, user_prompt, temperature=0.25)
    review = RoutineReview.model_validate_json(raw)

    out_path = Path(args.input).with_suffix(".review.json")
    out_path.write_text(review.model_dump_json(indent=2), encoding="utf-8")

    print(f"[green]saved:[/green] {out_path}")
    print(review.overall_notes)


if __name__ == "__main__":
    main()

import argparse
from pathlib import Path

from src.schemas import Routine


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--input", required=True)
    args = parser.parse_args()

    routine = Routine.model_validate_json(Path(args.input).read_text(encoding="utf-8"))

    lines = [
        f"# {routine.routine_title}",
        "",
        f"- Persona: {routine.persona}",
        f"- Audience: {routine.audience}",
        f"- Topic: {routine.topic}",
        "",
    ]

    for i, beat in enumerate(routine.beats, start=1):
        lines.extend(
            [
                f"## Beat {i}",
                "",
                f"Setup: {beat.setup}",
                "",
                f"[pause {beat.delivery.pause_before_punchline_ms}ms]",
                "",
                f"Punchline: {beat.punchline}",
                "",
                f"[pause {beat.delivery.pause_after_punchline_ms}ms]",
                "",
                f"- Voice: {beat.delivery.voice}",
                f"- Gesture: {beat.delivery.gesture}",
                f"- Expression: {beat.delivery.expression}",
                f"- Mechanism: {beat.humour_mechanism}",
                f"- Risk: {beat.risk_level}",
                "",
            ]
        )

    out_path = Path(args.input).with_suffix(".md")
    out_path.write_text("\n".join(lines), encoding="utf-8")
    print(f"saved: {out_path}")


if __name__ == "__main__":
    main()