import spaces
import subprocess
# Install flash attention, skipping CUDA build if necessary
subprocess.run(
    "pip install flash-attn --no-build-isolation",
    env={"FLASH_ATTENTION_SKIP_CUDA_BUILD": "TRUE"},
    shell=True,
)

import os
import time

import imageio
import numpy as np
import torch
import rembg
from PIL import Image
from torchvision.transforms import v2
from pytorch_lightning import seed_everything
from omegaconf import OmegaConf
from einops import rearrange, repeat
from tqdm import tqdm
from diffusers import DiffusionPipeline, EulerAncestralDiscreteScheduler

# Imports for InstantMesh
import shutil
from src.utils.train_util import instantiate_from_config
from src.utils.camera_util import (
    FOV_to_intrinsics,
    get_zero123plus_input_cameras,
    get_circular_camera_poses,
)
from src.utils.mesh_util import save_obj, save_glb
from src.utils.infer_util import remove_background, resize_foreground, images_to_video

import tempfile
from functools import partial

from huggingface_hub import hf_hub_download

import gradio as gr

# Imports for MeshAnythingv2
from accelerate.utils import set_seed
from accelerate import Accelerator
from main import load_v2
from mesh_to_pc import process_mesh_to_pc
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d.art3d import Poly3DCollection

###############################################################################
# Configuration for InstantMesh
###############################################################################
def get_render_cameras(
    batch_size=1, M=120, radius=2.5, elevation=10.0, is_flexicubes=False
):
    """
    Get the rendering camera parameters.
    """
    c2ws = get_circular_camera_poses(M=M, radius=radius, elevation=elevation)
    if is_flexicubes:
        cameras = torch.linalg.inv(c2ws)
        cameras = cameras.unsqueeze(0).repeat(batch_size, 1, 1, 1)
    else:
        extrinsics = c2ws.flatten(-2)
        intrinsics = (
            FOV_to_intrinsics(50.0).unsqueeze(0).repeat(M, 1, 1).float().flatten(-2)
        )
        cameras = torch.cat([extrinsics, intrinsics], dim=-1)
        cameras = cameras.unsqueeze(0).repeat(batch_size, 1, 1)
    return cameras


def images_to_video(images, output_path, fps=30):
    # images: (N, C, H, W)
    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    frames = []
    for i in range(images.shape[0]):
        frame = (
            (images[i].permute(1, 2, 0).cpu().numpy() * 255)
            .astype(np.uint8)
            .clip(0, 255)
        )
        assert (
            frame.shape[0] == images.shape[2] and frame.shape[1] == images.shape[3]
        ), f"Frame shape mismatch: {frame.shape} vs {images.shape}"
        assert (
            frame.min() >= 0 and frame.max() <= 255
        ), f"Frame value out of range: {frame.min()} ~ {frame.max()}"
        frames.append(frame)
    imageio.mimwrite(output_path, np.stack(frames), fps=fps, codec="h264")


def find_cuda():
    # Check if CUDA_HOME or CUDA_PATH environment variables are set
    cuda_home = os.environ.get("CUDA_HOME") or os.environ.get("CUDA_PATH")

    if cuda_home and os.path.exists(cuda_home):
        return cuda_home

    # Search for the nvcc executable in the system's PATH
    nvcc_path = shutil.which("nvcc")

    if nvcc_path:
        # Remove the 'bin/nvcc' part to get the CUDA installation path
        cuda_path = os.path.dirname(os.path.dirname(nvcc_path))
        return cuda_path

    return None


cuda_path = find_cuda()

if cuda_path:
    print(f"CUDA installation found at: {cuda_path}")
else:
    print("CUDA installation not found")

config_path = "configs/instant-mesh-large.yaml"
config = OmegaConf.load(config_path)
config_name = os.path.basename(config_path).replace(".yaml", "")
model_config = config.model_config
infer_config = config.infer_config

IS_FLEXICUBES = True if config_name.startswith("instant-mesh") else False

device = torch.device("cuda")

# load diffusion model
print("Loading diffusion model ...")
pipeline = DiffusionPipeline.from_pretrained(
    "sudo-ai/zero123plus-v1.2",
    custom_pipeline="zero123plus",
    torch_dtype=torch.float16,
)
pipeline.scheduler = EulerAncestralDiscreteScheduler.from_config(
    pipeline.scheduler.config, timestep_spacing="trailing"
)

# load custom white-background UNet
unet_ckpt_path = hf_hub_download(
    repo_id="TencentARC/InstantMesh",
    filename="diffusion_pytorch_model.bin",
    repo_type="model",
)
state_dict = torch.load(unet_ckpt_path, map_location="cpu")
pipeline.unet.load_state_dict(state_dict, strict=True)

pipeline = pipeline.to(device)

# load reconstruction model
print("Loading reconstruction model ...")
model_ckpt_path = hf_hub_download(
    repo_id="TencentARC/InstantMesh",
    filename="instant_mesh_large.ckpt",
    repo_type="model",
)
model = instantiate_from_config(model_config)
state_dict = torch.load(model_ckpt_path, map_location="cpu")["state_dict"]
state_dict = {
    k[14:]: v
    for k, v in state_dict.items()
    if k.startswith("lrm_generator.") and "source_camera" not in k
}
model.load_state_dict(state_dict, strict=True)

model = model.to(device)

print("Loading Finished!")


def check_input_image(input_image):
    if input_image is None:
        raise gr.Error("No image uploaded!")


def preprocess(input_image, do_remove_background):

    rembg_session = rembg.new_session() if do_remove_background else None

    if do_remove_background:
        input_image = remove_background(input_image, rembg_session)
        input_image = resize_foreground(input_image, 0.85)

    return input_image


@spaces.GPU
def generate_mvs(input_image, sample_steps, sample_seed):

    seed_everything(sample_seed)

    # sampling
    z123_image = pipeline(input_image, num_inference_steps=sample_steps).images[0]

    show_image = np.asarray(z123_image, dtype=np.uint8)
    show_image = torch.from_numpy(show_image)  # (960, 640, 3)
    show_image = rearrange(show_image, "(n h) (m w) c -> (n m) h w c", n=3, m=2)
    show_image = rearrange(show_image, "(n m) h w c -> (n h) (m w) c", n=2, m=3)
    show_image = Image.fromarray(show_image.numpy())

    return z123_image, show_image


@spaces.GPU
def make3d(images):

    global model
    if IS_FLEXICUBES:
        model.init_flexicubes_geometry(device, use_renderer=False)
    model = model.eval()

    images = np.asarray(images, dtype=np.float32) / 255.0
    images = (
        torch.from_numpy(images).permute(2, 0, 1).contiguous().float()
    )  # (3, 960, 640)
    images = rearrange(
        images, "c (n h) (m w) -> (n m) c h w", n=3, m=2
    )  # (6, 3, 320, 320)

    input_cameras = get_zero123plus_input_cameras(batch_size=1, radius=4.0).to(device)
    render_cameras = get_render_cameras(
        batch_size=1, radius=2.5, is_flexicubes=IS_FLEXICUBES
    ).to(device)

    images = images.unsqueeze(0).to(device)
    images = v2.functional.resize(
        images, (320, 320), interpolation=3, antialias=True
    ).clamp(0, 1)

    mesh_fpath = tempfile.NamedTemporaryFile(suffix=f".obj", delete=False).name
    print(mesh_fpath)
    mesh_basename = os.path.basename(mesh_fpath).split(".")[0]
    mesh_dirname = os.path.dirname(mesh_fpath)
    video_fpath = os.path.join(mesh_dirname, f"{mesh_basename}.mp4")
    mesh_glb_fpath = os.path.join(mesh_dirname, f"{mesh_basename}.glb")

    with torch.no_grad():
        # get triplane
        planes = model.forward_planes(images, input_cameras)

        # get mesh
        mesh_out = model.extract_mesh(
            planes,
            use_texture_map=False,
            **infer_config,
        )

        vertices, faces, vertex_colors = mesh_out
        vertices = vertices[:, [1, 2, 0]]

        save_glb(vertices, faces, vertex_colors, mesh_glb_fpath)
        save_obj(vertices, faces, vertex_colors, mesh_fpath)

        print(f"Mesh saved to {mesh_fpath}")

    return mesh_fpath, mesh_glb_fpath


###############################################################################
# Configuration for MeshAnythingv2
###############################################################################
model = load_v2()
device = torch.device("cuda")
accelerator = Accelerator(
    mixed_precision="fp16",
)
model = accelerator.prepare(model)
model.eval()
print("Model loaded to device")


def wireframe_render(mesh):
    views = [(90, 20), (270, 20)]
    mesh.vertices = mesh.vertices[:, [0, 2, 1]]

    bounding_box = mesh.bounds
    center = mesh.centroid
    scale = np.ptp(bounding_box, axis=0).max()

    fig = plt.figure(figsize=(10, 10))

    # Function to render and return each view as an image
    def render_view(mesh, azimuth, elevation):
        ax = fig.add_subplot(111, projection="3d")
        ax.set_axis_off()

        # Extract vertices and faces for plotting
        vertices = mesh.vertices
        faces = mesh.faces

        # Plot faces
        ax.add_collection3d(
            Poly3DCollection(
                vertices[faces],
                facecolors=(0.8, 0.5, 0.2, 1.0),  # Brownish yellow
                edgecolors="k",
                linewidths=0.5,
            )
        )

        # Set limits and center the view on the object
        ax.set_xlim(center[0] - scale / 2, center[0] + scale / 2)
        ax.set_ylim(center[1] - scale / 2, center[1] + scale / 2)
        ax.set_zlim(center[2] - scale / 2, center[2] + scale / 2)

        # Set view angle
        ax.view_init(elev=elevation, azim=azimuth)

        # Save the figure to a buffer
        buf = io.BytesIO()
        plt.savefig(buf, format="png", bbox_inches="tight", pad_inches=0, dpi=300)
        plt.clf()
        buf.seek(0)

        return Image.open(buf)

    # Render each view and store in a list
    images = [render_view(mesh, az, el) for az, el in views]

    # Combine images horizontally
    widths, heights = zip(*(i.size for i in images))
    total_width = sum(widths)
    max_height = max(heights)

    combined_image = Image.new("RGBA", (total_width, max_height))

    x_offset = 0
    for img in images:
        combined_image.paste(img, (x_offset, 0))
        x_offset += img.width

    # Save the combined image
    save_path = f"combined_mesh_view_{int(time.time())}.png"
    combined_image.save(save_path)

    plt.close(fig)
    return save_path


@spaces.GPU(duration=360)
def do_inference(input_3d, sample_seed=0, do_sampling=False, do_marching_cubes=False):
    set_seed(sample_seed)
    print("Seed value:", sample_seed)

    input_mesh = trimesh.load(input_3d)
    pc_list, mesh_list = process_mesh_to_pc(
        [input_mesh], marching_cubes=do_marching_cubes
    )
    pc_normal = pc_list[0]  # 4096, 6
    mesh = mesh_list[0]
    vertices = mesh.vertices

    pc_coor = pc_normal[:, :3]
    normals = pc_normal[:, 3:]

    bounds = np.array([vertices.min(axis=0), vertices.max(axis=0)])
    # scale mesh and pc
    vertices = vertices - (bounds[0] + bounds[1])[None, :] / 2
    vertices = vertices / (bounds[1] - bounds[0]).max()
    mesh.vertices = vertices
    pc_coor = pc_coor - (bounds[0] + bounds[1])[None, :] / 2
    pc_coor = pc_coor / (bounds[1] - bounds[0]).max()

    mesh.merge_vertices()
    mesh.update_faces(mesh.nondegenerate_faces())
    mesh.update_faces(mesh.unique_faces())
    mesh.remove_unreferenced_vertices()
    mesh.fix_normals()
    try:
        if mesh.visual.vertex_colors is not None:
            orange_color = np.array([255, 165, 0, 255], dtype=np.uint8)

            mesh.visual.vertex_colors = np.tile(
                orange_color, (mesh.vertices.shape[0], 1)
            )
        else:
            orange_color = np.array([255, 165, 0, 255], dtype=np.uint8)
            mesh.visual.vertex_colors = np.tile(
                orange_color, (mesh.vertices.shape[0], 1)
            )
    except Exception as e:
        print(e)
    input_save_name = f"processed_input_{int(time.time())}.obj"
    mesh.export(input_save_name)
    input_render_res = wireframe_render(mesh)

    pc_coor = pc_coor / np.abs(pc_coor).max() * 0.99  # input should be from -1 to 1

    assert (
        np.linalg.norm(normals, axis=-1) > 0.99
    ).all(), "normals should be unit vectors, something wrong"
    normalized_pc_normal = np.concatenate([pc_coor, normals], axis=-1, dtype=np.float16)

    input = torch.tensor(normalized_pc_normal, dtype=torch.float16, device=device)[None]
    print("Data loaded")

    # with accelerator.autocast():
    with accelerator.autocast():
        outputs = model(input, do_sampling)
    print("Model inference done")
    recon_mesh = outputs[0]

    valid_mask = torch.all(~torch.isnan(recon_mesh.reshape((-1, 9))), dim=1)
    recon_mesh = recon_mesh[valid_mask]  # nvalid_face x 3 x 3
    vertices = recon_mesh.reshape(-1, 3).cpu()
    vertices_index = np.arange(len(vertices))  # 0, 1, ..., 3 x face
    triangles = vertices_index.reshape(-1, 3)

    artist_mesh = trimesh.Trimesh(
        vertices=vertices, faces=triangles, force="mesh", merge_primitives=True
    )

    artist_mesh.merge_vertices()
    artist_mesh.update_faces(artist_mesh.nondegenerate_faces())
    artist_mesh.update_faces(artist_mesh.unique_faces())
    artist_mesh.remove_unreferenced_vertices()
    artist_mesh.fix_normals()

    if artist_mesh.visual.vertex_colors is not None:
        orange_color = np.array([255, 165, 0, 255], dtype=np.uint8)

        artist_mesh.visual.vertex_colors = np.tile(
            orange_color, (artist_mesh.vertices.shape[0], 1)
        )
    else:
        orange_color = np.array([255, 165, 0, 255], dtype=np.uint8)
        artist_mesh.visual.vertex_colors = np.tile(
            orange_color, (artist_mesh.vertices.shape[0], 1)
        )

    num_faces = len(artist_mesh.faces)

    brown_color = np.array([165, 42, 42, 255], dtype=np.uint8)
    face_colors = np.tile(brown_color, (num_faces, 1))

    artist_mesh.visual.face_colors = face_colors
    # add time stamp to avoid cache
    save_name = f"output_{int(time.time())}.obj"
    artist_mesh.export(save_name)
    output_render = wireframe_render(artist_mesh)
    return input_save_name, input_render_res, save_name, output_render


# Output gradio
output_model_obj = gr.Model3D(
    label="Generated Mesh (OBJ Format)",
    display_mode="wireframe",
    clear_color=[1, 1, 1, 1],
)
preprocess_model_obj = gr.Model3D(
    label="Processed Input Mesh (OBJ Format)",
    display_mode="wireframe",
    clear_color=[1, 1, 1, 1],
)
input_image_render = gr.Image(
    label="Wireframe Render of Processed Input Mesh",
)
output_image_render = gr.Image(
    label="Wireframe Render of Generated Mesh",
)

###############################################################################
# Gradio
###############################################################################
HEADER = """
# Generate 3D Assets for Roblox
With this Space, you can generate 3D Assets using AI for your Roblox game for free.
Simply follow the 3 steps below.
1. Generate a 3D Mesh using an image model as input.
2. Simplify the Mesh to get lower polygon number.
3. Download the model and import it in Roblox.

We wrote a tutorial here
"""

STEP1_HEADER = """
## Step 1: Generate the 3D Mesh
For this step, we use <a href='https://github.com/TencentARC/InstantMesh' target='_blank'>InstantMesh</a>, an open-source model for **fast** feedforward 3D mesh generation from a single image.
During this step, you need to upload an image of what you want to generate a 3D Model from.
## 💡 Tips
-  If there's a background, ✅ Remove background.
- The 3D mesh generation results highly depend on the quality of generated multi-view images. Please try a different **seed value** if the result is unsatisfying (Default: 42).
"""

STEP2_HEADER = """
## Step 2: Simplify the generated 3D Mesh
ADD ILLUSTRATION
The 3D Mesh Generated contains too much polygons, fortunately, we can use another AI model to help us optimize it.
The model we use is called [MeshAnythingV2]().
## 💡 Tips
- We don't click on Preprocess with marching Cubes, because in the last step the input mesh was produced by it.
- Limited by computational resources, MeshAnything is trained on meshes with fewer than 1600 faces and cannot generate meshes with more than 1600 faces. The shape of the input mesh should be sharp enough; otherwise, it will be challenging to represent it with only 1600 faces. Thus, feed-forward image-to-3D methods may often produce bad results due to insufficient shape quality.
"""

STEP3_HEADER = """
## Step 3 (optional): Shader Smooth
- The mesh simplified in step 2, looks low poly. One way to make it more smooth is to use Shader Smooth.
- You can usually do it in Blender, but we can do it directly here
ADD ILLUSTRATION
ADD SHADERSMOOTH
"""

STEP4_HEADER = """
## Step 4: Get the Mesh Material
"""

with gr.Blocks() as demo:
    gr.Markdown(HEADER)
    gr.Markdown(STEP1_HEADER)
    with gr.Row(variant="panel"):
        with gr.Column():
            with gr.Row():
                input_image = gr.Image(
                    label="Input Image",
                    image_mode="RGBA",
                    sources="upload",
                    type="pil",
                    elem_id="content_image",
                )
                processed_image = gr.Image(
                    label="Processed Image",
                    image_mode="RGBA",
                    type="pil",
                    interactive=False,
                )
            with gr.Row():
                with gr.Group():
                    do_remove_background = gr.Checkbox(
                        label="Remove Background", value=True
                    )
                    sample_seed = gr.Number(value=42, label="Seed Value", precision=0)
                    sample_steps = gr.Slider(
                        label="Sample Steps", minimum=30, maximum=75, value=75, step=5
                    )
            with gr.Row():
                step1_submit = gr.Button(
                    "Generate", elem_id="generate", variant="primary"
                )
        with gr.Column():
            with gr.Row():
                with gr.Column():
                    mv_show_images = gr.Image(
                        label="Generated Multi-views",
                        type="pil",
                        width=379,
                        interactive=False,
                    )
        with gr.Column():
            with gr.Tab("OBJ"):
                output_model_obj = gr.Model3D(
                    label="Output Model (OBJ Format)",
                    interactive=False,
                )
                gr.Markdown(
                    "Note: Downloaded object will be flipped in case of .obj export. Export .glb instead or manually flip it before usage."
                )
            with gr.Tab("GLB"):
                output_model_glb = gr.Model3D(
                    label="Output Model (GLB Format)",
                    interactive=False,
                )
                gr.Markdown(
                    "Note: The model shown here has a darker appearance. Download to get correct results."
                )
                gr.Markdown(
                    """Try a different <b>seed value</b> if the result is unsatisfying (Default: 42)."""
                )

    gr.Markdown(STEP2_HEADER)
    with gr.Row(variant="panel"):
        with gr.Column():
            with gr.Row():
                input_3d = gr.Model3D(
                    label="Input Mesh",
                    display_mode="wireframe",
                    clear_color=[1, 1, 1, 1],
                )

        with gr.Row():
            with gr.Group():
                do_marching_cubes = gr.Checkbox(
                    label="Preprocess with Marching Cubes", value=False
                )
                do_sampling = gr.Checkbox(label="Random Sampling", value=False)
                sample_seed = gr.Number(value=0, label="Seed Value", precision=0)

            with gr.Row():
                step2_submit = gr.Button(
                    "Generate", elem_id="generate", variant="primary"
                )

            with gr.Row(variant="panel"):
                mesh_examples = gr.Examples(
                    examples=[
                        os.path.join("examples", img_name)
                        for img_name in sorted(os.listdir("examples"))
                    ],
                    inputs=input_3d,
                    outputs=[
                        preprocess_model_obj,
                        input_image_render,
                        output_model_obj,
                        output_image_render,
                    ],
                    fn=do_inference,
                    cache_examples=False,
                    examples_per_page=10,
                )

        with gr.Column():
            with gr.Row():
                input_image_render.render()
            with gr.Row():
                with gr.Tab("OBJ"):
                    preprocess_model_obj.render()
            with gr.Row():
                output_image_render.render()
            with gr.Row():
                with gr.Tab("OBJ"):
                    output_model_obj.render()
            with gr.Row():
                gr.Markdown(
                    """Try click random sampling and different <b>Seed Value</b> if the result is unsatisfying"""
                )

    gr.Markdown(STEP3_HEADER)
    gr.Markdown(STEP4_HEADER)

    mv_images = gr.State()

    step1_submit.click(fn=check_input_image, inputs=[input_image]).success(
        fn=preprocess,
        inputs=[input_image, do_remove_background],
        outputs=[processed_image],
    ).success(
        fn=generate_mvs,
        inputs=[processed_image, sample_steps, sample_seed],
        outputs=[mv_images, mv_show_images],
    ).success(
        fn=make3d, inputs=[mv_images], outputs=[output_model_obj, output_model_glb]
    )

    step2_submit.click(
        fn=do_inference,
        inputs=[input_3d, sample_seed, do_sampling, do_marching_cubes],
        outputs=[
            preprocess_model_obj,
            input_image_render,
            output_model_obj,
            output_image_render,
        ],
    )


demo.queue(max_size=10)
demo.launch()