import platform

import uvicorn
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

from backend.api.models.response import StableDiffusionResponse
from backend.base64_image import base64_image_to_pil, pil_image_to_base64_str
from backend.device import get_device_name
from backend.models.device import DeviceInfo
from backend.models.lcmdiffusion_setting import DiffusionTask, LCMDiffusionSetting
from constants import APP_VERSION, DEVICE
from context import Context
from models.interface_types import InterfaceType
from state import get_settings

app_settings = get_settings()
app = FastAPI(
    title="AEGIS Bio-Digital Lab 10 - Visual System",
    description="Scientific visualization system for pathogen and molecular structure generation",
    version=APP_VERSION,
    license_info={
        "name": "MIT",
        "identifier": "MIT",
    },
    docs_url="/api/docs",
    redoc_url="/api/redoc",
    openapi_url="/api/openapi.json",
)
print(app_settings.settings.lcm_diffusion_setting)
origins = ["*"]
app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)
context = Context(InterfaceType.API_SERVER)


@app.get("/api/")
async def root():
    return {"message": "Welcome to AEGIS Bio-Digital Lab 10 - Visual System API"}


@app.get(
    "/api/ping",
    description="Health check endpoint for UptimeRobot monitoring",
    summary="Ping endpoint",
)
async def ping():
    """Health check endpoint for monitoring services like UptimeRobot"""
    return {
        "status": "ok",
        "service": "AEGIS Bio-Digital Lab 10 - Visual System",
        "version": APP_VERSION,
        "device": DEVICE,
    }


@app.get(
    "/api/health",
    description="Detailed health check with system status",
    summary="Health check",
)
async def health():
    """Detailed health check endpoint"""
    return {
        "status": "healthy",
        "service": "AEGIS Bio-Digital Lab 10 - Visual System",
        "version": APP_VERSION,
        "device": DEVICE,
        "device_name": get_device_name(),
        "platform": platform.system(),
    }


@app.get(
    "/api/info",
    description="Get system information",
    summary="Get system information",
)
async def info():
    device_info = DeviceInfo(
        device_type=DEVICE,
        device_name=get_device_name(),
        os=platform.system(),
        platform=platform.platform(),
        processor=platform.processor(),
    )
    return device_info.model_dump()


@app.get(
    "/api/config",
    description="Get current configuration",
    summary="Get configurations",
)
async def config():
    return app_settings.settings


@app.get(
    "/api/models",
    description="Get available models",
    summary="Get available models",
)
async def models():
    return {
        "lcm_lora_models": app_settings.lcm_lora_models,
        "stable_diffusion": app_settings.stable_diffsuion_models,
        "openvino_models": app_settings.openvino_lcm_models,
        "lcm_models": app_settings.lcm_models,
    }


@app.post(
    "/api/generate",
    description="Generate image(Text to image,Image to Image)",
    summary="Generate image(Text to image,Image to Image)",
)
async def generate(diffusion_config: LCMDiffusionSetting) -> StableDiffusionResponse:
    app_settings.settings.lcm_diffusion_setting = diffusion_config
    if diffusion_config.diffusion_task == DiffusionTask.image_to_image:
        app_settings.settings.lcm_diffusion_setting.init_image = base64_image_to_pil(
            diffusion_config.init_image
        )

    images = context.generate_text_to_image(app_settings.settings)

    if images:
        images_base64 = [pil_image_to_base64_str(img) for img in images]
    else:
        images_base64 = []
    return StableDiffusionResponse(
        latency=round(context.latency, 2),
        images=images_base64,
        error=context.error,
    )


@app.post(
    "/api/window7/generate-pathogen",
    description="Generate virus or bacteria visualization for Window 7 Disease Analysis",
    summary="Generate pathogen visualization",
)
async def generate_pathogen_visualization(diffusion_config: LCMDiffusionSetting) -> StableDiffusionResponse:
    """
    Generate virus and bacteria visualizations for AEGIS Bio-Digital Lab 10 Window 7.
    Used for disease discovery and pathogen identification visualization.
    """
    app_settings.settings.lcm_diffusion_setting = diffusion_config
    
    if diffusion_config.diffusion_task == DiffusionTask.image_to_image:
        app_settings.settings.lcm_diffusion_setting.init_image = base64_image_to_pil(
            diffusion_config.init_image
        )
    
    images = context.generate_text_to_image(app_settings.settings)
    
    if images:
        images_base64 = [pil_image_to_base64_str(img) for img in images]
    else:
        images_base64 = []
    
    return StableDiffusionResponse(
        latency=round(context.latency, 2),
        images=images_base64,
        error=context.error,
    )


@app.post(
    "/api/window7/generate-disease-visualization",
    description="Generate disease and infection visualization for Window 7",
    summary="Generate disease visualization",
)
async def generate_disease_visualization(diffusion_config: LCMDiffusionSetting) -> StableDiffusionResponse:
    """
    Generate disease and infection visualizations for AEGIS Bio-Digital Lab 10 Window 7.
    Used for visualizing disease progression, symptoms, and affected areas.
    """
    app_settings.settings.lcm_diffusion_setting = diffusion_config
    
    if diffusion_config.diffusion_task == DiffusionTask.image_to_image:
        app_settings.settings.lcm_diffusion_setting.init_image = base64_image_to_pil(
            diffusion_config.init_image
        )
    
    images = context.generate_text_to_image(app_settings.settings)
    
    if images:
        images_base64 = [pil_image_to_base64_str(img) for img in images]
    else:
        images_base64 = []
    
    return StableDiffusionResponse(
        latency=round(context.latency, 2),
        images=images_base64,
        error=context.error,
    )


@app.post(
    "/api/window9/generate-molecule",
    description="Generate molecular structure visualization for Window 9",
    summary="Generate molecule visualization",
)
async def generate_molecule_visualization(diffusion_config: LCMDiffusionSetting) -> StableDiffusionResponse:
    """
    Generate molecular structure visualizations for AEGIS Bio-Digital Lab 10 Window 9.
    Used for drug development visualization after SMILES processing.
    """
    app_settings.settings.lcm_diffusion_setting = diffusion_config
    
    # Ensure we're doing text-to-image for molecular structures
    if diffusion_config.diffusion_task == DiffusionTask.image_to_image:
        app_settings.settings.lcm_diffusion_setting.init_image = base64_image_to_pil(
            diffusion_config.init_image
        )
    
    images = context.generate_text_to_image(app_settings.settings)
    
    if images:
        images_base64 = [pil_image_to_base64_str(img) for img in images]
    else:
        images_base64 = []
    
    return StableDiffusionResponse(
        latency=round(context.latency, 2),
        images=images_base64,
        error=context.error,
    )


@app.post(
    "/api/window9/generate-drug-visualization",
    description="Generate drug compound visualization for Window 9",
    summary="Generate drug visualization",
)
async def generate_drug_visualization(diffusion_config: LCMDiffusionSetting) -> StableDiffusionResponse:
    """
    Generate drug compound visualizations for AEGIS Bio-Digital Lab 10 Window 9.
    Used for visualizing drug candidates and their properties.
    """
    app_settings.settings.lcm_diffusion_setting = diffusion_config
    
    if diffusion_config.diffusion_task == DiffusionTask.image_to_image:
        app_settings.settings.lcm_diffusion_setting.init_image = base64_image_to_pil(
            diffusion_config.init_image
        )
    
    images = context.generate_text_to_image(app_settings.settings)
    
    if images:
        images_base64 = [pil_image_to_base64_str(img) for img in images]
    else:
        images_base64 = []
    
    return StableDiffusionResponse(
        latency=round(context.latency, 2),
        images=images_base64,
        error=context.error,
    )


@app.post(
    "/api/aegis/generate-scientific",
    description="Generate scientific visualization for AEGIS Bio-Digital Lab 10",
    summary="Generate scientific visualization",
)
async def generate_scientific_visualization(diffusion_config: LCMDiffusionSetting) -> StableDiffusionResponse:
    """
    General scientific visualization endpoint for AEGIS Bio-Digital Lab 10.
    Can be used across all windows for generating scientific imagery.
    """
    app_settings.settings.lcm_diffusion_setting = diffusion_config
    
    if diffusion_config.diffusion_task == DiffusionTask.image_to_image:
        app_settings.settings.lcm_diffusion_setting.init_image = base64_image_to_pil(
            diffusion_config.init_image
        )
    
    images = context.generate_text_to_image(app_settings.settings)
    
    if images:
        images_base64 = [pil_image_to_base64_str(img) for img in images]
    else:
        images_base64 = []
    
    return StableDiffusionResponse(
        latency=round(context.latency, 2),
        images=images_base64,
        error=context.error,
    )


def start_web_server(port: int = 8000):
    uvicorn.run(
        app,
        host="0.0.0.0",
        port=port,
    )