"""Render-only camera persistence fix and actual camera/light telemetry."""
from pathlib import Path
import json, os

_context={'frame':None,'chunk':-1}
_logged=set()

def setup(env):
    from isaaclab.utils.math import convert_camera_frame_orientation_convention
    path=Path(os.environ['PILOT_CAMERA_LOG'])
    episodes=json.loads(os.environ['PILOT_RENDER_EPISODES'])
    gen=Path(os.environ.get('PILOT_GEN_ROOT',str(Path(__file__).parent/'data_gen/pilot')))
    episodes.sort(key=lambda e:(json.loads((gen/e/'meta.json').read_text())['steps'],str(gen/e)))
    lengths=[json.loads((gen/e/'meta.json').read_text())['steps'] for e in episodes]
    stream=path.open('x',buffering=1)
    origins=env.iscene.env_origins.detach().cpu().tolist()
    from pxr import UsdLux
    light = UsdLux.LightAPI(env.sim.stage.GetPrimAtPath('/World/light'))
    path.with_suffix('.grid.json').write_text(json.dumps({'num_envs':env.num_envs,'origins':origins,
        'actual_light_intensity':float(light.GetIntensityAttr().Get()),
        'pilot_parts_box_prim_present':[bool(env.sim.stage.GetPrimAtPath(f'/World/envs/env_{i}/PilotPartsBox').IsValid()) for i in range(env.num_envs)],
        'episodes_in_render_order':episodes,'pose_source':'Isaac camera XformPrimView after forced update',
        'world_quaternion':'wxyz, +X forward +Z up','ros_quaternion':'wxyz, +Z forward -Y up'},indent=2))
    for name,cam in env.iscene.sensors.items():
        if not hasattr(cam.cfg,'data_types') or 'rgb' not in cam.cfg.data_types:continue
        # TiledCamera otherwise returns INITIALIZATION poses even as pixels move.
        cam.cfg.update_latest_camera_pose=True
        if '/front' in cam.cfg.prim_path:
            original_set=cam.set_world_poses
            def persistent_set(positions=None,orientations=None,env_ids=None,convention='ros',
                               _original=original_set,_cam=cam):
                _original(positions,orientations,env_ids,convention)
                # In this installed Fabric backend, the next sim tick overwrites
                # a world-only camera edit from its nominal USD local transform.
                # External cameras are direct children of untranslated/identity
                # env frames except for the audited env-origin translation.
                ids=slice(None) if env_ids is None else env_ids
                local=positions-env.iscene.env_origins[ids] if positions is not None else None
                gl=convert_camera_frame_orientation_convention(orientations,origin=convention,target='opengl') if orientations is not None else None
                _cam._view.set_local_poses(local,gl,env_ids)
                _cam._pilot_expected_position=positions.detach().clone()
                if convention=='world':_cam._pilot_expected_quat_world=orientations.detach().clone()
            cam.set_world_poses=persistent_set
        original=cam.update
        def update(*a,_original=original,_cam=cam,_name=name,**kw):
            result=_original(*a,**kw)
            if kw.get('force_recompute') and _context['frame'] is not None:
                d=_cam.data
                for slot in range(env.num_envs):
                    j=_context['chunk']*env.num_envs+slot
                    if j>=len(episodes) or _context['frame']>=lengths[j]:continue
                    key=(j,_context['frame'],_name)
                    if key in _logged:continue
                    row={'episode':episodes[j],'env_slot':slot,'env_origin':origins[slot],
                         'frame_index':_context['frame'],'camera':_name,
                         'pos_w':d.pos_w[slot].detach().cpu().tolist(),
                         'quat_w_world':d.quat_w_world[slot].detach().cpu().tolist(),
                         'quat_w_ros':d.quat_w_ros[slot].detach().cpu().tolist(),
                         'intrinsic_matrix':d.intrinsic_matrices[slot].detach().cpu().tolist(),
                         'size':[_cam.cfg.width,_cam.cfg.height],
                         'clipping_range':list(_cam.cfg.spawn.clipping_range)}
                    if hasattr(_cam,'_pilot_expected_position'):
                        error=float((d.pos_w[slot]-_cam._pilot_expected_position[slot]).norm())
                        if error>.0001:raise RuntimeError(f'Camera pose did not persist: {_name} {error}')
                        row['requested_pose_error_m']=error
                    if hasattr(_cam,'_pilot_expected_quat_world'):
                        qerror=1-abs(float((d.quat_w_world[slot]*_cam._pilot_expected_quat_world[slot]).sum()))
                        if qerror>.0001:raise RuntimeError(f'Camera rotation did not persist: {_name} {qerror}')
                        row['requested_rotation_dot_error']=qerror
                    stream.write(json.dumps(row)+'\n');_logged.add(key)
            return result
        cam.update=update

def per_frame(env,t):
    if t==0:_context['chunk']+=1
    _context['frame']=int(t)