import { VisionInterface } from "../interfaces/Vision";
import { VisonOpenAIService } from "../services/vision/openai";
import { VisionZhiPuService } from "../services/vision/zhipu";
import { VersionFluxService } from "../services/vision/Flux";
import { VisionBaiduCloudService } from "../services/vision/baidu";
import { VisionHuanYuanService } from "../services/vision/hunyuan";
import { VisionAliService } from "../services/vision/ali";
import { VisionDoubaoService } from "../services/vision/doubao";
import { ImageParams, ImageResult } from "../types/vision/vision";
import { DoubaoImageParams } from "../types/vision/doubao";
import { ImageGenerateParams } from "openai/resources";


export const ReAIVisionAPI = (options?: { host?: string, apiKey: string }): VisionInterface => {

    const host = options?.host || ""
    const apiKey = options?.apiKey || ""
    if (!apiKey) {
        throw new Error("apiKey is required")
    }

    if (apiKey.startsWith("sk-")) {
        return new VisonOpenAIService({ host, apiKey })
    } else if (apiKey.startsWith("zhipu:")) {
        const [pre, key] = apiKey.split(":")
        return new VisionZhiPuService(key)
    } else if (apiKey.startsWith("flux:")) {
        const [pre, key, secret] = apiKey.split(":")
        return new VersionFluxService(key + ":" + secret)
    } else if (apiKey.startsWith("baidu:")) {
        const [pre, clientId, clientSecret] = apiKey.split(":")
        return new VisionBaiduCloudService(clientId, clientSecret)
    } else if (apiKey.startsWith("hunyuan:")) {
        const [pre, secretId, secretKey] = apiKey.split(":")
        return new VisionHuanYuanService(secretId, secretKey)
    } else if (apiKey.startsWith("dashscope:")) {
        const [pre, key] = apiKey.split(":")
        return new VisionAliService(key)
    } else if (apiKey.startsWith("doubao:")) {
        const [pre, secretId, secretKey] = apiKey.split(":")
        return new VisionDoubaoService(secretId, secretKey)
    } else {
        throw new Error("apiKey is invalid")
    }
}


export class ReAIImageAPI {

    private api: VisionInterface
    constructor(options?: { host?: string, apiKey: string }) {
        this.api = ReAIVisionAPI(options)
    }

    async imageGenerate(params: ImageGenerateParams & ImageParams): Promise<ImageResult> {
        const res = await this.api.image(params)
        if (!(Symbol.asyncIterator in res)) {
            throw new Error("Image generation stream is not iterable");
        }

        for await (const element of res) {
            const status = (element as ImageResult).status
            if (status === "completed") {
                return element as ImageResult
            }
            if (status === "failed") {
                throw new Error((element as ImageResult).message)
            }
        }
        throw new Error("Image generation failed")
    }
}