import type * as Openai from "#Source/openai/index.ts"

import type {
  BaseChatCompletionOptions,
  ChatCompletionOptions,
  ChatCompletionResult,
} from "./chat-completion.ts"
import { BaseChatCompletion } from "./chat-completion.ts"

export interface LingyiwanwuChatCompletionOptions extends BaseChatCompletionOptions {
  openai: Openai.Openai
}
export class LingyiwanwuChatCompletion extends BaseChatCompletion {
  protected readonly openai: Openai.Openai

  constructor(options: LingyiwanwuChatCompletionOptions) {
    super(options)
    this.logger.setDefaultName("LingyiwanwuChatCompletion")

    this.openai = options.openai
  }

  protected transformOptions(options: ChatCompletionOptions): Openai.CustomChatCompletionOptions {
    const transformedOptions: Openai.CustomChatCompletionOptions = {
      messages: options.messages.map((message) => {
        const { role, content } = message
        if (role === "system") {
          return message
        }
        if (role === "user") {
          if (typeof content === "string") {
            return {
              role,
              content,
            }
          }
          if (Array.isArray(content)) {
            return {
              role,
              content: content.map((item) => {
                if (item.type === "image_url") {
                  return {
                    type: item.type,
                    image_url: item.imageUrl,
                  }
                } else {
                  return item
                }
              }),
            }
          }
          throw new Error("Invalid content")
        }
        if (role === "assistant") {
          return message
        }
        throw new Error("Invalid role")
      }),
      model: options.model,
      ...(options.frequencyPenalty !== undefined
        ? { frequency_penalty: options.frequencyPenalty }
        : {}),
      ...(options.logitBias !== undefined ? { logit_bias: options.logitBias } : {}),
      ...(options.logprobs !== undefined ? { logprobs: options.logprobs } : {}),
      ...(options.maxCompletionTokens !== undefined
        ? { max_completion_tokens: options.maxCompletionTokens }
        : {}),
      ...(options.maxTokens !== undefined ? { max_tokens: options.maxTokens } : {}),
      ...(options.presencePenalty !== undefined
        ? { presence_penalty: options.presencePenalty }
        : {}),
      ...(options.responseFormat !== undefined ? { response_format: options.responseFormat } : {}),
      ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
      ...(options.topLogprobs !== undefined ? { top_logprobs: options.topLogprobs } : {}),
      ...(options.topP !== undefined ? { top_p: options.topP } : {}),
      timeout: options.timeoutFirstChunk ?? undefined,
      abortSignal: options.abortSignal,
    }
    return transformedOptions
  }

  async chatCompletion(options: ChatCompletionOptions): Promise<ChatCompletionResult> {
    const transformedOptions = this.transformOptions(options)
    const result = await this.openai.customChatCompletionStreaming(transformedOptions)
    return result
  }
}