#!/usr/bin/env node
import 'dotenv/config';
import OpenAI from 'openai';

import { promises as fs } from "node:fs";
import { fileURLToPath } from "node:url";
import path from "node:path";

const __dirname = path.dirname(fileURLToPath(import.meta.url));

async function loadTools() {
  const toolsDir = path.join(__dirname, "tools");
  const dirents = await fs.readdir(toolsDir, { withFileTypes: true });
  const toolEntries = await Promise.all(
    dirents
      .filter((dirent) => dirent.isFile() && dirent.name.endsWith(".js"))
      .map(async (dirent) => {
        const fileName = dirent.name.replace(/\.js$/, "");
        const module = await import(`file://${path.join(toolsDir, dirent.name)}`);
        return [fileName, { def: module.default, run: module.run }];
      })
  );
  return Object.fromEntries(toolEntries);
}


streamOnce(new OpenAI({ apiKey: process.env.OPENAI_API_KEY }), 'Zeig mir die Dateiein in /');

async function streamOnce(openai, userText) {
  const toolsByFile = await loadTools();
  let previousResponseId;

  let input = [
    { "role": "developer",  "content": [ {"type": "input_text","text":  '' }] },
    {"role": "user", "content": [ { "type": "input_text", "text": userText } ]},
  ]

  while(input.length > 0){
    console.log('input:', input.length);

    const call = {
      model: 'gpt-5-nano',
      input: input,
      text: { format: { type: 'text' }, verbosity: 'low' },
      reasoning: { effort: 'high', summary: 'detailed' },
      tools: Object.values(toolsByFile).map(t => t.def),
      store: true,
    }
    if(previousResponseId) call.previous_response_id = previousResponseId;

    const stream = await openai.responses.stream(call);
    stream.on('response.created', (event) => {
      if(!previousResponseId){
        previousResponseId = event.response.id;
      }
    });
    stream.on('response.reasoning_summary_text.delta', (event) => {
      //process.stdout.write(event.delta);
    });
    stream.on('response.reasoning_summary_text.done', () => {
      //process.stdout.write('\n');
      //clear on next delta
    });

    stream.on('response.output_text.delta', (event) => {
      process.stdout.write(event.delta);
    });


    stream.on('response.output_item.added', (event) => {
      if(event.item && event.item.type === 'function_call'){
        //console.log('function call:', event.item);
      }
    });
    stream.on('response.function_call_arguments.delta', (event) => {
      //process.stdout.write(event.delta);
    });

    const functionCalls = [];

    stream.on('response.output_item.done', async (event) => {
      if(event.item && event.item.type === 'function_call'){
        const id = event.item.call_id;
        const name = event.item.name;
        let args = {};
        try { 
          args = JSON.parse(event.item.arguments); 
        } catch (e){
          console.error('Error parsing arguments:', e, event.item.arguments);
        }
        functionCalls.push({ id, name, args, promise: toolsByFile[name].run(args) });
      }
    });

    stream.on('response.completed', async (event) => {
      //log usage & print messages to user
    });

    await Array.fromAsync(stream);
    input=[];

    for (const call of functionCalls) {
      try {
        const result = await call.promise;
        input.push({
          type: "function_call_output",
          call_id: call.id,
          output: JSON.stringify(result),
        })
        //console.log('function call result:', call,result);
      } catch (err) {
        console.error('Error in function call:', call.name, err);
      }
    }
  }

  //console.log('OPENAI STREAM FINISHED');
}