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

//npm install tiktoken
//csk-8jftdte6r6vf8fdvp9xkyek5t3jnc6jfhh93d3ewfcwxxvh9

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


function renderUsage(usage) {
  const inputTokens = usage.input_tokens - usage.input_tokens_details.cached_tokens;
  const cacheTokens = usage.input_tokens_details.cached_tokens;
  const outputToken = usage.output_tokens;
  console.log('          Cost', inputTokens, cacheTokens, outputToken);
}

function printIndented(indentNum, ...args) {
  const indent = ' '.repeat(indentNum);
  const output = args.map(arg => {
    if (typeof arg === 'string') return arg;
    try {
      return JSON.stringify(arg, null, 2);
    } catch {
      return String(arg);
    }
  }).join(' ');
  // Indent every line
  console.log(output.split('\n').map(line => indent + line).join('\n'));
}

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 }), 'Erstelle eine React Project für eine Abovverwaltung. Mui, Sqllite, Express, Nodejs, KEIN Typescript, Aber ESM import. webpack, kein vite. HRM, nodemon');


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

  let input = [
    {"role": "developer",  "content": [ {"type": "input_text","text": `You are an interactive CLI AI assistant. Follow the user's instructions.` }] },
    {"role": "user",       "content": [ {"type": "input_text","text": userText } ]},
  ]

  while(input.length > 0){

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

    console.log("\n\n\n\n\n------NEW OPENAI CALL-"+input.length+"-------------"
      ,"\n",counter++,"\n",'----INPUT-----------------'
      ,"\n",call.input.map(i => JSON.stringify(i)),"\n",
      '--------CALL-------------',"\n");
    const stream = await openai.responses.stream(call);
    stream.on('response.created', (event) => {
      previousResponseId = event.response.id;
    });
    stream.on('response.reasoning_summary_text.delta', (event) => {
      process.stdout.write('o')
    });
    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('.')
    });


    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('x');
    });

    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);
        }
        console.log('          function call:', id, name);
        functionCalls.push({ id, name, args, promise: toolsByFile[name].run(args) });
      }
    });

    stream.on('response.completed', async (event) => {
      printIndented(10,renderUsage(event.response.usage));
      if (event.response.output.filter(i => i.type === 'message').length > 0) printIndented(10, "Textresult:",event.response.output.filter(i => i.type === 'message').map(i => i.content[0].text));
    });

    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),
        })
        printIndented(10,'function call result:',result);
      //} catch (err) {
      //  console.error('Error in function call:', call.name, err);
      //}
    }
  }

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