import { ImageGenerateParams } from "openai/resources";
import { VisionInterface } from "../../interfaces/Vision";
import { ImageParams, ImageResult, VideoParams, VideoResult } from "../../types/vision/vision";
import { VisionResultStream } from "../../utils/stream";
import { VisionBase } from "./base";
import { API_HOSTS } from "../../types/host";
import { sleep } from "openai/core";
import { Logger } from "../../utils/Logger";

export class VisionAliService extends VisionBase implements VisionInterface {
    
    apiKey: string;
    constructor(apiKey: string) {
        super()
        this.apiKey = apiKey
    }

    async image(params: ImageGenerateParams & ImageParams): Promise<VisionResultStream<ImageResult>> {
        const body: any = {
            model: params.model || "wanx-v1",
            input: {
                prompt: params.prompt,
            },
            parameters: {
                n: params.n || 1,
            }
        }
        if (params.image_url) {
            body.input.ref_img = params.image_url
        }
        if (params.styleTag) {
            body.parameters.style = params.styleTag
        }
        if (params.size) {
            body.parameters.size = params.size
        }
        if (params.seed) {
            body.parameters.seed = params.seed
        }
        if (params.strength) {
            body.parameters.ref_strength = params.strength
        }
        Logger.debug(`[Ali] image request:`, body)
        const stream = new VisionResultStream<ImageResult>()
        fetch(API_HOSTS.DASHSCOPE_API + "/services/aigc/text2image/image-synthesis", {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                "Authorization": "Bearer " + this.apiKey,
                "X-DashScope-Async": "enable"
            },
            body: JSON.stringify(body)
        }).then(async response => {
            if (!response.ok || response.status !== 200) {
                stream.write({
                    status: "failed",
                    created_at: Date.now(),
                    message: `${response.status} ${response.statusText}`
                } as ImageResult)
                stream.end()
                return
            }

            const json = await response.json()
            if (json.code) {
                stream.write({
                    status: "failed",
                    created_at: Date.now(),
                    message: json.message
                })
                stream.end()
                return
            }

            const taskId = json.output.task_id
            let taskStatus = json.output.task_status
            Logger.debug(`[Ali] image task id:`, taskId)

            while (taskStatus !== "success") {
                await this.sleep(1000)

                const response = await fetch(API_HOSTS.DASHSCOPE_API + "/tasks/" + taskId, {
                    method: "GET",
                    headers: {
                        "Authorization": "Bearer " + this.apiKey
                    }
                })
                const json = await response.json()
                Logger.debug(`[Ali] image task json:`, json)

                const status = json.output.task_status
                if (status === "SUCCEEDED") {
                    taskStatus = "success"
                    stream.write({
                        status: "completed",
                        created_at: Date.now(),
                        data: json.output.results.map((result:any) => {
                            return {
                                format: "url",
                                url: result.url
                            }
                        })
                    } as ImageResult)
                    stream.end()
                    break
                } else if (status === "RUNNING") {
                    stream.write({
                        status: "progressing",
                        created_at: Date.now()
                    })
                } else if (status === "FAILED") {
                    stream.write({
                        status: "failed",
                        created_at: Date.now(),
                        message: json.output.message
                    })
                    stream.end()
                    break
                }
            }

        })
        return stream
        
    }

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

    private sleep(ms: number) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }
}