import gradio as gr
import torch
from torch import nn
from torchvision import models, transforms
from huggingface_hub import hf_hub_download
from PIL import Image
import requests
import base64
from io import BytesIO
import os

# Define the number of classes
num_classes = 2  # Update with the actual number of classes in your dataset

# Download model from Hugging Face
def download_model():
    try:
        model_path = hf_hub_download(repo_id="jays009/Restnet50", filename="pytorch_model.bin")
        return model_path
    except Exception as e:
        print(f"Error downloading model: {e}")
        return None

# Load the model from Hugging Face
def load_model(model_path):
    try:
        model = models.resnet50(pretrained=False)
        model.fc = nn.Linear(model.fc.in_features, num_classes)
        model.load_state_dict(torch.load(model_path, map_location=torch.device("cpu")))
        model.eval()
        return model
    except Exception as e:
        print(f"Error loading model: {e}")
        return None

# Download the model and load it
model_path = download_model()
model = load_model(model_path) if model_path else None

# Define the transformation for the input image
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])

def process_image(image_input):
    try:
        # Process the image input (URL, local file, or base64)
        if isinstance(image_input, dict):
            # Check if the input contains a URL
            if image_input.get("url"):
                image_url = image_input["url"]
                response = requests.get(image_url)
                image = Image.open(BytesIO(response.content))
            # Check if the input contains a file path
            elif image_input.get("path"):
                image_path = image_input["path"]
                image = Image.open(image_path)
            # Handle base64 if it's included
            elif image_input.get("data"):
                image_data = base64.b64decode(image_input["data"])
                image = Image.open(BytesIO(image_data))
            else:
                return "Invalid input data format. Please provide a URL or path."

            # Apply transformations
            image = transform(image).unsqueeze(0)
            image = image.to(torch.device("cuda" if torch.cuda.is_available() else "cpu"))

            # Make the prediction
            with torch.no_grad():
                outputs = model(image)
                predicted_class = torch.argmax(outputs, dim=1).item()

            # Return prediction result
            if predicted_class == 0:
                return "The photo you've sent is of fall army worm with problem ID 126."
            elif predicted_class == 1:
                return "The photo you've sent is of a healthy maize image."
            else:
                return "Unexpected class prediction."
        else:
            return "Invalid input. Please provide a dictionary with 'url' or 'path'."
    except Exception as e:
        print(f"Error processing image: {e}")
        return f"Error processing image: {e}"

# Create the Gradio interface
iface = gr.Interface(
    fn=process_image,
    inputs=gr.JSON(label="Upload an image (URL or Local Path)"),  # Input: JSON to handle URL or path
    outputs=gr.Textbox(label="Prediction Result"),  # Output: Prediction result
    live=True,
    title="Maize Anomaly Detection",
    description="Upload an image of maize to detect anomalies like disease or pest infestation. You can provide local paths, URLs, or base64-encoded images."
)

# Launch the Gradio interface
iface.launch(share=True, show_error=True)