# -*- coding: utf-8 -*-
"""SRT desde tiempos de palabra. Parte por frases; solo dentro de una frase larga
   busca el corte natural más cercano al reparto equilibrado."""
import json, re, sys, os, math

MAXL=42; MAXR=2; MAXCUE=MAXL*MAXR-4   # 80 caracteres por subtítulo
MAXS=6.0; MINS=1.2; PAUSA=0.6
CORTE_BLANDO=re.compile(r'[,;:]$')
CONECTOR={"y","o","pero","porque","que","cuando","donde","si","para","como","aunque",
          "and","or","but","because","that","when","where","if","to","as","which","so"}

def hhmmss(t):
    h=int(t//3600); m=int(t%3600//60); s=t%60
    return f"{h:02d}:{m:02d}:{s:06.3f}".replace(".",",")

def reparte(txt):
    p=txt.split()
    if len(txt)<=MAXL: return [txt]
    mejor=None
    for i in range(1,len(p)):
        a=" ".join(p[:i]); b=" ".join(p[i:])
        if len(a)<=MAXL and len(b)<=MAXL:
            bonus = -6 if CORTE_BLANDO.search(a) else (3 if p[i].lower() in CONECTOR else 0)
            d=abs(len(a)-len(b))+bonus
            if mejor is None or d<mejor[0]: mejor=(d,[a,b])
    return mejor[1] if mejor else [txt]

def normaliza(pal):
    out=[];i=0
    while i<len(pal):
        w=pal[i]["w"]
        if i+1<len(pal) and w.lower()=="agent" and pal[i+1]["w"].lower().startswith("squad"):
            out.append({"t":pal[i]["t"],"e":pal[i+1]["e"],"w":"AgentSquad"+pal[i+1]["w"][5:]}); i+=2; continue
        # nombres propios que Whisper deforma, verificados uno a uno contra el audio
        for pat,rep in ((r'\bAIB\s*C\s*0?1\b','AIB-C01'),
                        (r'\bClot\b','Claude'),
                        (r'\bStrategies\b','Strategist'),
                        (r'\banthropic\b','Anthropic'),
                        (r'\bAnthropics\b','Anthropic')):
            w=re.sub(pat,rep,w)
        out.append({"t":pal[i]["t"],"e":pal[i]["e"],"w":w}); i+=1
    return out

def frases(pal):
    """Agrupa en frases; una pausa larga también cierra frase."""
    fr=[];act=[]
    for i,p in enumerate(pal):
        act.append(p)
        fin=bool(re.search(r'[.?!]["»]?$',p["w"]))
        pausa=(i+1<len(pal)) and (pal[i+1]["t"]-p["e"]>PAUSA)
        if fin or pausa: fr.append(act); act=[]
    if act: fr.append(act)
    return fr

FUNCION=set("el la los las un una unos unas de del al a en con por para y o u que se su sus lo le les es son "
            "the a an of to in on for and or that is are was were with as at by from its his her their this these".split())

def trocea(fr):
    """Corta una frase en el mínimo de trozos que cumplan MAXCUE y MAXS.
       Los límites se eligen por índice, nunca mutando dentro del bucle, y se
       puntúa cada candidato: premia cortar tras coma, castiga cortar en palabra función."""
    txt=" ".join(p["w"] for p in fr); dur=fr[-1]["e"]-fr[0]["t"]
    n=max(math.ceil(len(txt)/MAXCUE), math.ceil(dur/MAXS))
    if n<=1: return [fr]
    acum=[]; c=0
    for p in fr: c+=len(p["w"])+1; acum.append(c)
    total=acum[-1]
    limites=[]; ini=0
    for k in range(1,n):
        objetivo=total*k/n
        mejor=None
        for j in range(ini+1,len(fr)-1):
            largo=acum[j]-(acum[ini-1] if ini>0 else 0)
            if largo>MAXCUE: break
            if fr[j]["e"]-fr[ini]["t"]>MAXS: break
            pen=abs(acum[j]-objetivo)
            if CORTE_BLANDO.search(fr[j]["w"]): pen-=28
            if fr[j]["w"].lower().strip(".,;:") in FUNCION: pen+=22
            if fr[j+1]["w"].lower().strip(".,;:") in FUNCION: pen-=6
            if mejor is None or pen<mejor[0]: mejor=(pen,j)
        if mejor is None: break
        limites.append(mejor[1]); ini=mejor[1]+1
    trozos=[]; a=0
    for b in limites+[len(fr)-1]:
        trozos.append(fr[a:b+1]); a=b+1
    return [t for t in trozos if t]

def construir(pal):
    pal=normaliza(pal); cues=[]
    for fr in frases(pal):
        for tz in trocea(fr):
            txt=re.sub(r'\s+([,.;:?!])',r'\1'," ".join(p["w"] for p in tz)).strip()
            if not txt: continue
            cues.append({"t":tz[0]["t"],"e":max(tz[-1]["e"],tz[0]["t"]+MINS),"txt":txt})
    # fusionar subtítulos huérfanos (1-2 palabras) con el anterior si cabe
    i=1
    while i<len(cues):
        c=cues[i]
        if len(c["txt"].split())<=2 and len(cues[i-1]["txt"])+len(c["txt"])+1<=MAXCUE \
           and c["e"]-cues[i-1]["t"]<=MAXS+1.5:
            cues[i-1]["txt"]=(cues[i-1]["txt"]+" "+c["txt"]).replace("  "," ")
            cues[i-1]["e"]=c["e"]; cues.pop(i)
        else: i+=1
    # reparación final: ningún subtítulo puede quedar sin caber en dos renglones de MAXL
    i=0
    while i<len(cues):
        c=cues[i]
        if any(len(l)>MAXL for l in reparte(c["txt"])):
            pal_=c["txt"].split()
            mejor=None
            for k in range(1,len(pal_)):
                a=" ".join(pal_[:k]); b=" ".join(pal_[k:])
                if max(len(x) for x in reparte(a)+reparte(b))<=MAXL:
                    d=abs(len(a)-len(b))
                    if mejor is None or d<mejor[0]: mejor=(d,k,a,b)
            if mejor:
                _,k,a,b=mejor
                frac=len(a)/(len(a)+len(b)); span=c["e"]-c["t"]
                med=c["t"]+span*frac
                cues[i]={"t":c["t"],"e":med-0.02,"txt":a}
                cues.insert(i+1,{"t":med,"e":c["e"],"txt":b})
                continue
        i+=1
    for i in range(len(cues)-1):
        if cues[i]["e"]>cues[i+1]["t"]-0.04:
            cues[i]["e"]=max(cues[i]["t"]+0.5,cues[i+1]["t"]-0.04)
    return cues

if __name__=="__main__":
    S="/tmp/claude-1000/-home-clawd/16492513-0f24-4b26-8e34-c28a8085f218/scratchpad/"
    cues=construir(json.load(open(S+sys.argv[1])))
    with open(sys.argv[2],"w",encoding="utf-8") as f:
        for n,c in enumerate(cues,1):
            f.write(f"{n}\n{hhmmss(c['t'])} --> {hhmmss(c['e'])}\n"+"\n".join(reparte(c["txt"]))+"\n\n")
    largos=sum(1 for c in cues if any(len(l)>MAXL for l in reparte(c["txt"])))
    tres=sum(1 for c in cues if len(reparte(c["txt"]))>MAXR)
    cortos=sum(1 for c in cues if c["e"]-c["t"]<0.9)
    solapes=sum(1 for i in range(len(cues)-1) if cues[i]["e"]>cues[i+1]["t"])
    huerf=sum(1 for c in cues if len(c["txt"].split())<=2)
    cps=max((len(c["txt"])/(c["e"]-c["t"])) for c in cues)
    print(f"{os.path.basename(sys.argv[2])}: {len(cues)} subtítulos · fin {cues[-1]['e']:.1f}s")
    print(f"   renglón >42c: {largos} · 3+ renglones: {tres} · <0.9s: {cortos} · solapes: {solapes} · huérfanos: {huerf} · car/s máx: {cps:.0f}")
