"""Reference-conditioned professional sprites, kept in a separate resumable queue."""
import argparse
import hashlib
import io
import json
from pathlib import Path
import sqlite3
import tarfile
import time
import background_production as engine

ROOT=Path(__file__).resolve().parents[1]
STATE=ROOT/'experiments/job-outfits'
BUFFER=Path('/tmp/vivarium-job-outfits')
REPO='laion/Vivarium-Greenscreen-Characters-FLUX-9B'
engine.STATE=STATE;engine.BUFFER=BUFFER;engine.REPO=REPO;engine.REPO_PREFIX='job-data';engine.SHARD_PREFIX='jobs';engine.ASSET_LABEL='job-outfit sprites'
connect=engine.connect;status=engine.status

def reference(record):
    phase=record['reference_source_phase'];assert phase in ['character-production','character-extension']
    db=sqlite3.connect(ROOT/f'experiments/{phase}/queue.sqlite');db.row_factory=sqlite3.Row
    row=db.execute('SELECT shard,metadata FROM images WHERE id=?',(record['reference_id'],)).fetchone();db.close()
    if row is None:raise RuntimeError('Reference not yet in a closed shard: '+record['reference_id'])
    m=json.loads(row['metadata']);assert m['personality_id']==record['personality_id'] and m['emotion']=='neutral'
    for key in ['age_group','age_years','gender','ethnicity','skin_tone','hair']:
        assert m[key]==record[key],(record['id'],'reference identity mismatch',key)
    path=Path('/tmp/vivarium-'+phase)/row['shard']
    with tarfile.open(path,'r:') as tar:data=tar.extractfile(record['reference_id']+'.png').read()
    digest=hashlib.sha256(data).hexdigest();assert digest==m['image_sha256']
    from PIL import Image
    with Image.open(io.BytesIO(data)) as im:
        assert im.size==(832,1248) and im.mode=='RGB';im.load();image=im.copy()
    return image.resize((416,624),Image.Resampling.BICUBIC),digest,dict(
        reference_source_shard=row['shard'],reference_source_repo_path=record['reference_source_repo_path']+row['shard'],
        reference_source_member=record['reference_id']+'.png',reference_source_generated_utc=m['generated_utc'])

def init():
    engine.init(STATE/'image-plan.json');c=connect()
    if c.execute("SELECT COUNT(*) FROM jobs WHERE status!='queued'").fetchone()[0]==0:
        plan=json.loads((STATE/'image-plan.json').read_text())
        # The first16 span all ten job families, the requested occupations and
        # young/middle/older adults of both genders, with references already made.
        requested=['physician','firefighter','police_officer','cashier','carpenter','bartender','debt_collector','supermarket_worker',
                   'judge','welder','beekeeper','school_teacher','hotel_receptionist','nurse','airline_pilot','sanitation_worker']
        cells=[('young_adult','male'),('young_adult','female'),('middle_adult','male'),('middle_adult','female'),
               ('older_adult','male'),('older_adult','female'),('younger_senior','male'),('younger_senior','female')]
        source=sqlite3.connect(ROOT/'experiments/character-production/queue.sqlite')
        available={r[0] for r in source.execute("SELECT id FROM images WHERE emotion='neutral'")};source.close()
        pilots=[]
        for i,key in enumerate(requested):
            candidates=[r for r in plan if r['job_key']==key and r['reference_source_phase']=='character-production' and r['reference_id'] in available]
            cell=cells[i%len(cells)];preferred=[r for r in candidates if (r['age_group'],r['gender'])==cell]
            pilots.append((preferred or candidates)[0]['id'])
        order=pilots+[r['id'] for r in plan if r['id'] not in pilots]
        assert len(order)==4640 and len(set(order))==4640
        for i,ident in enumerate(order):c.execute('UPDATE jobs SET position=? WHERE id=?',(i,ident))
        engine.dump(STATE/'planning/generation-order.json',dict(pilot_ids=pilots,order=order))
    c.execute("INSERT OR REPLACE INTO settings VALUES('sealed','true')");c.commit()

def worker(gpu,shared=False,limit=None):
    import torch
    from native_flux_inference import create_native_pipeline,generate_native_image,encode_text
    from character_pilot import metadata
    c=connect();c.execute("UPDATE jobs SET status='queued',worker=NULL WHERE status='running' AND worker=?",(gpu,));c.commit()
    engine.event(c,gpu,'loading')
    pipe=create_native_pipeline('characters',device='cpu' if shared else 'cuda:0',compile_mode='default',cfg_mode='batched')
    if shared:pipe.enable_model_cpu_offload(gpu_id=0)
    engine.event(c,gpu,'loaded');BUFFER.mkdir(parents=True,exist_ok=True)
    rows=list(c.execute('SELECT name FROM shards WHERE worker=?',(gpu,)))
    sequence=max([int(r['name'].removesuffix('.tar').rsplit('-',1)[1]) for r in rows]+[-1])+1
    first=not rows;warm=False;completed=0;refs={};scorer=None
    from teen_generation_safety import in_scope,screen_frame,persist_actual_plan
    while limit is None or completed<limit:
        records=[];target=min(2 if first else 20,(limit-completed) if limit is not None else 20)
        tar=None
        for _ in range(target):
            r=engine.claim(c,gpu)
            if r is None:break
            if tar is None:
                name=f'jobs-g{gpu}-{sequence:05d}.tar';partial=BUFFER/(name+'.partial');tar=tarfile.open(partial,'w',format=tarfile.USTAR_FORMAT)
            if r['personality_id'] not in refs:
                refs={r['personality_id']:reference(r)}
            image,ref_sha,provenance=refs[r['personality_id']]
            t=time.perf_counter();embeds=encode_text(pipe,r['prompt']);torch.cuda.synchronize();encode_seconds=time.perf_counter()-t
            if r['negative_prompt'] not in pipe._native_text_cache:pipe._native_text_cache[r['negative_prompt']]=encode_text(pipe,r['negative_prompt'])
            torch.cuda.synchronize();t=time.perf_counter()
            im=generate_native_image(pipe,prompt_embeds=embeds,seed=r['seed'],steps=50,guidance=4.,
                negative_prompt=r['negative_prompt'],image=image,width=832,height=1248)[0]
            torch.cuda.synchronize();seconds=time.perf_counter()-t
            safety=None
            if in_scope(r):
                if scorer is None:
                    from laion_image_scorer import Scorer
                    scorer=Scorer('cuda:0')
                im,actual,safety,extra=screen_frame(pipe,r,r,im,image,scorer)
                r.update({k:actual[k] for k in ['seed','negative_prompt']});seconds+=extra
                persist_actual_plan(STATE,'image-plan.json','id',r)
                c.execute('UPDATE jobs SET record=? WHERE id=?',(json.dumps(r,ensure_ascii=False,sort_keys=True),r['id']));c.commit()
            b=io.BytesIO();im.save(b,format='PNG',compress_level=4);png=b.getvalue()
            profile='shared-GPU-CPU-offload-job-pilot' if shared else 'dedicated-GPU-reference-job-outfits'
            m=metadata(r,dict(id=r['id'],seed=r['seed']),png,ref_sha,seconds,encode_seconds,name,profile);m.update(provenance)
            if safety is not None:
                safety['image_sha256']=m['image_sha256'];m['safety_check']=safety
            m['runtime']['includes_compile_warmup']=not warm;warm=True
            m['runtime']['gpu_shared_with_backgrounds']=False;m['runtime']['gpu_shared_with_character_production']=shared
            engine.add_member(tar,r['id']+'.png',png);engine.add_member(tar,r['id']+'.json',json.dumps(m,ensure_ascii=False,indent=2).encode());engine.add_member(tar,r['id']+'.txt',r['prompt'].encode())
            records.append((r['id'],seconds,json.dumps(m,ensure_ascii=False)));completed+=1
            engine.event(c,gpu,'image',json.dumps(dict(id=r['id'],seconds=seconds)));print(json.dumps(dict(id=r['id'],seconds=round(seconds,2),gpu=gpu)),flush=True)
        if tar:
            tar.close();final=BUFFER/name;partial.replace(final)
            c.execute('BEGIN IMMEDIATE');c.execute('INSERT INTO shards VALUES(?,?,?,?,?,?,?,?,?)',(name,gpu,len(records),final.stat().st_size,engine.sha(final),'ready',None,engine.utc(),None))
            for ident,seconds,m in records:c.execute("UPDATE jobs SET status='done',shard=?,generation_seconds=?,metadata=?,finished=? WHERE id=?",(name,seconds,m,engine.utc(),ident))
            c.commit();sequence+=1;first=False
        if not records:break
    if scorer is not None:scorer.close()
    engine.event(c,gpu,'pilot_complete' if limit is not None else 'complete')

if __name__=='__main__':
    p=argparse.ArgumentParser();p.add_argument('command',choices=['init','worker','status','upload']);p.add_argument('--gpu',type=int);p.add_argument('--shared',action='store_true');p.add_argument('--limit',type=int);a=p.parse_args()
    if a.command=='init':init()
    elif a.command=='worker':worker(a.gpu,a.shared,a.limit)
    elif a.command=='upload':engine.upload()
    else:print(json.dumps(status(),indent=2))