import * as plugins from './plugins.js';
import * as paths from './paths.js';

import { MultiModal } from './abstract.classes.multimodal.js';

export class OpenAiProvider extends MultiModal {
  private openAiToken: string;
  public openAiApiClient: plugins.openai.default;

  constructor(openaiToken: string) {
    super();
    this.openAiToken = openaiToken; // Ensure the token is stored
  }

  async start() {
    this.openAiApiClient = new plugins.openai.default({
      apiKey: this.openAiToken,
      dangerouslyAllowBrowser: true,
    });
  }

  async stop() {}

  chatStream(input: ReadableStream<string>): ReadableStream<string> {
    const decoder = new TextDecoder();
    let messageHistory: { role: 'assistant' | 'user'; content: string }[] = [];

    return new ReadableStream({
      async start(controller) {
        const reader = input.getReader();
        try {
          let done, value;
          while ((({ done, value } = await reader.read()), !done)) {
            const userMessage = decoder.decode(value, { stream: true });
            messageHistory.push({ role: 'user', content: userMessage });

            const aiResponse = await this.chat('', userMessage, messageHistory);
            messageHistory.push({ role: 'assistant', content: aiResponse.message });

            // Directly enqueue the string response instead of encoding it first
            controller.enqueue(aiResponse.message);
          }
          controller.close();
        } catch (err) {
          controller.error(err);
        }
      },
    });
  }

  // Implementing the synchronous chat interaction
  public async chat(
    systemMessage: string,
    userMessage: string,
    messageHistory: {
      role: 'assistant' | 'user';
      content: string;
    }[]
  ) {
    const result = await this.openAiApiClient.chat.completions.create({
      model: 'gpt-3.5-turbo-16k-0613',
      messages: [
        { role: 'system', content: systemMessage },
        ...messageHistory,
        { role: 'user', content: userMessage },
      ],
    });
    return {
      message: result.choices[0].message,
    };
  }

  public async audio(messageArg: string) {
    const done = plugins.smartpromise.defer();
    const result = await this.openAiApiClient.audio.speech.create({
      model: 'tts-1-hd',
      input: messageArg,
      voice: 'nova',
      response_format: 'mp3',
      speed: 1,
    });
    const stream = result.body.pipe(plugins.smartfile.fsStream.createWriteStream(plugins.path.join(paths.nogitDir, 'output.mp3')));
    stream.on('finish', () => {
      done.resolve();
    });
    return done.promise;
  }
}