import gradio as gr
import tempfile
import os
import re
import json
import subprocess
import urllib.parse
import urllib.request
import time
import hashlib

STUDIO_NAME = "Aether Studio"
MODEL_DISPLAY_NAME = "Nemotron 3 Ultra"
OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions"
OPENROUTER_KEY = os.environ.get(
    "OPENROUTER_API_KEY",
    "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",
)
MODEL_ID = os.environ.get("OPENROUTER_MODEL", "nvidia/nemotron-3-ultra-550b-a55b:free")

CACHE_DIR = "/tmp/aether_cache"
os.makedirs(CACHE_DIR, exist_ok=True)

SOUNDFONT_CANDIDATES = [
    "/usr/share/sounds/sf2/FluidR3_GM.sf2",
    "/usr/share/sounds/sf2/default-GM.sf2",
    "/usr/share/sounds/sf2/TimGM6mb.sf2",
    "/usr/share/soundfonts/FluidR3_GM.sf2",
    "/usr/share/sounds/sf2/default.sf2",
]

NOTE_TO_MIDI = {
    "C": 0, "C#": 1, "Db": 1, "D": 2, "D#": 3, "Eb": 3, "E": 4, "F": 5,
    "F#": 6, "Gb": 6, "G": 7, "G#": 8, "Ab": 8, "A": 9, "A#": 10, "Bb": 10, "B": 11,
}
DUR = {"w": 4.0, "h": 2.0, "q": 1.0, "e": 0.5, "s": 0.25}

GM_PROGRAM = {
    "piano": 0, "bright_piano": 1, "grand_piano": 0, "electric_piano": 4, "harpsichord": 6,
    "celesta": 8, "glockenspiel": 9, "music_box": 10, "vibraphone": 11, "marimba": 12,
    "xylophone": 13, "bells": 14, "dulcimer": 15, "organ": 19, "church_organ": 19,
    "accordion": 21, "harmonica": 22, "guitar": 24, "nylon_guitar": 24, "steel_guitar": 25,
    "clean_guitar": 27, "lute": 24, "oud": 24, "acoustic_bass": 32, "finger_bass": 33,
    "pick_bass": 34, "fretless_bass": 35, "synth_bass": 38, "violin": 40, "viola": 41,
    "cello": 42, "contrabass": 43, "pizzicato_strings": 45, "harp": 46, "timpani": 47,
    "strings": 48, "slow_strings": 49, "synth_strings": 50, "choir": 52, "synth_voice": 54,
    "orchestra_hit": 55, "trumpet": 56, "trombone": 57, "tuba": 58, "muted_trumpet": 59,
    "french_horn": 60, "brass": 61, "synth_brass": 62, "soprano_sax": 64, "alto_sax": 65,
    "tenor_sax": 66, "oboe": 68, "english_horn": 69, "bassoon": 70, "clarinet": 71,
    "piccolo": 72, "flute": 73, "recorder": 74, "pan_flute": 75, "whistle": 78, "ocarina": 79,
    "square_lead": 80, "saw_lead": 81, "calliope_lead": 82, "bass_lead": 87, "pad": 88,
    "warm_pad": 89, "polysynth_pad": 90, "choir_pad": 91, "bowed_pad": 92, "sitar": 104,
    "banjo": 105, "koto": 107, "kalimba": 108, "bagpipe": 109, "fiddle": 110, "steel_drums": 114,
}

SOLO_INSTRUMENTS = {"recorder", "flute", "whistle", "ocarina", "pan_flute"}
SUSTAIN_INSTRUMENTS = {
    "piano", "grand_piano", "bright_piano", "electric_piano", "harp",
    "strings", "slow_strings", "synth_strings", "guitar", "lute",
}
CHORD_QUALITIES = {
    "": [0, 4, 7], "maj": [0, 4, 7], "m": [0, 3, 7], "min": [0, 3, 7],
    "7": [0, 4, 7, 10], "m7": [0, 3, 7, 10], "min7": [0, 3, 7, 10],
    "maj7": [0, 4, 7, 11], "dim": [0, 3, 6], "dim7": [0, 3, 6, 9],
    "aug": [0, 4, 8], "sus2": [0, 2, 7], "sus4": [0, 5, 7], "5": [0, 7],
}
_QUALITY_RE = r"(maj7|min7|sus2|sus4|dim7|maj|min|m7|dim|aug|7|5|m)?"
DYNAMIC_LEVELS = {"pp": 42, "p": 58, "mp": 74, "mf": 90, "f": 106, "ff": 120}
PERCUSSION_STYLES = {"epica", "marcha", "ninguno"}

NOTE_TOKEN_RE = re.compile(r"^([A-G][#b]?)(\d)([qehws]?)([-!]{0,2})$")
REST_TOKEN_RE = re.compile(r"^R([qehws])$", re.I)
CHORD_TOKEN_RE = re.compile(r"^([A-G][#b]?)" + _QUALITY_RE + r"(\d(?:\.\d)?)?$")

SYSTEM = """Eres el compositor de Aether Studio. Tu trabajo es generar partituras instrumentales en formato PMNS.

RECHAZO: si el usuario NO pide musica/cancion/composicion, responde exactamente:
lo siento no puedo hacer eso

HERRAMIENTAS (usalas cuando las necesites, antes de la partitura final):
1) TOOL_SEARCH: <consulta>
   Busca en la web datos musicales (modos, tempos tipicos, instrumentacion de un genero, estructura de un estilo).
2) TOOL_VALIDATE: <partitura PMNS completa>
   Valida gramatica PMNS. Te devuelve OK o lista de errores con linea.
3) TOOL_INSTRUMENTS:
   Lista instrumentos GM validos.

Flujo recomendado:
- Si dudas del estilo/modo/instrumentacion -> TOOL_SEARCH
- Escribe borrador PMNS
- TOOL_VALIDATE si quieres comprobar
- Cuando este listo, responde SOLO la partitura PMNS (sin TOOL_*, sin explicaciones)

GRAMATICA PMNS:
obra := cabecera seccion+
cabecera := "# " titulo  /  "## Estilo"  /  "## Tempo"  /  "## Tonalidad"
seccion := "### " nombre  + campos
campos posibles:
  instrumento: <nombre GM>
  tempo: <BPM seccion>
  dinamica: pp|p|mp|mf|f|ff
  repetir: <1-8>
  percusion: epica|marcha|ninguno
  notas: <tokens>
  acordes: <tokens>

Notas: Nota+Octava+Duracion[+articulacion]
  Nota: C C# Db D D# Eb E F F# Gb G G# Ab A A# Bb B
  Octava: 1-7
  Duracion: w h q e s  (si omites duracion = q)
  Articulacion: - legato   ! acento
  Silencio: Rq Re Rh Rw Rs
Acordes: Root+calidad+pulsos  ej: Dm2 Fmaj74 Am  (pulsos opcionales, default 2)
  calidades: m min maj 7 m7 maj7 dim dim7 aug sus2 sus4 5

Reglas de calidad:
- 6-8 secciones para ~1 minuto
- >=10 notas por seccion de melodia
- Usa tu conocimiento musical + resultados de tools
- No inventes instrumentos fuera del catalogo
- No escribas letra cantada, solo instrumental
- No uses escalas mecanicas como unica melodia

Ejemplo de forma (no copies el estilo, solo la forma):

# Titulo
## Estilo
descripcion
## Tempo
100
## Tonalidad
D dorico
## Estructura
### Intro
instrumento: lute
dinamica: p
notas: D4q F4q A4q D5h
acordes: Dm2 Am2
### Tema
instrumento: recorder
dinamica: mf
repetir: 1
notas: A4q C5q D5q F5h E5q D5q C5h
acordes: Dm2 F2
### Outro
instrumento: lute
dinamica: p
notas: D4h A3h D3w
acordes: Dm4
"""


def parse_note_token(tok):
    m = NOTE_TOKEN_RE.match(tok.strip())
    if not m:
        return None
    name, octv, d, art = m.groups()
    if name not in NOTE_TO_MIDI:
        return None
    midi = NOTE_TO_MIDI[name] + (int(octv) + 1) * 12
    beats = DUR.get(d or "q", 1.0)
    return midi, beats, ("-" in art), ("!" in art)


def parse_chord_token(tok):
    m = CHORD_TOKEN_RE.match(tok.strip())
    if not m:
        return None
    root, quality, beats = m.groups()
    if root not in NOTE_TO_MIDI:
        return None
    return {
        "root": NOTE_TO_MIDI[root] + 48,
        "intervals": CHORD_QUALITIES[quality or ""],
        "beats": float(beats) if beats else 2.0,
    }


def detect_inst(text):
    t = text.lower().strip()
    for w in ("flauta dulce", "flauta de pico", "recorder"):
        if w in t:
            return "recorder"
    if "flauta" in t or "flute" in t:
        return "flute"
    for k in sorted(GM_PROGRAM.keys(), key=len, reverse=True):
        if k in t:
            return k
    for es, en in (
        ("laud", "lute"), ("laúd", "lute"), ("guitarra", "guitar"),
        ("arpa", "harp"), ("trompeta", "trumpet"), ("cuerdas", "strings"),
        ("organo", "organ"), ("campanas", "bells"),
    ):
        if es in t:
            return en
    return "piano"


def parse_pmns(md):
    errors = []
    work = {"title": "Sin titulo", "tempo": 100, "style": "", "key": "", "sections": []}
    tm = re.search(r"##\s*Tempo\s*\n\s*(\d+)", md, re.I)
    if tm:
        work["tempo"] = max(40, min(220, int(tm.group(1))))
    ttm = re.search(r"^\s*#\s+(.+)$", md, re.M)
    if ttm:
        work["title"] = ttm.group(1).strip()
    sm = re.search(r"##\s*Estilo\s*\n(.+?)(?=\n##|\n###|$)", md, re.I | re.S)
    if sm:
        work["style"] = sm.group(1).strip()
    km = re.search(r"##\s*Tonalidad\s*\n(.+?)(?=\n##|\n###|$)", md, re.I | re.S)
    if km:
        work["key"] = km.group(1).strip()
    default_inst = detect_inst(work["style"])

    for raw in re.split(r"###\s+", md)[1:]:
        lines = raw.split("\n")
        name = lines[0].strip()
        line0 = md[: md.find(raw)].count("\n") + 1 if raw in md else 0
        sec = {
            "name": name, "instrument": default_inst, "tempo": work["tempo"],
            "notes": "", "chords": "", "dynamic": None, "repeat": 1,
            "bass": "auto", "percusion": "ninguno", "line_no": line0,
        }
        for i, line in enumerate(lines[1:], start=line0 + 1):
            low = line.lower().strip()
            if low.startswith("notas:"):
                sec["notes"] = line.split(":", 1)[1].strip()
            elif low.startswith("acordes:"):
                sec["chords"] = line.split(":", 1)[1].strip()
            elif low.startswith("instrumento:"):
                raw_inst = line.split(":", 1)[1].strip()
                inst = detect_inst(raw_inst)
                if raw_inst.lower().split()[0] not in GM_PROGRAM and inst == "piano" and "piano" not in raw_inst.lower():
                    errors.append(f"linea ~{i}: instrumento desconocido '{raw_inst}'")
                sec["instrument"] = inst
            elif low.startswith("tempo:"):
                m = re.search(r"(\d+)", line)
                sec["tempo"] = max(40, min(220, int(m.group(1)))) if m else work["tempo"]
            elif low.startswith("dinamica:") or low.startswith("dinámica:"):
                dyn = line.split(":", 1)[1].strip().lower()
                if dyn in DYNAMIC_LEVELS:
                    sec["dynamic"] = dyn
                else:
                    errors.append(f"linea ~{i}: dinamica invalida '{dyn}'")
            elif low.startswith("percusion:") or low.startswith("percusión:"):
                p = line.split(":", 1)[1].strip().lower()
                sec["percusion"] = p if p in PERCUSSION_STYLES else "ninguno"
            elif low.startswith("repetir:"):
                m = re.search(r"(\d+)", line)
                sec["repeat"] = max(1, min(8, int(m.group(1)))) if m else 1
        if not sec["notes"]:
            errors.append(f"seccion '{name}': falta notas")
        else:
            bad = []
            for tok in sec["notes"].split():
                if REST_TOKEN_RE.match(tok):
                    continue
                if not parse_note_token(tok):
                    bad.append(tok)
            if bad and len(errors) < 8:
                errors.append(f"seccion '{name}': tokens invalidos {bad[:5]}")
        for tok in sec["chords"].split():
            if not parse_chord_token(tok) and len(errors) < 10:
                errors.append(f"seccion '{name}': acorde invalido '{tok}'")
        work["sections"].append(sec)
    if not work["sections"]:
        errors.append("no hay secciones ###")
    return work, errors


def score_to_midi(md, path, strict=True):
    import pretty_midi

    work, errors = parse_pmns(md)
    if errors and strict:
        raise ValueError("; ".join(errors[:6]))
    pm = pretty_midi.PrettyMIDI(initial_tempo=work["tempo"])
    instruments = {}

    def get_inst(name, is_drum=False):
        key = "drums" if is_drum else name
        if key not in instruments:
            prog = 0 if is_drum else GM_PROGRAM.get(name, 0)
            instruments[key] = pretty_midi.Instrument(program=prog, is_drum=is_drum, name=name)
        return instruments[key]

    global_time = 0.0
    n_sections = len(work["sections"])
    for s_idx, sec in enumerate(work["sections"]):
        beat_sec = 60.0 / sec["tempo"]
        base_vel = DYNAMIC_LEVELS[sec["dynamic"]] if sec["dynamic"] else int(58 + (s_idx / max(n_sections - 1, 1)) * 54)
        inst_name = sec["instrument"]
        is_solo = inst_name in SOLO_INSTRUMENTS
        for _rep in range(sec["repeat"]):
            sec_start = global_time
            inst = get_inst(inst_name)
            t = sec_start
            for tok in sec["notes"].split():
                rm = REST_TOKEN_RE.match(tok)
                if rm:
                    t += DUR[rm.group(1).lower()] * beat_sec
                    continue
                parsed = parse_note_token(tok)
                if not parsed:
                    continue
                midi, beats, legato, accent = parsed
                vel = min(127, base_vel + (14 if accent else 0))
                gate = 1.0 if legato else 0.96
                dur = beats * beat_sec
                inst.notes.append(
                    pretty_midi.Note(
                        velocity=vel,
                        pitch=min(max(midi, 21), 108),
                        start=t,
                        end=t + max(dur * gate, 0.05),
                    )
                )
                t += dur
            melodic_end = t
            if sec["chords"] and not is_solo:
                ch_name = (
                    "warm_pad"
                    if inst_name in ("pad", "strings", "choir", "synth_strings", "choir_pad", "brass")
                    else "harp"
                )
                ch_inst = get_inst(ch_name)
                ct = sec_start
                for tok in sec["chords"].split():
                    ch = parse_chord_token(tok)
                    if not ch:
                        continue
                    dur_b = ch["beats"]
                    for j, off in enumerate(ch["intervals"]):
                        ch_inst.notes.append(
                            pretty_midi.Note(
                                velocity=min(127, int(base_vel * 0.34) + (5 if j == 0 else 0)),
                                pitch=min(max(ch["root"] + off, 21), 108),
                                start=ct,
                                end=ct + dur_b * beat_sec,
                            )
                        )
                    ct += dur_b * beat_sec
            if sec["bass"] in ("auto", "si", "sí") and sec["chords"] and not is_solo:
                bass = get_inst("finger_bass")
                bt = sec_start
                for tok in sec["chords"].split():
                    ch = parse_chord_token(tok)
                    if not ch:
                        continue
                    root_bass = ch["root"] - 24
                    for k in range(max(1, int(ch["beats"]))):
                        bass.notes.append(
                            pretty_midi.Note(
                                velocity=int(base_vel * 0.72),
                                pitch=min(max(root_bass, 21), 48),
                                start=bt + k * beat_sec,
                                end=bt + k * beat_sec + 0.9 * beat_sec,
                            )
                        )
                    bt += ch["beats"] * beat_sec
            if sec["percusion"] in ("epica", "marcha"):
                drums = get_inst("timpani")
                pt = sec_start
                while pt < melodic_end - 0.01:
                    drums.notes.append(
                        pretty_midi.Note(
                            velocity=int(base_vel * 0.85),
                            pitch=41 if sec["percusion"] == "epica" else 45,
                            start=pt,
                            end=pt + 0.2,
                        )
                    )
                    pt += (2.0 if sec["percusion"] == "epica" else 1.0) * beat_sec
            if inst_name in SUSTAIN_INSTRUMENTS and melodic_end > sec_start:
                inst.control_changes.append(pretty_midi.ControlChange(64, 127, sec_start))
                inst.control_changes.append(pretty_midi.ControlChange(64, 0, melodic_end))
            global_time = melodic_end

    for inst in instruments.values():
        if inst.notes:
            pm.instruments.append(inst)
    if not pm.instruments:
        if strict:
            raise ValueError("No hay notas interpretables")
        inst = get_inst("piano")
        for i, p in enumerate([60, 64, 67, 72]):
            inst.notes.append(pretty_midi.Note(90, p, i * 0.5, i * 0.5 + 0.4))
        pm.instruments.append(inst)
    pm.write(path)
    return path, work


def find_soundfont():
    for p in SOUNDFONT_CANDIDATES:
        if os.path.isfile(p):
            return p
    return None


def midi_to_mp3(midi_path, mp3_path):
    from pydub import AudioSegment

    sf2 = find_soundfont()
    if not sf2:
        raise RuntimeError("No SoundFont (instala fluid-soundfont-gm)")
    wav_path = midi_path.replace(".mid", ".wav")
    subprocess.run(
        ["fluidsynth", "-ni", "-g", "1.3", "-R", "1", "-C", "1", sf2, midi_path, "-F", wav_path, "-r", "44100"],
        check=True,
        stdout=subprocess.DEVNULL,
        stderr=subprocess.DEVNULL,
    )
    audio = AudioSegment.from_wav(wav_path)
    peak = audio.max_dBFS
    if peak < -3:
        audio = audio.apply_gain(-3 - peak)
    audio.export(mp3_path, format="mp3", bitrate="192k")
    if os.path.exists(wav_path):
        os.unlink(wav_path)
    return mp3_path


def tool_web_search(query, max_results=5):
    results = []
    try:
        q = urllib.parse.quote(query)
        url = f"https://api.duckduckgo.com/?q={q}&format=json&no_html=1&skip_disambig=1"
        req = urllib.request.Request(url, headers={"User-Agent": "AetherStudio/1.0"})
        with urllib.request.urlopen(req, timeout=8) as resp:
            data = json.loads(resp.read().decode("utf-8", errors="ignore"))
        if data.get("AbstractText"):
            results.append(data["AbstractText"][:500])
        for t in data.get("RelatedTopics", [])[:max_results]:
            if isinstance(t, dict) and t.get("Text"):
                results.append(t["Text"][:300])
    except Exception:
        pass
    try:
        q = urllib.parse.quote(query.replace(" ", "_"))
        url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{q}"
        req = urllib.request.Request(url, headers={"User-Agent": "AetherStudio/1.0"})
        with urllib.request.urlopen(req, timeout=8) as resp:
            data = json.loads(resp.read().decode("utf-8", errors="ignore"))
        if data.get("extract"):
            results.append(data["extract"][:700])
    except Exception:
        pass
    return "\n".join(f"- {r}" for r in results[:6]) if results else "Sin resultados. Usa tu conocimiento."


def tool_validate(md):
    _, errors = parse_pmns(md)
    if not errors:
        return "OK: partitura valida"
    return "ERRORES:\n" + "\n".join(f"- {e}" for e in errors[:12])


def tool_instruments():
    return "Instrumentos validos: " + ", ".join(sorted(GM_PROGRAM.keys()))


def openrouter_chat(messages, max_tokens=2000):
    body = json.dumps({
        "model": MODEL_ID,
        "messages": messages,
        "max_tokens": max_tokens,
        "temperature": 0.7,
    }).encode()
    req = urllib.request.Request(
        OPENROUTER_URL,
        data=body,
        headers={
            "Authorization": f"Bearer {OPENROUTER_KEY}",
            "Content-Type": "application/json",
            "HTTP-Referer": "https://huggingface.co",
            "X-Title": "Aether Studio",
        },
        method="POST",
    )
    with urllib.request.urlopen(req, timeout=120) as resp:
        data = json.loads(resp.read().decode())
    return data["choices"][0]["message"]["content"]


def clean_score(text):
    text = text.strip()
    if text.lower().startswith("lo siento no puedo hacer eso") and "notas:" not in text.lower():
        return "lo siento no puedo hacer eso"
    idx = text.find("#")
    if idx == -1:
        return None
    md = text[idx:]
    for stop in ("```", "<|im_end|>"):
        if stop in md:
            md = md[: md.find(stop)]
    if "notas:" not in md.lower():
        return None
    return md.strip()


def agent_compose(prompt, max_rounds=4):
    messages = [
        {"role": "system", "content": SYSTEM},
        {"role": "user", "content": prompt.strip()},
    ]
    last = ""
    for _ in range(max_rounds):
        last = openrouter_chat(messages, max_tokens=2200)
        search = re.search(r"TOOL_SEARCH:\s*(.+)", last, re.I)
        if search:
            q = search.group(1).strip().split("\n")[0][:200]
            result = tool_web_search(q)
            messages.append({"role": "assistant", "content": last})
            messages.append({"role": "user", "content": f"Resultado TOOL_SEARCH ({q}):\n{result}\nContinua. Si ya puedes, escribe SOLO la partitura PMNS."})
            continue
        if re.search(r"TOOL_INSTRUMENTS\s*$", last, re.I | re.M) or "TOOL_INSTRUMENTS" in last and "notas:" not in last.lower():
            result = tool_instruments()
            messages.append({"role": "assistant", "content": last})
            messages.append({"role": "user", "content": f"{result}\nContinua con la partitura PMNS."})
            continue
        val = re.search(r"TOOL_VALIDATE:\s*(.+)", last, re.I | re.S)
        if val and "notas:" in last.lower():
            md_try = clean_score(last) or last
            result = tool_validate(md_try)
            messages.append({"role": "assistant", "content": last})
            messages.append({"role": "user", "content": f"Resultado TOOL_VALIDATE:\n{result}\nSi hay errores, corrige y escribe SOLO la partitura final. Si OK, escribe SOLO la partitura."})
            continue
        md = clean_score(last)
        if md and md != "lo siento no puedo hacer eso":
            return md, last
        if md == "lo siento no puedo hacer eso":
            return md, last
        messages.append({"role": "assistant", "content": last})
        messages.append({"role": "user", "content": "Responde ahora SOLO con la partitura PMNS completa (empieza con #)."})
    md = clean_score(last)
    return md or last, last


LIBRARY = []


def get_duration(mp3_path):
    try:
        from pydub import AudioSegment
        a = AudioSegment.from_mp3(mp3_path)
        s = len(a) / 1000
        return f"{int(s // 60)}:{int(s % 60):02d}"
    except Exception:
        return "--:--"


def render_library():
    if not LIBRARY:
        return '<div class="empty-library"><div class="empty-icon">🎵</div><div class="empty-title">Aún no hay composiciones</div><div class="empty-sub">Escribe una descripción y pulsa Crear.</div></div>'
    cards = []
    for s in LIBRARY:
        h = abs(hash(s["title"])) % 360
        grad = f"linear-gradient(135deg, hsl({h},65%,45%) 0%, hsl({(h+50)%360},65%,25%) 100%)"
        style_short = s["style"][:70] + ("…" if len(s["style"]) > 70 else "")
        cards.append(
            f'<div class="song-card" onclick="selectSong(\'{s["id"]}\')">'
            f'<div class="song-cover" style="background:{grad}"><span class="cover-icon">♪</span>'
            f'<span class="cover-dur">{s["duration"]}</span></div>'
            f'<div class="song-info"><div class="song-title">{s["title"]}</div>'
            f'<div class="song-meta">{style_short}</div>'
            f'<div class="song-stats"><span>{s["tempo"]} BPM</span><span>·</span><span>{s["key"]}</span></div></div>'
            f'<div class="song-play">▶</div></div>'
        )
    return f'<div class="library">{"".join(cards)}</div>'


CUSTOM_CSS = """
.gradio-container { background: #0a0a0d !important; color: #e5e7eb !important; font-family: Inter, sans-serif !important; max-width: 100% !important; }
footer { display: none !important; }
#aether-topbar { display:flex; align-items:center; gap:14px; padding:14px 26px; background:#0f0f14; border-bottom:1px solid #1c1c25; }
#aether-logo { width:34px; height:34px; border-radius:9px; background:linear-gradient(135deg,#8b5cf6,#06b6d4); display:flex; align-items:center; justify-content:center; }
#aether-brand-name { font-size:15px; font-weight:700; color:#fff; }
#aether-brand-model { font-size:11px; font-weight:600; color:#67e8f9; background:rgba(6,182,212,0.10); border:1px solid rgba(6,182,212,0.28); padding:3px 9px; border-radius:999px; margin-left:10px; }
#aether-main { display:flex; gap:18px; padding:18px; min-height:70vh; }
#aether-create { width:380px; flex-shrink:0; background:#0f0f14; border:1px solid #1c1c25; border-radius:14px; padding:18px; }
#compose-btn { background:linear-gradient(135deg,#8b5cf6,#06b6d4) !important; border:none !important; border-radius:11px !important; color:#fff !important; font-weight:700 !important; width:100% !important; }
#aether-library { flex:1; background:#0f0f14; border:1px solid #1c1c25; border-radius:14px; padding:18px; }
.library { display:flex; flex-direction:column; gap:10px; }
.song-card { display:flex; align-items:center; gap:14px; padding:12px; background:#13131a; border:1px solid #1c1c25; border-radius:12px; cursor:pointer; }
.song-cover { width:64px; height:64px; border-radius:9px; display:flex; align-items:center; justify-content:center; position:relative; }
.cover-dur { position:absolute; bottom:5px; right:6px; font-size:10px; color:#fff; background:rgba(0,0,0,0.65); padding:1px 5px; border-radius:4px; }
.song-title { font-size:14.5px; font-weight:600; color:#fff; }
.song-meta { font-size:12px; color:#94a3b8; }
.song-stats { font-size:11px; color:#64748b; display:flex; gap:6px; }
.song-play { width:34px; height:34px; border-radius:50%; background:rgba(139,92,246,0.15); color:#c4b5fd; display:flex; align-items:center; justify-content:center; }
.empty-library { text-align:center; padding:60px 20px; color:#64748b; }
#aether-player { padding:12px 24px; background:#0c0c11; border-top:1px solid #1c1c25; }
#song-selector { display:none !important; }
"""

HEADER_HTML = f"""<div id="aether-topbar"><div id="aether-logo">🎼</div><div id="aether-brand-name">{STUDIO_NAME}</div><span id="aether-brand-model">{MODEL_DISPLAY_NAME}</span></div>"""
SELECT_JS = """<script>function selectSong(id){const el=document.querySelector('#song-selector input, #song-selector textarea');if(el){el.value=id;el.dispatchEvent(new Event('input',{bubbles:true}));el.dispatchEvent(new Event('change',{bubbles:true}));}}</script>"""


def process_request(prompt):
    if not prompt or not prompt.strip():
        yield "Escribe qué canción quieres.", "", render_library(), gr.update(), gr.update()
        return
    yield "🎼 *Componiendo con Nemotron 3 Ultra (OpenRouter)...*", "", render_library(), gr.update(), gr.update()
    try:
        md, raw = agent_compose(prompt)
    except Exception as e:
        yield f"❌ Error OpenRouter: {e}", str(e), render_library(), gr.update(), gr.update()
        return
    if md == "lo siento no puedo hacer eso":
        yield "🚫 No es una petición musical.", raw, render_library(), gr.update(), gr.update()
        return
    if not md or "notas:" not in md.lower():
        yield "🚫 El modelo no devolvió partitura válida.", raw, render_library(), gr.update(), gr.update()
        return
    yield "⏳ *Sintetizando audio...*", raw, render_library(), gr.update(), gr.update()
    mid = tempfile.NamedTemporaryFile(suffix=".mid", delete=False).name
    mp3 = mid.replace(".mid", ".mp3")
    try:
        try:
            _, work = score_to_midi(md, mid, strict=True)
            warnings = []
        except ValueError as ve:
            _, work = score_to_midi(md, mid, strict=False)
            warnings = [str(ve)]
        midi_to_mp3(mid, mp3)
        song_id = hashlib.md5(f"{work['title']}{time.time()}".encode()).hexdigest()[:10]
        cached_mp3 = os.path.join(CACHE_DIR, f"{song_id}.mp3")
        subprocess.run(["cp", mp3, cached_mp3], check=False)
        song_meta = {
            "id": song_id,
            "title": work.get("title", "Pieza"),
            "style": work.get("style") or "Instrumental",
            "tempo": work.get("tempo", 100),
            "key": work.get("key") or "—",
            "duration": get_duration(cached_mp3),
            "path": cached_mp3,
        }
        LIBRARY.insert(0, song_meta)
        status = f"✅ **{song_meta['title']}** lista · {song_meta['duration']} · {song_meta['tempo']} BPM"
        if warnings:
            status += f"\n\n*(validación parcial: {warnings[0][:120]})*"
        yield status, md, render_library(), cached_mp3, gr.update(value=song_id)
    except Exception as e:
        yield f"❌ Error sintetizando: {e}", md, render_library(), gr.update(), gr.update()
    finally:
        if os.path.exists(mid):
            os.unlink(mid)
        if os.path.exists(mp3):
            try:
                os.unlink(mp3)
            except Exception:
                pass


def load_song_from_library(song_id):
    if not song_id:
        return None
    for s in LIBRARY:
        if s["id"] == song_id:
            return s["path"]
    return None


with gr.Blocks(css=CUSTOM_CSS, title=STUDIO_NAME) as demo:
    gr.HTML(HEADER_HTML + SELECT_JS)
    song_selector = gr.Textbox(elem_id="song-selector", visible=False)
    with gr.Row(elem_id="aether-main"):
        with gr.Column(elem_id="aether-create"):
            gr.HTML('<div class="panel-title">Describe tu pieza</div>')
            prompt_in = gr.Textbox(placeholder="Ej: canción medieval épica con laúd y recorder...", show_label=False, lines=5)
            compose_btn = gr.Button("✦  Crear composición", elem_id="compose-btn")
            gr.HTML('<div class="panel-title" style="margin-top:16px">Estado</div>')
            status_out = gr.Markdown("*Listo.*")
            with gr.Accordion("Partitura / debug", open=False):
                raw_out = gr.Textbox(show_label=False, lines=12, interactive=False)
        with gr.Column(elem_id="aether-library"):
            gr.HTML('<div class="panel-title">Biblioteca</div>')
            library_out = gr.HTML(render_library())
    with gr.Row(elem_id="aether-player"):
        audio_out = gr.Audio(show_label=False, type="filepath")
    compose_btn.click(fn=process_request, inputs=[prompt_in], outputs=[status_out, raw_out, library_out, audio_out, song_selector])
    prompt_in.submit(fn=process_request, inputs=[prompt_in], outputs=[status_out, raw_out, library_out, audio_out, song_selector])
    song_selector.change(fn=load_song_from_library, inputs=[song_selector], outputs=[audio_out])

if __name__ == "__main__":
    demo.queue(max_size=4).launch()