import gradio as gr
import numpy as np
from PIL import Image, ImageDraw

# Define your labels
part_labels = ["front-bumper", "fender", "hood", "door", "trunk"]
damage_labels = ["dent", "scratch", "misalignment", "crack"]

def mock_inference(image):
    # This function mocks the segmentation model output
    # It randomly assigns labels to different parts of the image
    height, width = image.shape[:2]
    part_mask = np.random.randint(0, len(part_labels), (height, width))
    damage_mask = np.random.randint(0, len(damage_labels), (height, width))
    return part_mask, damage_mask

def combine_masks(part_mask, damage_mask):
    part_damage_pairs = []
    for part_id, part_name in enumerate(part_labels):
        for damage_id, damage_name in enumerate(damage_labels):
            part_binary = (part_mask == part_id)
            damage_binary = (damage_mask == damage_id)
            intersection = np.logical_and(part_binary, damage_binary)
            if np.any(intersection):
                part_damage_pairs.append((part_name, damage_name))
    return part_damage_pairs

def create_one_hot_vector(part_damage_pairs):
    vector = np.zeros(len(part_labels) * len(damage_labels))
    for part, damage in part_damage_pairs:
        if part in part_labels and damage in damage_labels:
            part_index = part_labels.index(part)
            damage_index = damage_labels.index(damage)
            vector_index = part_index * len(damage_labels) + damage_index
            vector[vector_index] = 1
    return vector

def visualize_results(image, part_mask, damage_mask):
    img = Image.fromarray(image)
    draw = ImageDraw.Draw(img)
    
    for i in range(0, img.width, 10):  # Sample every 10th pixel for efficiency
        for j in range(0, img.height, 10):
            part = part_labels[part_mask[j, i]]
            damage = damage_labels[damage_mask[j, i]]
            draw.point((i, j), fill="red")
    
    return img

def process_image(image):
    # Mock inference
    part_mask, damage_mask = mock_inference(image)
    
    # Combine masks
    part_damage_pairs = combine_masks(part_mask, damage_mask)
    
    # Create one-hot encoded vector
    one_hot_vector = create_one_hot_vector(part_damage_pairs)
    
    # Visualize results
    result_image = visualize_results(image, part_mask, damage_mask)
    
    return result_image, part_damage_pairs, one_hot_vector.tolist()

def gradio_interface(input_image):
    result_image, part_damage_pairs, one_hot_vector = process_image(input_image)
    
    # Convert part_damage_pairs to a string for display
    damage_description = "\n".join([f"{part} : {damage}" for part, damage in part_damage_pairs])
    
    return result_image, damage_description, str(one_hot_vector)

iface = gr.Interface(
    fn=gradio_interface,
    inputs=gr.Image(type="numpy"),
    outputs=[
        gr.Image(type="pil", label="Detected Damage (Mocked)"),
        gr.Textbox(label="Damage Description"),
        gr.Textbox(label="One-hot Encoded Vector")
    ],
    title="Car Damage Assessment (Demo)",
    description="Upload an image of a damaged car to get a mocked assessment of the damage. Note: This is a demo using random predictions, not actual model inference."
)

iface.launch()