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

# Define the number of classes
num_classes = 2

# 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 predict(input_data):
    try:
        print(f"Input data received: {input_data}, Type: {type(input_data)}")
        
        # Check if the input is a URL or image
        if isinstance(input_data, str):  # If it's a string, assume it's a URL
            try:
                response = requests.get(input_data)
                response.raise_for_status()  # Raise error for HTTP issues
                img = Image.open(BytesIO(response.content))
                print("Image fetched successfully from URL.")
            except Exception as e:
                print(f"Error fetching image from URL: {e}")
                return json.dumps({"error": f"Failed to fetch image from URL: {e}"})
        else:  # If it's not a string, assume it's an image file
            img = input_data

        # Validate the image
        if not isinstance(img, Image.Image):
            print("Invalid image format received.")
            return json.dumps({"error": "Invalid image format received. Please provide a valid image."})
        else:
            print(f"Image successfully loaded: {img}")

        # Apply transformations to the image
        img = transform(img).unsqueeze(0)
        print(f"Transformed image tensor shape: {img.shape}")

        # Ensure model is loaded
        if model is None:
            return json.dumps({"error": "Model not loaded. Ensure the model file is available and correctly loaded."})

        # Move the image to the correct device
        img = img.to(torch.device("cuda" if torch.cuda.is_available() else "cpu"))

        # Make predictions
        with torch.no_grad():
            outputs = model(img)
            predicted_class = torch.argmax(outputs, dim=1).item()
            print(f"Model prediction outputs: {outputs}, Predicted class: {predicted_class}")

        # Return the result based on the predicted class
        if predicted_class == 0:
            return json.dumps({"result": "The photo you've sent is of fall army worm with problem ID 126."})
        elif predicted_class == 1:
            return json.dumps({"result": "The photo you've sent is of a healthy maize image."})
        else:
            return json.dumps({"error": "Unexpected class prediction."})

    except Exception as e:
        print(f"Error processing image: {e}")
        return json.dumps({"error": f"Error processing image: {e}"})


# Create the Gradio interface with both local file upload and URL input
iface = gr.Interface(
    fn=predict,
    inputs=[gr.Image(type="pil", label="Upload an image or provide a local path"), 
            gr.Textbox(label="Or enter image URL (if available)", placeholder="Enter a URL for the image")],
    outputs=gr.Textbox(label="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)