import { ImageGenerateParams } from "openai/resources";
import { VisionInterface } from "../../interfaces/Vision";
import { Client } from "tencentcloud-sdk-nodejs-hunyuan/tencentcloud/services/hunyuan/v20230901/hunyuan_client";
import { SubmitHunyuanImageJobRequest, SubmitHunyuanImageJobResponse, TextToImageLiteRequest } from "tencentcloud-sdk-nodejs-hunyuan/tencentcloud/services/hunyuan/v20230901/hunyuan_models";
import { ImageParams, ImageResult, VideoParams, VideoResult } from "../../types/vision/vision";
import { VisionResultStream } from "../../utils/stream";

export class VisionHuanYuanService implements VisionInterface {

    client: Client

    constructor(secretId: string, secretKey: string) {
        this.client = new Client({
            credential: {
                secretId,
                secretKey
            },
            region: "ap-guangzhou"
        })
    }

    async image(params: ImageGenerateParams & ImageParams): Promise<VisionResultStream<ImageResult>> {
        const model = params.model || "lite"
        const stream = new VisionResultStream<ImageResult>()
        if (model === "lite") {
            const req: TextToImageLiteRequest = {
                Prompt: params.prompt,
                RspImgType: params.response_format === "url" ? "url" : "base64",
                LogoAdd: params.logAdd ? 1: 0
            }
            if (params.quality === "hd") {
                req.Resolution = "1024:1024"
            } else if (params.quality === "standard") {
                req.Resolution = "768:768"
            }

            const timer = setInterval(() => {
                stream.write({
                    status: "processing",
                    created_at: Date.now()
                } as ImageResult)
            }, 1000)

            this.client.TextToImageLite(req).then(res => {
                clearInterval(timer)
                stream.write({
                    status: "completed",
                    created_at: Date.now(),
                    data: [
                        (req.RspImgType === "url") ? {
                            format: "url",
                            url: res.ResultImage
                        } : {
                            format: "b64_json",
                            b64_json: res.ResultImage
                        }
                    ]
                } as ImageResult)
                stream.end()
            }).catch(err => {
                clearInterval(timer)
                stream.write({
                    status: "failed",
                    created_at: Date.now()
                } as ImageResult)
                stream.end()
                return
            })
        } else {
            const req: SubmitHunyuanImageJobRequest = {
                Prompt: params.prompt,
                LogoAdd: params.logAdd ? 1 : 0
            }
            if (params.quality === "hd") {
                req.Resolution = "1024:1024"
            } else if (params.quality === "standard") {
                req.Resolution = "768:768"
            }
            if (params.resolution) {
                req.Resolution = params.resolution || "768:768"
            }
            if (params.styleNo) {
                req.Style = params.styleNo
            }
            const res = await this.client.SubmitHunyuanImageJob(req)
            const queryJob = async (jobId: string): Promise<void> => {
                const resJob = await this.client.QueryHunyuanImageJob({
                    JobId: jobId
                })
                if (resJob.JobErrorCode) {
                    stream.write({
                        status: "failed",
                        message: resJob.JobErrorMsg
                    } as ImageResult)
                    stream.end()
                } else if (resJob.JobStatusCode === "5") {
                    stream.write({
                        status: "completed",
                        created_at: Date.now(),
                        data: resJob.ResultImage?.map(img => {
                            return {
                                format: "url",
                                url: img
                            }
                        })
                    } as ImageResult)
                    stream.end()
                } else {
                    stream.write({
                        status: "processing",
                        message: resJob.JobStatusMsg,
                        created_at: Date.now()
                    } as ImageResult)
                    setTimeout(async () => {
                        await queryJob(jobId)
                    }, 1000)
                }
            }
            if (res.JobId) {
                queryJob(res.JobId)
            } else {
                stream.write({
                    status: "failed",
                    message: "submit job failed"
                } as ImageResult)
                stream.end()
            }
           
        }

        return stream
    }

    video(params: VideoParams): Promise<VisionResultStream<VideoResult>> {
        throw new Error("Method not implemented.");
    }
}