import torch
import torch.nn as nn
import torchvision.utils as vutils
import gradio as gr
import numpy as np


# Define Generator architecture - must match the architecture used during training
class Generator(nn.Module):
    def __init__(self, ngpu=1, nz=100, ngf=64, nc=1):
        super(Generator, self).__init__()
        self.ngpu = ngpu
        self.main = nn.Sequential(
            # input is Z, going into a convolution
            nn.ConvTranspose2d(nz, ngf * 8, 4, 1, 0, bias=False),
            nn.BatchNorm2d(ngf * 8),
            nn.ReLU(True),
            # state size. (ngf*8) x 4 x 4
            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 4),
            nn.ReLU(True),
            # state size. (ngf*4) x 8 x 8
            nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 2),
            nn.ReLU(True),
            # state size. (ngf*2) x 16 x 16
            nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf),
            nn.ReLU(True),
            # state size. (ngf) x 32 x 32
            nn.ConvTranspose2d(ngf, nc, 4, 2, 1, bias=False),
            nn.Tanh()
            # state size. (nc) x 64 x 64
        )

    def forward(self, input):
        return self.main(input)


# Load the generator
def load_model(model_path):
    # Create the generator and load the saved weights
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    netG = Generator().to(device)
    netG.load_state_dict(torch.load(model_path, map_location=device))
    netG.eval()  # Set to evaluation mode
    return netG, device


# Generate images using the model
def generate_images(num_images=16, seed=None, model_path="models/netG_epoch_29.pth"):
    # Load the model
    netG, device = load_model(model_path)

    # Set random seed for reproducibility if provided
    if seed is not None:
        torch.manual_seed(seed)
        np.random.seed(seed)

    # Generate latent vectors
    nz = 100  # Size of the latent vector (must match the model)
    noise = torch.randn(num_images, nz, 1, 1, device=device)

    # Generate fake images
    with torch.no_grad():
        fake_images = netG(noise).detach().cpu()

    # Convert to grid for display
    grid = vutils.make_grid(fake_images, padding=2, normalize=True, nrow=int(np.sqrt(num_images)))

    # Convert from tensor to numpy array for Gradio
    grid_np = grid.numpy().transpose((1, 2, 0))

    # Convert from [-1, 1] to [0, 1] range for display
    grid_np = (grid_np + 1) / 2.0

    return grid_np


# Create Gradio interface
def create_gradio_app():
    with gr.Blocks(title="DCGAN MNIST Generator") as app:
        gr.Markdown("# DCGAN MNIST Generator")
        gr.Markdown("Generate MNIST-like digits using a Deep Convolutional GAN")

        with gr.Row():
            with gr.Column():
                num_images = gr.Slider(minimum=1, maximum=64, value=16, step=1, label="Number of Images")
                seed = gr.Number(label="Random Seed (leave blank for random)", precision=0)
                generate_button = gr.Button("Generate Images")

            with gr.Column():
                output_image = gr.Image(label="Generated Images")

        generate_button.click(fn=generate_images, inputs=[num_images, seed], outputs=output_image)

        gr.Markdown("## About")
        gr.Markdown("This model was trained using PyTorch DCGAN implementation on the MNIST dataset. "
                    "It generates new handwritten digit-like images from random noise.")

    return app


# Launch the app if the script is run directly
if __name__ == "__main__":
    app = create_gradio_app()
    app.launch()