# -------------------------------------------------------------------
# DragMesh1 VAE inference on "Microwave" (manual joint override mode)
# Run on server: zhanghao@101.69.182.118:44, conda env: dragmesh_env
# -------------------------------------------------------------------
import os
os.environ["PYOPENGL_PLATFORM"] = "egl"

import sys
import json
import numpy as np
import torch
import trimesh

sys.path.insert(0, '/home/zhanghao/scene/DragMesh')

from dragmesh.inference.inference_pipeline import (
    sample_point_cloud, run_kpp_inference, load_kpp_model, load_vae_model,
)
from dragmesh.inference.inference_animation import run_animation_from_sample

DATA_DIR = '/home/zhanghao/scene/DragMesh/test_data/furniture/Microwave'
OUTPUT_ROOT = os.path.join(DATA_DIR, 'output')
CKPT_DIR = '/home/zhanghao/scene/DragMesh/checkpoints'

device = torch.device('cuda')
print(f'Using device: {device} | torch={torch.__version__} | cuda_available={torch.cuda.is_available()}')

# 1. Load mesh
mesh = trimesh.load(os.path.join(DATA_DIR, 'mesh.obj'), process=False)
if isinstance(mesh, trimesh.Scene):
    if len(mesh.geometry) == 0:
        raise RuntimeError('Empty scene geometry')
    mesh = trimesh.util.concatenate(tuple(mesh.geometry.values()))
print(f'Loaded mesh: {len(mesh.vertices)} verts, {len(mesh.faces)} faces')

# 2. Load labels
labels = np.load(os.path.join(DATA_DIR, 'labels.npy')).reshape(-1).astype(int)
print(f'Labels: shape={labels.shape}, unique={np.unique(labels).tolist()}, moving(label=1)={int((labels == 1).sum())}')

# 3. Part mask for the moving part (label == 1)
mask_bool = (labels == 1).astype(np.float32)
print(f'Part mask: {int(mask_bool.sum())} moving vertices')

# 4. Load KPP and VAE checkpoints
kpp_model = load_kpp_model(os.path.join(CKPT_DIR, 'kpp.pth'), device)
vae_model, num_frames = load_vae_model(os.path.join(CKPT_DIR, 'dqvae.pth'), device, None)
print(f'Loaded KPP + VAE checkpoints, num_frames={num_frames}')

# Read joint.json (manual annotation)
with open(os.path.join(DATA_DIR, 'joint.json')) as f:
    jj = json.load(f)
joint_type_manual = jj['type']
drag_point = np.array(jj['drag_point'], dtype=np.float32)
drag_vector = np.array(jj['drag_vector'], dtype=np.float32)
axis_manual = np.array(jj['axis'], dtype=np.float32)
origin_manual = np.array(jj['origin'], dtype=np.float32)
print(f'Manual joint: type={joint_type_manual}, axis={axis_manual.tolist()}, origin={origin_manual.tolist()}, '
      f'drag_point={drag_point.tolist()}, drag_vector={drag_vector.tolist()}')

# 5. Run sample_point_cloud + run_kpp_inference
pc, face_indices, center, scale = sample_point_cloud(mesh, 4096)
sampled_mask = np.zeros(len(face_indices), dtype=np.float32)
for i, fid in enumerate(face_indices):
    face_vertices = mesh.faces[fid]
    sampled_mask[i] = 1.0 if mask_bool[face_vertices].mean() > 0.5 else 0.0
print(f'Sampled point cloud: {pc.shape}, moving ratio in sampled mask: {sampled_mask.mean():.3f}')

drag_point_norm = (drag_point - center) / scale
drag_vector_norm = drag_vector / scale

pred_type_logits, pred_axis, pred_origin = run_kpp_inference(
    kpp_model, pc, sampled_mask, drag_point_norm, drag_vector_norm, device
)

kpp_joint_type = int(torch.argmax(pred_type_logits, dim=-1).item())
kpp_type_probs = torch.softmax(pred_type_logits, dim=-1).squeeze(0).detach().cpu().numpy().tolist()
kpp_axis = pred_axis.squeeze(0).cpu().numpy()
kpp_axis = kpp_axis / (np.linalg.norm(kpp_axis) + 1e-8)
kpp_origin_norm = pred_origin.squeeze(0).cpu().numpy()
kpp_origin = kpp_origin_norm * scale + center
print(f'KPP: type={"revolute" if kpp_joint_type == 0 else "prismatic"} (probs={kpp_type_probs}), '
      f'axis={kpp_axis.tolist()}, origin={kpp_origin.tolist()}')

# 6. Final joint type: USE THE MANUAL TYPE from joint.json
final_joint_type = joint_type_manual

# 7. Axis: use KPP axis if dot product with manual axis > 0.7, else manual axis
dot = float(np.dot(kpp_axis, axis_manual))
use_kpp_axis = abs(dot) > 0.7  # sign-robust agreement check
if use_kpp_axis:
    joint_axis = kpp_axis * (1.0 if dot > 0.0 else -1.0)  # align sign with manual axis
else:
    joint_axis = axis_manual
print(f'Axis decision: dot={dot:.4f}, use_kpp_axis={use_kpp_axis}, final axis={joint_axis.tolist()}')

# Origin: KPP predicted origin when KPP axis was trusted, else manual origin
joint_origin = kpp_origin if use_kpp_axis else origin_manual
print(f'Origin decision: final origin={joint_origin.tolist()}')

# 8. Build sample_dict
sample_dict = {
    'initial_mesh': mesh,
    'part_mask': mask_bool,
    'drag_point': drag_point,
    'drag_vector': drag_vector,
    'joint_type': final_joint_type,
    'joint_axis': joint_axis,
    'joint_origin': joint_origin,
    'rotation_direction': None,
    'trajectory_vectors': None,
    'drag_trajectory': None,
}

# 9. Run run_animation_from_sample
os.makedirs(OUTPUT_ROOT, exist_ok=True)
run_animation_from_sample(
    model=vae_model,
    sample=sample_dict,
    sample_name='Microwave',
    device=device,
    output_root=OUTPUT_ROOT,
    num_frames=num_frames,
    num_samples_to_gen=3,
    force_rotation=False,
    include_groundtruth=False,
    fps=5.0,
    loop_mode='pingpong'
)

# 10. Write audit JSON
audit = {
    'name': jj.get('name', 'Microwave'),
    'joint_type_manual': joint_type_manual,
    'kpp_joint_type': 'revolute' if kpp_joint_type == 0 else 'prismatic',
    'kpp_type_probs': kpp_type_probs,
    'final_joint_type': final_joint_type,
    'axis_manual': axis_manual.tolist(),
    'kpp_axis': kpp_axis.tolist(),
    'axis_dot_product': dot,
    'use_kpp_axis': bool(use_kpp_axis),
    'joint_axis_used': joint_axis.tolist(),
    'origin_manual': origin_manual.tolist(),
    'kpp_origin': kpp_origin.tolist(),
    'joint_origin_used': joint_origin.tolist(),
    'drag_point': drag_point.tolist(),
    'drag_vector': drag_vector.tolist(),
    'num_frames': num_frames,
}
with open(os.path.join(OUTPUT_ROOT, 'inference_audit.json'), 'w') as f:
    json.dump(audit, f, indent=2)
print(json.dumps(audit, indent=2))
print('DONE')