"""Recipe-driven character art production: same rig -> three clips -> visual prefab -> QA.

Default is local cached production. --generate explicitly requests DGXA inference.
Unity-managed assets are imported/authored only through Unity Pipeline.
"""
from __future__ import annotations
import argparse
import hashlib
import json
import os
from pathlib import Path
import re
import shutil
import subprocess
import sys
import time

REPO=Path(__file__).resolve().parents[1]
PROJECT=REPO/'AIClient'

def sha(path):
    return hashlib.sha256(Path(path).read_bytes()).hexdigest()

def resolve(path):
    result=(REPO/path).resolve()
    if not result.is_relative_to(REPO):
        raise ValueError(f'Path leaves repository: {path}')
    return result

def recipe(path):
    r=json.loads(path.read_text(encoding='utf-8-sig'))
    if r.get('schemaVersion')!=1 or not re.fullmatch(r'[A-Za-z][A-Za-z0-9_]*',r['id']):
        raise ValueError('Unsupported schema / invalid actor id')
    if r['profile'] not in ('biped_short','avian_grounded','quadruped_turtle','quadruped_heavy'):
        raise ValueError('Unsupported anatomy. Add and validate a different anatomy adapter before using it.')
    r.setdefault('usage','enemy_visual')
    if r['usage'] not in ('enemy_visual','companion_visual'):
        raise ValueError('Unsupported character usage')
    r.setdefault('visualPrefab',r.get('enemyPrefab',''))
    r.setdefault('attackStyle','body_slam')
    if r['attackStyle'] not in ('body_slam','ranged_cast','wing_cast','turtle_bubble','braced_bash','flame_roar'):
        raise ValueError('Unsupported attack style')
    if (r['profile']=='avian_grounded') != (r['attackStyle']=='wing_cast'):
        raise ValueError('Grounded birds require wing_cast; wing_cast requires avian_grounded')
    if (r['profile']=='quadruped_turtle') != (r['attackStyle']=='turtle_bubble'):
        raise ValueError('Turtles require their own four-legged bubble adapter')
    if (r['profile']=='quadruped_heavy') != (r['attackStyle']=='braced_bash'):
        raise ValueError('Heavy quadrupeds require their own braced bash adapter')
    r.setdefault('attackEvent','OnCompanionAttackImpact' if r['usage']=='companion_visual' else 'OnEnemyAttackImpact')
    if not re.fullmatch(r'[A-Za-z][A-Za-z0-9_]*',r['attackEvent']):
        raise ValueError('Invalid attack event')
    if r.get('boneMappingReady') is False:
        raise ValueError('Inspect this character\'s generated rig and complete its bone mapping before production')
    if r['attackStyle']=='flame_roar':
        required=('rootBone','chestBone','neckBone','headBone','rightArm','leftArm','rightPawTip','leftPawTip',
                  'rightFoot','leftFoot','rightFootTip','leftFootTip','faceRight','faceLeft')
        if r['profile']!='biped_short' or any(not re.fullmatch(r'bone_\d+',r.get(k,'')) for k in required):
            raise ValueError('Flame roar requires this biped\'s own head, neck, two arms/paws and feet')
        for right,left in (('rightArm','leftArm'),('rightPawTip','leftPawTip'),('rightFoot','leftFoot'),('rightFootTip','leftFootTip'),('faceRight','faceLeft'),('headBone','chestBone')):
            if r[right]==r[left]:raise ValueError('Flame roar requires independent head/body and left/right mappings')
        lo,hi=r.get('maneRegionMin',[]),r.get('maneRegionMax',[])
        if len(lo)!=3 or len(hi)!=3 or any(a>=b for a,b in zip(lo,hi)) or not 0<r.get('maneRigidityTolerance',0)<=.002:
            raise ValueError('Inspect the mane geometry region and rigidity budget')
        if not (0<r.get('attackHeadReach',0)<r['height']*.1 and 0<r.get('attackHeadPitchDegrees',0)<=15 and 0<r.get('attackSpreadDegrees',0)<=45):
            raise ValueError('Invalid flame roar head reach, pitch or paw spread')
    if r['profile'] in ('quadruped_turtle','quadruped_heavy'):
        feet=('frontRightFoot','frontLeftFoot','hindRightFoot','hindLeftFoot')
        tips=tuple(k+'Tip' for k in feet)
        body='shellBone' if r['profile']=='quadruped_turtle' else 'chestBone'
        if any(not re.fullmatch(r'bone_\d+',r.get(k,'')) for k in ('rootBone',body,'neckBone','headBone','faceRight','faceLeft',*feet,*tips)):
            raise ValueError('Map this quadruped\'s own body, head/neck and four paws')
        if len({r[k] for k in feet})!=4 or len({r[k] for k in tips})!=4 or r['faceRight']==r['faceLeft']:
            raise ValueError('Four separate paw mappings and distinct facing references required')
        if r.get('rootTiltReference')!='bind_up' or not 0<r.get('walkSwingFraction',0)<=.25:
            raise ValueError('Quadrupeds require bind-up orientation and a four-beat support gait')
        if not 0<r.get('attackHeadReach',0)<r['height']*.15:
            raise ValueError('Invalid quadruped head reach')
        regions=('shell',) if r['profile']=='quadruped_turtle' else ('armor','horn')
        for region in regions:
            lo,hi=r.get(region+'RegionMin',[]),r.get(region+'RegionMax',[])
            if len(lo)!=3 or len(hi)!=3 or any(a>=b for a,b in zip(lo,hi)) or not 0<r.get(region+'RigidityTolerance',0)<=.002:
                raise ValueError('Inspected '+region+' geometry region and rigidity budget required')
        if r['profile']=='quadruped_heavy' and (r['chestBone']==r['headBone'] or not 0<r.get('attackLunge',0)<r['height']*.12 or not 0<r.get('attackHeadPitchDegrees',0)<=20):
            raise ValueError('Heavy bash requires independent head/chest, a short shoulder lunge and controlled head pitch')
    if r['profile']=='avian_grounded':
        required=('rootBone','chestBone','rightArm','leftArm','rightWingTip','leftWingTip',
                  'rightFoot','leftFoot','rightFootTip','leftFootTip','faceRight','faceLeft')
        if any(not re.fullmatch(r'bone_\d+',r.get(k,'')) for k in required):
            raise ValueError('Inspect and map this bird\'s own wings, wing tips and feet')
        for right,left in (('rightArm','leftArm'),('rightWingTip','leftWingTip'),
                           ('rightFoot','leftFoot'),('rightFootTip','leftFootTip'),('faceRight','faceLeft')):
            if r[right]==r[left]:raise ValueError('Bird left/right mappings must be distinct')
        if not 0<r.get('wingSpreadDegrees',0)<=60:
            raise ValueError('Bird wingSpreadDegrees must be in (0,60]')
    if r['assetRoot']!=f"Assets/Bundles/Characters/{r['kind']}/{r['id']}":
        raise ValueError('assetRoot must match kind/id')
    for key in ('assetRoot','visualPrefab','staticPrefab','reviewScene'):
        if not r[key].startswith('Assets/Bundles/') or '..' in Path(r[key]).parts:
            raise ValueError(f'Invalid Unity asset path: {key}')
    for key in ('approvedMesh','rigSource','outputDir'):
        resolve(r[key])
    if not (.05<r['height']<20 and 0<r['walkStride']<r['height'] and 0<r['walkLift']<r['height']*.2):
        raise ValueError('Invalid dimensions/stride')
    if not 0<r['attackWindup']<r['attackImpact']<r['attackRecover']<1:
        raise ValueError('Invalid attack phase order')
    if not 0<=r.get('attackReach',0)<r['height']*.25:
        raise ValueError('Invalid attack reach')
    if not 0<r.get('walkSourceWeight',1)<=1:
        raise ValueError('Invalid Walk source weight')
    if {m['name'] for m in r['motions']}!={'Idle','Walk','Attack'} or len(r['motions'])!=3:
        raise ValueError('Exactly Idle, Walk and Attack required')
    for m in r['motions']:
        resolve(m['sourceDir'])
        if not m['prompt'].isascii() or ('jump' in m['prompt'].lower() and m['name']=='Walk'):
            raise ValueError('Use explicit English action captions; do not mix walk and jump')
    return r

def unity(command,**kwargs):
    args=['unity','--json','command','--project-path',str(PROJECT)]
    if command=='run_script':
        # Import/refresh and ephemeral compilation can delay dispatch in a live
        # Editor. Bound both server dispatch and CLI response, without retrying
        # a mutation whose outcome is unknown.
        # AIGAME_RUN_SCRIPT_TIMEOUT_MS raises the window for heavy QA (31-bone quadruped skin sampling took >90s).
        server_ms=int(os.environ.get('AIGAME_RUN_SCRIPT_TIMEOUT_MS','90000'))
        args.extend(['--timeout',str(server_ms//1000+30)])
        kwargs.setdefault('timeout_ms',server_ms)
    args.append(command)
    for k,v in kwargs.items():
        args.extend(['--'+k, json.dumps(v,ensure_ascii=False) if isinstance(v,(list,dict,bool)) else str(v)])
    proc=subprocess.run(args,cwd=REPO,capture_output=True,text=True,encoding='utf-8',errors='replace',timeout=int(os.environ.get('AIGAME_RUN_SCRIPT_TIMEOUT_MS','90000'))//1000+90)
    if proc.returncode:
        raise RuntimeError(proc.stderr or proc.stdout)
    data=json.loads(proc.stdout)
    result=data.get('data',{}).get('result')
    if not data.get('success') or isinstance(result,dict) and result.get('success') is False:
        raise RuntimeError(json.dumps(data,ensure_ascii=False))
    return result

def script(file,entry,args):
    result=unity('run_script',file='AgentScripts/'+file+'.cs',entry=entry,args=args)
    print(result.get('result',result),flush=True)
    return result

def wait_editor(play_mode):
    deadline=time.monotonic()+60
    while time.monotonic()<deadline:
        try:
            state=unity('editor_status')
            if state['playMode']==play_mode and not state['compiling'] and not state.get('domainReloadInProgress'):
                return
        except RuntimeError:
            pass  # Pipeline reconnects during the expected domain reload.
        time.sleep(.25)
    raise TimeoutError('Editor did not reach '+play_mode)

def cached_sources(r):
    rig_hash=sha(resolve(r['rigSource']))
    receipts={}
    for m in r['motions']:
        folder=resolve(m['sourceDir']);receipt=folder/'motion_request.json'
        if not receipt.is_file() and (folder/'walk_request.json').is_file():
            receipt=folder/'walk_request.json'
        if not (folder/'animated.fbx').is_file() and m.get('cachedFbx'):
            # Only accept a cache whose accompanying source rig is byte-identical.
            if sha(resolve(m['cachedRig']))!=rig_hash:
                raise ValueError('Cached action was generated from another rig: '+m['name'])
            folder.mkdir(parents=True,exist_ok=True)
            shutil.copy2(resolve(m['cachedFbx']),folder/'animated.fbx')
            receipt=folder/'motion_request.json'
            receipt.write_text(json.dumps(dict(rig_sha256=rig_hash,motion=m['name'],
                prompt=m['cachedPrompt'],cache_original=m['cachedFbx'],cache_rig=m['cachedRig'],
                note='Existing same-rig generated seed. Offline authoring defines final action semantics.'),indent=2),encoding='utf-8')
        if not receipt.is_file() or not (folder/'animated.fbx').is_file():
            raise FileNotFoundError('Missing source motion/provenance: '+m['name'])
        record=json.loads(receipt.read_text(encoding='utf-8-sig'))
        if record['rig_sha256'].lower()!=rig_hash:
            raise ValueError('Motion rig hash mismatch: '+m['name'])
        if record.get('source_fbx_sha256') and record['source_fbx_sha256']!=sha(folder/'animated.fbx'):
            raise ValueError('Motion source FBX hash mismatch: '+m['name'])
        receipts[m['name']]=dict(source=str(folder/'animated.fbx'),sha256=sha(folder/'animated.fbx'),request=record)
    return receipts

def main():
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--recipe',type=Path,required=True)
    parser.add_argument('--generate',nargs='+',choices=('Idle','Walk','Attack'))
    parser.add_argument('--generation-device',choices=('cuda','cpu'),default='cuda')
    parser.add_argument('--build-review',action='store_true')
    parser.add_argument('--play-check',action='store_true',help='With --build-review, verify all states in actual Play Mode and return to Edit Mode')
    parser.add_argument('--validate-recipe',action='store_true')
    args=parser.parse_args()
    recipe_path=args.recipe.resolve();r=recipe(recipe_path)
    if args.validate_recipe:
        print('PASS recipe',r['id']);return
    if args.play_check and not args.build_review:
        parser.error('--play-check requires --build-review')
    unity('set_autotick',enable=True)
    status=unity('editor_status')
    if status['playMode']!='stopped':raise RuntimeError('Use Edit Mode')
    if args.generate:
        subprocess.run([sys.executable,str(REPO/'Tools/generate_enemy_motions.py'),'--recipe',str(recipe_path),'--device',args.generation_device,'--motions',*args.generate],cwd=REPO,check=True)
    sources=cached_sources(r)
    output=resolve(r['outputDir']);output.mkdir(parents=True,exist_ok=True)
    (output/'production_manifest.json').write_text(json.dumps(dict(schemaVersion=1,status='building',id=r['id'])),encoding='utf-8')
    blender=os.environ.get('BLENDER_EXE',r'D:\Tools\Blender\blender-5.0.0-windows-x64\blender.exe')
    rigged=output/(r['id']+'_Rigged.fbx')
    subprocess.run([blender,'-b','--factory-startup','--python',str(REPO/'Tools/model_tools/bl_transfer_skin.py'),'--',
        str(resolve(r['rigSource'])),str(resolve(r['approvedMesh'])),str(rigged),'--low-up',r['lowUp'],'--align-bounds',
        '--weight-overrides',str(recipe_path)],cwd=REPO,check=True)
    unity('import_asset',source=str(rigged),path=r['assetRoot']+'/Rigged/'+r['id']+'_Rigged.fbx',confirm=True)
    for name,record in sources.items():
        unity('import_asset',source=record['source'],path=r['assetRoot']+'/Anims/'+r['id']+'_'+name+'.fbx',confirm=True)
    script('SetupAnimalAnimator','SetupAnimalAnimator.Run',[r['kind'],r['id'],r['height'],False])
    relative=recipe_path.relative_to(REPO).as_posix()
    if r['profile'] in ('quadruped_turtle','quadruped_heavy'):
        script('FinalizeAnimalWalk','FinalizeAnimalWalk.RunQuadruped',[relative])
    else:
        script('FinalizeAnimalWalk','FinalizeAnimalWalk.RunFor',[r['assetRoot'],r['id'],r['height'],r['rootBone'],r['rightFoot'],r['leftFoot'],r['walkStride'],r['walkLift'],r['walkSeconds'],r['outputDir'],r.get('walkBindCalibration',False),r.get('walkSourceWeight',1)])
    script('FinalizeEnemyMotions','FinalizeEnemyMotions.Run',[relative])
    verifier='VerifyQuadrupedMotions' if r['profile'] in ('quadruped_turtle','quadruped_heavy') else 'VerifyEnemyMotions'
    script(verifier,verifier+'.Run',[relative])
    script('BuildEnemyReview','BuildEnemyReview.Publish',[relative])
    if args.build_review:
        script('BuildEnemyReview','BuildEnemyReview.Build',[relative])
        script('BuildEnemyReview','BuildEnemyReview.Capture',[relative])
    live_result=None
    if args.play_check:
        unity('editor_play')
        try:
            wait_editor('playing')
            live_result=script(verifier,verifier+'.Live',[relative])['result']
            prefix='CompanionReview_'+r['id'] if r['usage']=='companion_visual' else 'EnemyReview'
            role='companion' if r['usage']=='companion_visual' else 'enemy'
            unity('capture_game_view',camera=prefix+'Camera',width=1900,height=760,
                  save_path='Assets/Screenshots/'+role+'_'+r['id'].lower()+'_play.png')
        finally:
            unity('editor_stop')
            wait_editor('stopped')
        (output/'play_verification.txt').write_text(live_result,encoding='utf-8')
    manifest=dict(schemaVersion=1,status='validated' if live_result else 'edit_validated',id=r['id'],usage=r['usage'],recipe=relative,
        approved_mesh_sha256=sha(resolve(r['approvedMesh'])),rig_sha256=sha(resolve(r['rigSource'])),
        sources=sources,rigged_fbx=str(rigged),visual_prefab=r['visualPrefab'],
        motions=['Idle','Walk','Attack'],controller=dict(Motion='0=Idle,1=Walk',Attack='Trigger, one shot'),
        attack_impact_seconds=r['attackSeconds']*r['attackImpact'],
        qa=dict(edit='passed',play=live_result or 'not_run'),
        report=str(output/'verification.txt'),generated_at_utc=time.strftime('%Y-%m-%dT%H:%M:%SZ',time.gmtime()))
    if r['usage']=='enemy_visual':manifest['enemy_prefab']=r['visualPrefab']
    (output/'production_manifest.json').write_text(json.dumps(manifest,ensure_ascii=False,indent=2),encoding='utf-8')
    print('PASS character production',r['visualPrefab'],flush=True)

if __name__=='__main__':
    main()