import io
import os
import sys
import json
import base64
import requests
import torch
import numpy as np
from PIL import Image
from io import BytesIO
from typing_extensions import override
from comfy_api.latest import ComfyExtension, io
from ..utils.image_utils import tensor_to_base64_string
from ..utils.config_utils import get_config_section

class GeminiImage(io.ComfyNode):
    """
    这个节点使用谷歌Gemini Image API 生成或者修改图片
    """

    @classmethod
    def _load_models_from_config(cls):
        """
        从config.json中加载模型列表
        如果获取不到，返回默认模型列表
        """
        try:
            config_path = os.path.join(os.path.dirname(__file__), '..', "config.json")
            if not os.path.exists(config_path):
                return ["gemini-2.5-flash-image"]

            with open(config_path, 'r', encoding='utf-8') as f:
                config = json.load(f)

            if 'gemini-image' in config and 'models' in config['gemini-image']:
                models = config['gemini-image']['models']
                if isinstance(models, list) and len(models) > 0:
                    return models

            return ["gemini-2.5-flash-image"]
        except Exception:
            return ["gemini-2.5-flash-image"]

    @classmethod
    def _load_config_credentials(cls, config_options=None):
        """
        从config.json中加载并验证API凭据，如果提供了config_options则优先使用
        返回 (base_url, api_key, timeout) 元组
        """
        # 如果提供了配置覆盖，则使用覆盖配置
        if config_options is not None:
            base_url = config_options.get('base_url', '').strip()
            api_key = config_options.get('api_key', '').strip()
            timeout = config_options.get('timeout', 120)

            # 如果覆盖配置中有有效的 base_url 和 api_key，则直接返回
            if base_url and api_key:
                return base_url, api_key, timeout

        # 否则从配置文件加载
        config_path = os.path.join(os.path.dirname(__file__), '..',  "config.json")

        # 检查配置文件是否存在
        if not os.path.exists(config_path):
            raise FileNotFoundError(f"Config file not found: {config_path}")

        try:
            with open(config_path, 'r', encoding='utf-8') as f:
                config = json.load(f)

            # 检查是否存在gemini配置段
            if 'gemini-image' not in config:
                raise ValueError("Missing 'gemini-image' section in config file")

            gemini_config = config['gemini-image']

            # 获取并验证base_url
            if 'base_url' not in gemini_config:
                raise ValueError("Missing 'base_url' in gemini-image section")
            base_url = gemini_config['base_url'].strip() if isinstance(gemini_config['base_url'], str) else str(gemini_config['base_url']).strip()
            if not base_url:
                raise ValueError("base_url cannot be empty")

            # 获取并验证api_key
            if 'api_key' not in gemini_config:
                raise ValueError("Missing 'api_key' in gemini-image section")
            api_key = gemini_config['api_key'].strip() if isinstance(gemini_config['api_key'], str) else str(gemini_config['api_key']).strip()
            if not api_key:
                raise ValueError("api_key cannot be empty")

            # 获取timeout参数，默认值为120秒
            timeout = gemini_config.get('timeout', 120)
            if isinstance(timeout, str):
                try:
                    timeout = int(timeout)
                except ValueError:
                    timeout = 120

            # 如果有配置覆盖，则使用覆盖的值（如果提供了）
            if config_options is not None:
                if config_options.get('base_url', '').strip():
                    base_url = config_options['base_url'].strip()
                if config_options.get('api_key', '').strip():
                    api_key = config_options['api_key'].strip()
                if config_options.get('timeout'):
                    timeout = config_options['timeout']

            return base_url, api_key, timeout

        except Exception as e:
            raise ValueError(f"Config loading error: {str(e)}")

    @classmethod
    def _get_proxy_config(cls, proxy_options=None):
        """
        从config.json中获取代理配置，如果提供了proxy_options则优先使用
        返回 proxies 字典或 None
        """
        # 如果提供了代理覆盖配置
        if proxy_options is not None:
            if not proxy_options.get('enable', False):
                return None

            proxies = {}
            if proxy_options.get('http', '').strip():
                proxies['http'] = proxy_options['http'].strip()
            if proxy_options.get('https', '').strip():
                proxies['https'] = proxy_options['https'].strip()

            return proxies if proxies else None

        # 否则从配置文件加载
        try:
            proxy_config = get_config_section('proxy')
            if not proxy_config or not proxy_config.get('enable', False):
                return None

            proxies = {}
            if proxy_config.get('http'):
                proxies['http'] = proxy_config['http']
            if proxy_config.get('https'):
                proxies['https'] = proxy_config['https']

            return proxies if proxies else None
        except Exception:
            return None

    @classmethod
    def define_schema(cls) -> io.Schema:
        """
            返回一个包含该节点所有信息的模式（schema）。
            一些可用类型："Model", "Vae", "Clip", "Conditioning", "Latent", "Image", "Int", "String", "Float", "Combo"。
            对于输出，应使用 "io.Model.Output"，对于输入，可以使用 "io.Model.Input"。
            类型可以是 "Combo" —— 这将是一个供选择的列表。
        """
        # 从配置文件加载模型列表
        model_options = cls._load_models_from_config()
        default_model = model_options[0]

        return io.Schema(
            node_id="YCYY_Gemini_Image_API",
            display_name="Gemini Image API",
            category="YCYY/API/image",
            inputs=[
                io.Image.Input(
                    id="images",
                    optional=True,
                    tooltip="Optional image(s) to use as context for the model"
                ),
                io.Custom("YCYY_API_CONFIG_OPTIONS").Input(
                    id="config_options",
                    optional=True,
                    tooltip="Optional configuration override from YCYY API Config Options"
                ),
                io.Custom("YCYY_API_PROXY_OPTIONS").Input(
                    id="proxy_options",
                    optional=True,
                    tooltip="Optional proxy configuration override from YCYY API Proxy Options"
                ),
                io.String.Input(
                    id="prompt",
                    multiline=True,
                ),
                io.Combo.Input(
                    id="model",
                    options=model_options,
                    default=default_model
                ),
                io.Combo.Input(
                    id="aspectRatio",
                    options=[
                        "auto",
                        "1:1",
                        "2:3",
                        "3:2",
                        "3:4",
                        "4:3",
                        "4:5",
                        "5:4",
                        "9:16",
                        "16:9",
                        "21:9"
                    ],
                    default="auto",
                    tooltip="The model defaults to matching the output image size to that of your input image, or otherwise generates 1:1 squares. You can control the aspect ratio of the output image using the aspect ratio"
                ),
                io.Combo.Input(
                    id="imageSize",
                    options=[
                        "1K",
                        "2K",
                        "4K"
                    ],
                    default="1K",
                    tooltip="Control the resolution of the output image. 1K is approximately 1024x1024, 2K is approximately 2048x2048, 4K is approximately 4096x4096(Only effective for the gemini-3 model)."
                ),
                io.Boolean.Input(
                    id="enableSearch",
                    default=False,
                    tooltip="Use the Google Search tool to generate images based on real-time information(Only effective for the gemini-3 model)"
                ),
                io.Int.Input(
                    id="seed",
                    min=0,
                    max=0xFFFFFFFFFFFFFFFF,
                    default=0,
                    control_after_generate=True
                )
            ],
            outputs=[
                io.Image.Output(),
                io.String.Output()
            ],
            description="This node uses the Google Gemini Image API to generate or modify images."
        )

    # @classmethod
    # def check_lazy_status(cls, image, string_field, int_field, float_field, print_to_screen):
    #     """
    #         返回一个需要被求值的输入名称列表。

    #         如果存在任何尚未被求值的惰性输入（lazy inputs），此函数将被调用。
    #         只要你返回的列表中至少有一个尚未被求值的字段（并且还有更多未求值的字段存在），
    #         那么一旦请求的字段值可用，此函数将再次被调用。

    #         任何已被求值的输入都将作为参数传递给此函数。任何未被求值的输入的值将为 None。
    #     """
    #     if print_to_screen == "enable":
    #         return ["int_field", "float_field", "string_field"]
    #     else:
    #         return []
    # 执行 GeminiImage 节点
    @classmethod
    def execute(cls, prompt, model, aspectRatio, imageSize, enableSearch, seed, images=None, config_options=None, proxy_options=None) -> io.NodeOutput:
        # 加载配置和凭据，如果提供了config_options则使用覆盖配置
        base_url, api_key, timeout = cls._load_config_credentials(config_options)
        # 获取代理配置，如果提供了proxy_options则使用覆盖配置
        proxies = cls._get_proxy_config(proxy_options)
        if not prompt:
            raise ValueError("prompt cannot be empty")
        api_url = base_url+"/"+model+":generateContent"
        if images is not None:
            return cls._edit_images(api_url,api_key,prompt,model,aspectRatio,imageSize,enableSearch,seed,images,timeout,proxies)
        else:
            return cls._generate_images(api_url,api_key,prompt,model,aspectRatio,imageSize,enableSearch,seed,timeout,proxies)
    # 图生图模式
    @classmethod
    def _edit_images(cls,api_url,api_key,prompt,model,aspectRatio,imageSize,enableSearch,seed,images,timeout,proxies=None)-> io.NodeOutput:
        image_parts = cls._create_image_parts(images)
        image_parts.append(
            {
                "text": prompt
            }
        )
        headers = {
            "x-goog-api-key": api_key,
            "Content-Type": "application/json"
        }
        payload = {
            "contents": [
                {
                    "parts": image_parts
                }
            ],
            "generationConfig": {
                "responseModalities": ["TEXT", "IMAGE"]
            }
        }
        # 根据模型类型添加imageConfig - gemini-2.5-flash-image不支持imageSize参数
        if model == "gemini-2.5-flash-image":
            # 对于不支持imageSize的模型，只添加aspectRatio（如果非auto）
            if aspectRatio != "auto":
                payload["generationConfig"]["imageConfig"] = {
                    "aspectRatio": aspectRatio
                }
        elif model == "gemini-3-pro-image-preview":
            # 对于支持imageSize的模型，添加imageSize和aspectRatio
            image_config = {
                "imageSize": imageSize
            }
            if aspectRatio != "auto":
                image_config["aspectRatio"] = aspectRatio
            payload["generationConfig"]["imageConfig"] = image_config
            if enableSearch:
                payload["tools"] = [{"google_search": {}}]

        # print(f"正在请求Gemini文生图API: {api_url}")
        # print(f"请求载荷: {json.dumps(payload)}")
        try:
            resp = requests.post(api_url, headers=headers, json=payload, timeout=timeout, proxies=proxies)
            return cls._parse_response(resp)
        except Exception as e:
            empty_image = cls._create_empty_image()
            return io.NodeOutput(empty_image,f'{{"success":false,"message":"The API request failed. Please check if the interface address and key are correct."}}')    
    # 将图像张量输入转换为与 Gemini API 兼容的格式。
    @classmethod
    def _create_image_parts(cls,image_input):
        image_parts: list[dict] = []
        for image_index in range(image_input.shape[0]):
            image_as_b64 = tensor_to_base64_string(
                image_input[image_index].unsqueeze(0)
            )
            inlineData ={
                "mimeType": "image/png",
                "data": image_as_b64
            }
            GeminiPart = {
                "inlineData": inlineData
            }
            image_parts.append(GeminiPart)
        return image_parts
    # 文生图模式
    @classmethod
    def _generate_images(cls,api_url,api_key,prompt,model,aspectRatio,imageSize,enableSearch,seed,timeout,proxies=None)-> io.NodeOutput:
        headers = {
            "x-goog-api-key": api_key,
            "Content-Type": "application/json"
        }
        payload = {
            "contents": [
                {
                    "parts": [
                        {
                            "text": prompt
                        }
                    ]
                }
            ],
            "generationConfig": {
                "responseModalities": ["TEXT", "IMAGE"]
            }
        }
        # 根据模型类型添加imageConfig - gemini-2.5-flash-image不支持imageSize参数
        if model == "gemini-2.5-flash-image":
            # 对于不支持imageSize的模型，只添加aspectRatio（如果非auto）
            if aspectRatio != "auto":
                payload["generationConfig"]["imageConfig"] = {
                    "aspectRatio": aspectRatio
                }
        elif model == "gemini-3-pro-image-preview":
            # 对于支持imageSize的模型，添加imageSize和aspectRatio
            image_config = {
                "imageSize": imageSize
            }
            if aspectRatio != "auto":
                image_config["aspectRatio"] = aspectRatio
            payload["generationConfig"]["imageConfig"] = image_config
            if enableSearch:
                payload["tools"] = [{"google_search": {}}]

        # print(f"正在请求Gemini文生图API: {api_url}")
        # print(f"请求载荷: {json.dumps(payload)}")
        try:
            resp = requests.post(api_url, headers=headers, json=payload, timeout=timeout, proxies=proxies)
            return cls._parse_response(resp)
        except Exception as e:
            empty_image = cls._create_empty_image()
            return io.NodeOutput(empty_image,f'{{"success":false,"message":"The API request failed. Please check if the interface address and key are correct."}}')
    # 解析response 返回内容
    @classmethod
    def _parse_response(cls,resp):
        # 检查HTTP状态码
        if resp.status_code != 200:
            empty_image = cls._create_empty_image()
            return (empty_image,f'{{"success":false,"message":"API request returns an error.status_code:{resp.status_code}.error_reason:{resp.text}"}}')
        # 检查返回内容是否为空
        if not resp.text.strip():
            empty_image = cls._create_empty_image()
            return (empty_image,f'{{"success":false,"message":"The API returns an empty content"}}')
        try:
            data = resp.json()
        except Exception as json_exception:
            # print(f"JSON解析失败：{json_exception}")
            empty_image = cls._create_empty_image()
            return (empty_image,f'{{"success":false,"message":"The API returned a JSON parsing failure"}}')
        # 解析响应数据
        if "candidates" in data and data["candidates"]:
            candidate = data["candidates"][0]
            content = candidate.get("content", {})
            parts = content.get("parts", [])
            # 查找图像部分
            for part in parts:
                if "inlineData" in part:
                    inline_data = part["inlineData"]
                    mime_type = inline_data.get("mimeType", "")
                    image_date = inline_data.get("data", "")               
                    if mime_type.startswith("image/"):
                        comfyui_image = cls._image_data_to_comfyui_image(image_date)
                        # 解析usage信息
                        usageMetadata = data.get("usageMetadata", {})
                        tokens_usage = cls._format_tokens_usage(usageMetadata)
                        return (comfyui_image, tokens_usage)
        else:
            # print(f"未找到imag数据")
            empty_image = cls._create_empty_image()
            return (empty_image,f'{{"success":false,"message":"Imag data not found"}}')
    # 将返回的图像数据解析为 comfyui 格式的 image
    @classmethod
    def _image_data_to_comfyui_image(cls,image_date):
        try:
            image_bytes = base64.b64decode(image_date)
            image = Image.open(BytesIO(image_bytes)).convert("RGB")
            image_np = np.array(image).astype(np.float32) / 255.0
            image_tensor = torch.from_numpy(image_np).unsqueeze(0) 
            return image_tensor
        except Exception as e:
            empty_image = cls._create_empty_image()
            return io.NodeOutput(empty_image,f'{{"success":false,"message":"Return image data parsing exception"}}')
    # 获取token用量
    @classmethod
    def _format_tokens_usage(cls,usageMetadata):
        if not usageMetadata:
            return ""
        total_tokens = usageMetadata.get('totalTokenCount', '-')
        return f'{{"success":true,"message":"total_tokens:{total_tokens}"}}'
    # 创建空图像
    @classmethod
    def _create_empty_image(cls):
        try:
            return torch.zeros(1, 512, 512, 3, dtype=torch.float32)
        except Exception as e:
            return None

# 设置 web 目录，该目录中的任何 .js 文件都将被前端加载为前端扩展
# WEB_DIRECTORY = "./somejs"


# 使用 router 添加自定义 API 路由
from aiohttp import web
from server import PromptServer

@PromptServer.instance.routes.get("/hello")
async def get_hello(request):
    return web.json_response("hello")