import json, pickle, hashlib, collections, random, itertools, math
from pathlib import Path
import numpy as np
import openpyxl

INSTRUMENTS=['grasper','bipolar','hook','scissors','clipper','irrigator']
TOOLS=INSTRUMENTS+['specimen_bag']
ANATOMIES=['gallbladder','liver','omentum','gut','cystic_plate']
VERBS=['grasp','retract','dissect','coagulate','clip','cut','aspirate','irrigate','pack']
GERUND={'grasp':'Grasping','retract':'Retracting','dissect':'Dissecting','coagulate':'Coagulating','clip':'Clipping','cut':'Cutting','aspirate':'Aspirating','irrigate':'Irrigating','pack':'Packing'}
PARTICIPLE={'grasp':'grasped','retract':'retracted','dissect':'dissected','coagulate':'coagulated','clip':'clipped','cut':'cut','aspirate':'aspirated','irrigate':'irrigated','pack':'packed'}
PHASES={0:'Preparation',1:'Calot triangle dissection',2:'Clipping and cutting',3:'Gallbladder dissection',4:'Gallbladder packaging',5:'Cleaning and coagulation',6:'Gallbladder retraction'}
QUADS=['Upper left','Upper right','Lower left','Lower right']
INV={'left':'right','right':'left','above':'below','below':'above'}
FAMILIES={'P':'Perception','R':'Relation','C':'Composition','PR':'Procedure','V':'CVS','D':'Dynamic'}
def display(x):return x.replace('_',' ')
def title(x):return display(x).capitalize()
def digest(x):return hashlib.sha256(json.dumps(x,sort_keys=True,separators=(',',':')).encode()).hexdigest()
def write_json(p,x):Path(p).parent.mkdir(parents=True,exist_ok=True);Path(p).write_text(json.dumps(x,ensure_ascii=False,indent=2))
def read_jsonl(p):
    with open(p) as f:
        for l in f:
            if l.strip():yield json.loads(l)
def write_jsonl(p,rows):
    Path(p).parent.mkdir(parents=True,exist_ok=True)
    with open(p,'w') as f:
        for r in rows:f.write(json.dumps(r,ensure_ascii=False,separators=(',',':'))+'\n')
def family(task):return FAMILIES[''.join(x for x in task if x.isalpha())]

class Sources:
    def __init__(self,ori,videos):
        self.ori=Path(ori);self.videos=videos;self.phase={};self.ivt={};self.graphs={};self.action_starts={};self.cvt={};self.counts=collections.Counter()
        for fn in ['train/1fps_100_0.pickle','val/1fps.pickle','test/1fps.pickle']:
            p=self.ori/' Cholec80_labels/labels'/fn
            with p.open('rb') as f:d=pickle.load(f)
            for key,rows in d.items():
                v=int(key[5:])
                if v in videos:
                    self.phase[v]=rows
                    assert all(int(r['Original_frame_id'])==i*25 for i,r in enumerate(rows)),('alignment',v)
        vocab={int(a):tuple(b.split(',')) for line in (self.ori/'CholecT45/dict/triplet.txt').read_text().splitlines() for a,b in [line.split(':',1)]}
        for v in videos:
            self.ivt[v]={};starts={}
            for line in (self.ori/f'CholecT45/triplet/VID{v:02d}.txt').read_text().splitlines():
                row=list(map(int,line.split(',')));f=row[0];ts={vocab[i] for i,a in enumerate(row[1:]) if a}
                for t in ts:
                    if t not in starts:starts[t]=f
                    self.action_starts[v,f,t]=starts[t]
                starts={t:starts[t] for t in ts};self.ivt[v][f]=ts
            for f in range(len(self.phase[v])):
                p=self.ori/f'scene_graph/VID{v:02d}_{f}.json'
                if p.exists():
                    try:self.graphs[v,f]=json.loads(p.read_text())['scenes'][0]
                    except (KeyError,IndexError,ValueError):self.counts['invalid_sg']+=1
        self.cvs_rows=[]
        ws=openpyxl.load_workbook(self.ori/'Cholec80_CVS/cholec80-CVS.xlsx',data_only=True).active
        for i,row in enumerate(ws.values):
            if not i or int(row[0]) not in videos:continue
            r=dict(row=i+1,video=int(row[0]),start=int(row[2])*60+int(row[3]),end=int(row[4])*60+int(row[5]),scores=list(map(int,row[6:9])),total=int(row[9]),cv=int(row[1]))
            assert sum(r['scores'])==r['total'] and int(r['total']>=5)==r['cv']
            self.cvs_rows.append(r)
        for v in videos:
            first=next(i for i,r in enumerate(self.phase[v]) if r['Phase_gt']==2)
            rs=[r for r in self.cvs_rows if r['video']==v and r['start']<=r['end']]
            good={}
            for f in range(first):
                if self.phase[v][f]['Phase_gt']!=1:continue
                rr=[r for r in rs if r['start']<=f<=r['end']];vals={tuple(r['scores']) for r in rr}
                if len(vals)>1:self.counts['cvs_conflicting_seconds']+=1;continue
                score=next(iter(vals)) if vals else (0,0,0)
                good[f]=dict(scores=list(score),cv=int(sum(score)>=5),rows=[r['row'] for r in rr],source='explicit_interval' if rr else 'protocol_default_zero')
            for k in range(4):
                segments=[]
                for f,r in good.items():
                    value=r['scores'][k] if k<3 else r['cv']
                    if segments and segments[-1]['end']==f-1 and segments[-1]['value']==value:segments[-1]['end']=f
                    else:segments.append(dict(start=f,end=f,value=value))
                for seg in segments:
                    for f in range(seg['start'],seg['end']+1):
                        good[f][f'episode_{k}']=seg
            self.cvt[v]=good
        print('Source loaded',len(self.graphs),'graphs;',sum(len(x) for x in self.ivt.values()),'IVT frames',flush=True)
    def image_path(self,v,f):return self.ori/f'CholecT45/data/VID{v:02d}/{f:06d}.png'
    def tools(self,v,f):
        t=self.phase[v][f]['Tool_gt']
        return None if t is None else {TOOLS[i] for i,a in enumerate(t) if a}
    def clean_objects(self,v,f):
        g=self.graphs.get((v,f),{});out={}
        for i,o in enumerate(g.get('objects',[])):
            b=o.get('bbox');c=o.get('center')
            if not b or not c or len(b)!=4:continue
            x,y,X,Y=b
            if not (0<=x<X<=430 and 0<=y<Y<=240):continue
            if abs(c[0]-(x+X)/2)>0.01 or abs(c[1]-(y+Y)/2)>0.01:continue
            w=X-x;h=Y-y
            if o['type']=='instrument' and (w<15 or h<10 or w*h<450):continue
            if o['type']=='anatomy' and (w<25 or h<18 or w*h<1000):continue
            out[i]=o
        return out
    def unique(self,v,f):
        objs=self.clean_objects(v,f);cnt=collections.Counter(o['component'] for o in self.graphs.get((v,f),{}).get('objects',[]))
        return {o['component']:i for i,o in objs.items() if cnt[o['component']]==1}
    def spatial(self,v,f,a,b,p,require_edge=True):
        if a==b:return False
        o=self.graphs[v,f]['objects'];axis=0 if p in ['left','right'] else 1
        d=(o[a]['center'][axis]-o[b]['center'][axis])*(1 if p in ['right','below'] else -1)
        if d<(.05*(430 if axis==0 else 240)):return False
        if not require_edge:return True
        r=self.graphs[v,f]['relationships'];return a in r.get(p,[[]]*len(o))[b] and b in r.get(INV[p],[[]]*len(o))[a]
    def definite(self,v,f,a,b,p):
        if a==b:return True
        o=self.graphs[v,f]['objects'];axis=0 if p in ['left','right'] else 1
        return abs(o[a]['center'][axis]-o[b]['center'][axis])>=.05*(430 if axis==0 else 240)
    def consistent(self,v,f,a,b,p):
        return self.definite(v,f,a,b,p) and (not self.spatial(v,f,a,b,p,False) or self.spatial(v,f,a,b,p,True))
    def quadrant(self,v,f,a,b=None):
        o=self.graphs[v,f]['objects'];x,y=o[a]['center'];X,Y=(215,120) if b is None else o[b]['center']
        if abs(x-X)<21.5 or abs(y-Y)<12:return None
        p='left' if x<X else 'right';q='above' if y<Y else 'below'
        if b is not None and not (self.spatial(v,f,a,b,p) and self.spatial(v,f,a,b,q)):return None
        return ('Upper' if y<Y else 'Lower')+(' left' if x<X else ' right')
    def action_edge(self,v,f,inst,verb,target):
        u=self.unique(v,f)
        if inst not in u or target not in u:return False
        g=self.graphs[v,f];return u[target] in g['relationships'].get(verb,[[]]*len(g['objects']))[u[inst]]
    def source_evidence(self,v,frames):
        out=[]
        for f in frames:
            r=self.phase[v][f];g=self.graphs.get((v,f))
            out.append(dict(video=f'VID{v:02d}',frame_1fps=f,original_frame_id=int(r['Original_frame_id']),phase=int(r['Phase_gt']),tools=None if r['Tool_gt'] is None else list(map(int,r['Tool_gt'])),ivt=sorted(self.ivt[v].get(f,set())),scene_graph=g,source_image=str(self.image_path(v,f))))
        return out