import os
import gradio as gr
import numpy as np
import random
import spaces
from diffusers import DiffusionPipeline
import torch
import json
import logging
from diffusers import DiffusionPipeline, AutoencoderTiny, AutoencoderKL
from live_preview_helpers import calculate_shift, retrieve_timesteps, flux_pipe_call_that_returns_an_iterable_of_images

from huggingface_hub import hf_hub_download, HfFileSystem, ModelCard, snapshot_download
import copy
import random
import time


# init
dtype = torch.bfloat16
device = "cuda" if torch.cuda.is_available() else "cpu"
base_model = "black-forest-labs/FLUX.1-dev"

taef1 = AutoencoderTiny.from_pretrained("madebyollin/taef1", torch_dtype=dtype).to(device)
good_vae = AutoencoderKL.from_pretrained(base_model, subfolder="vae", torch_dtype=dtype).to(device)
pipe = DiffusionPipeline.from_pretrained(base_model, torch_dtype=dtype, vae=taef1).to(device)

MAX_SEED = 2**32-1

pipe.flux_pipe_call_that_returns_an_iterable_of_images = flux_pipe_call_that_returns_an_iterable_of_images.__get__(pipe)

class calculateDuration:
    def __init__(self, activity_name=""):
        self.activity_name = activity_name

    def __enter__(self):
        self.start_time = time.time()
        return self
    
    def __exit__(self, exc_type, exc_value, traceback):
        self.end_time = time.time()
        self.elapsed_time = self.end_time - self.start_time
        if self.activity_name:
            print(f"Elapsed time for {self.activity_name}: {self.elapsed_time:.6f} seconds")
        else:
            print(f"Elapsed time: {self.elapsed_time:.6f} seconds")


@spaces.GPU(duration=70)
def generate_image(prompt, steps, seed, cfg_scale, width, height, lora_scale, progress):
    pipe.to("cuda")
    generator = torch.Generator(device="cuda").manual_seed(seed)
    with calculateDuration("Generating image"):
        # Generate image
        for img in pipe.flux_pipe_call_that_returns_an_iterable_of_images(
            prompt=prompt,
            num_inference_steps=steps,
            guidance_scale=cfg_scale,
            width=width,
            height=height,
            generator=generator,
            joint_attention_kwargs={"scale": lora_scale},
            output_type="pil",
            good_vae=good_vae,
        ):
            yield img


def run_lora(prompt, cfg_scale, steps, lora_repo, lora_name, randomize_seed, seed, width, height, lora_scale, progress=gr.Progress(track_tqdm=True)):
    
    with calculateDuration("Unloading LoRA"):
        pipe.unload_lora_weights()
        
    # Load LoRA weights
    with calculateDuration(f"Loading LoRA weights for {lora_repo} {lora_name}"):
       pipe.load_lora_weights(lora_repo, weight_name=lora_name)

    # Set random seed for reproducibility
    with calculateDuration("Randomizing seed"):
        if randomize_seed:
            seed = random.randint(0, MAX_SEED)

    image_generator = generate_image(prompt, steps, seed, cfg_scale, width, height, lora_scale, progress)
    
    # Consume the generator to get the final image
    final_image = None
    step_counter = 0
    for image in image_generator:
        step_counter+=1
        final_image = image
        progress_bar = f'<div class="progress-container"><div class="progress-bar" style="--current: {step_counter}; --total: {steps};"></div></div>'
        yield image, seed, gr.update(value=progress_bar, visible=True)
        
    yield final_image, seed, gr.update(value=progress_bar, visible=False)


css="""
#col-container {
    margin: 0 auto;
    max-width: 640px;
}
"""

with gr.Blocks(css=css) as demo:
    
    with gr.Column(elem_id="col-container"):
        gr.Markdown(f"""
        # Simple flux with lora
        """)
        
        with gr.Column():

            with gr.Row():
                
                prompt = gr.Text(
                    label="Prompt",
                    show_label=False,
                    max_lines=1,
                    placeholder="Enter your prompt",
                    container=False,
                )
                
                lora_repo = gr.Text(
                        label="Repo",
                        max_lines=1,
                        placeholder="Enter a lora repo",
                        visible=False,
                    )
                
                lora_name = gr.Text(
                        label="Weights",
                        max_lines=1,
                        placeholder="Enter a lora weights",
                        visible=False,
                    )
                run_button = gr.Button("Run", scale=0)

                with gr.Accordion("Advanced Settings", open=False):

                    with gr.Row():
                        seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0, randomize=True)
                        randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
                        lora_scale = gr.Slider(label="LoRA Scale", minimum=0, maximum=3, step=0.01, value=0.95)

                    with gr.Row():
                        width = gr.Slider(label="Width", minimum=256, maximum=1536, step=64, value=1024)
                        height = gr.Slider(label="Height", minimum=256, maximum=1536, step=64, value=1024)

                    with gr.Row():
                        cfg_scale = gr.Slider(label="CFG Scale", minimum=1, maximum=20, step=0.5, value=3.5)
                        steps = gr.Slider(label="Steps", minimum=1, maximum=50, step=1, value=28)
                    
                    

            with gr.Row():
                progress_bar = gr.Markdown(elem_id="progress",visible=False)
                result = gr.Image(label="Result", show_label=False)

    gr.on(
        triggers=[run_button.click, prompt.submit],
        fn = run_lora,
        inputs = [prompt, cfg_scale, steps, lora_repo, lora_name, randomize_seed, seed, width, height, lora_scale],
        outputs=[result, seed, progress_bar]
    )

demo.queue().launch()