/* eslint-disable @typescript-eslint/ban-ts-comment */
/* eslint-disable no-async-promise-executor */
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/no-unused-vars */

import path from "node:path";
import { ChildProcess, spawn } from "node:child_process";
import ansiColors from "ansi-colors";
import net from "net";
import fs from "fs";
import { ConsoleMessage } from "puppeteer-core";
import ansiC from "ansi-colors";

import { IFinalResults, IRunTime } from "../../lib/index.js";
import { webEvaluator, getRunnables } from "./utils.js";
import { Queue } from "../../utils/queue.js";

import esbuildNodeConfiger from "../../esbuildConfigs/node.js";
import esbuildWebConfiger from "../../esbuildConfigs/web.js";
import esbuildImportConfiger from "../../esbuildConfigs/pure.js";

import {
  createLogStreams,
  LogStreams,
  statusMessagePretty,
} from "../../PM/utils.js";

import { PM_WithHelpo } from "./PM_WithHelpo.js";

const files: Record<string, Set<string>> = {};
const screenshots: Record<string, Promise<Uint8Array>[]> = {};

export class PM_Main extends PM_WithHelpo {
  constructor(configs: any, name: string, mode: string) {
    super(configs, name, mode);
  }

  async startBuildProcesses(): Promise<void> {
    const { nodeEntryPoints, webEntryPoints, pureEntryPoints } = getRunnables(
      this.configs.tests,
      this.projectName
    );

    console.log(`Starting build processes for ${this.projectName}...`);
    console.log(`  Node entry points: ${Object.keys(nodeEntryPoints).length}`);
    console.log(`  Web entry points: ${Object.keys(webEntryPoints).length}`);
    console.log(`  Pure entry points: ${Object.keys(pureEntryPoints).length}`);

    // Start all build processes (only node, web, pure)
    await Promise.all([
      this.startBuildProcess(esbuildNodeConfiger, nodeEntryPoints, "node"),
      this.startBuildProcess(esbuildWebConfiger, webEntryPoints, "web"),
      this.startBuildProcess(esbuildImportConfiger, pureEntryPoints, "pure"),
    ]);
  }

  private async setupTestEnvironment(
    src: string,
    runtime: IRunTime
  ): Promise<{
    reportDest: string;
    testConfig: any;
    testConfigResource: any;
    portsToUse: string[];
    testResources: string;
  }> {
    this.bddTestIsRunning(src);

    const reportDest = `testeranto/reports/${this.projectName}/${src
      .split(".")
      .slice(0, -1)
      .join(".")}/${runtime}`;

    if (!fs.existsSync(reportDest)) {
      fs.mkdirSync(reportDest, { recursive: true });
    }

    const testConfig = this.configs.tests.find((t) => t[0] === src);
    if (!testConfig) {
      console.log(
        ansiC.inverse(`missing test config! Exiting ungracefully for '${src}'`)
      );
      process.exit(-1);
    }

    const testConfigResource = testConfig[2];
    const portsToUse: string[] = [];
    let testResources = "";

    if (testConfigResource.ports === 0) {
      testResources = JSON.stringify({
        name: src,
        ports: [],
        fs: reportDest,
        browserWSEndpoint: this.browser.wsEndpoint(),
      });
    } else if (testConfigResource.ports > 0) {
      const openPorts = Object.entries(this.ports).filter(
        ([, status]) => status === ""
      );

      if (openPorts.length >= testConfigResource.ports) {
        for (let i = 0; i < testConfigResource.ports; i++) {
          portsToUse.push(openPorts[i][0]);
          this.ports[openPorts[i][0]] = src;
        }

        testResources = JSON.stringify({
          scheduled: true,
          name: src,
          ports: portsToUse,
          fs: reportDest,
          browserWSEndpoint: this.browser.wsEndpoint(),
        });
      } else {
        console.log(
          ansiC.red(
            `${runtime}: cannot run ${src} because there are no open ports ATM. This job will be enqueued and run again when a port is available`
          )
        );
        this.queue.push(src);
        throw new Error("No ports available");
      }
    } else {
      console.error("negative port makes no sense", src);
      process.exit(-1);
    }

    return {
      reportDest,
      testConfig,
      testConfigResource,
      portsToUse,
      testResources,
    };
  }

  private cleanupPorts(portsToUse: string[]) {
    portsToUse.forEach((port) => {
      this.ports[port] = "";
    });
  }

  private createIpcServer(
    onData: (data: Buffer) => void,
    ipcfile: string
  ): Promise<net.Server> {
    return new Promise((resolve, reject) => {
      const server = net.createServer((socket) => {
        socket.on("data", onData);
      });

      // @ts-ignore
      server.listen(ipcfile, (err) => {
        if (err) reject(err);
        else resolve(server);
      });

      server.on("error", reject);
    });
  }

  private handleChildProcess(
    child: ChildProcess,
    logs: LogStreams,
    reportDest: string,
    src: string,
    runtime: IRunTime
  ): Promise<void> {
    return new Promise((resolve, reject) => {
      child.stdout?.on("data", (data) => {
        logs.stdout?.write(data);
      });

      child.stderr?.on("data", (data) => {
        logs.stderr?.write(data);
      });

      child.on("close", (code) => {
        const exitCode = code === null ? -1 : code;
        if (exitCode < 0) {
          logs.writeExitCode(
            exitCode,
            new Error("Process crashed or was terminated")
          );
        } else {
          logs.writeExitCode(exitCode);
        }
        logs.closeAll();

        if (exitCode === 0) {
          this.bddTestIsNowDone(src, 0);
          statusMessagePretty(0, src, runtime);
          resolve();
        } else {
          console.log(
            ansiColors.red(
              `${runtime} ! ${src} failed to execute. Check ${reportDest}/stderr.log for more info`
            )
          );
          this.bddTestIsNowDone(src, exitCode);
          statusMessagePretty(exitCode, src, runtime);
          reject(new Error(`Process exited with code ${exitCode}`));
        }
      });

      child.on("error", (e) => {
        console.log(
          ansiC.red(
            ansiC.inverse(
              `${src} errored with: ${e.name}. Check error logs for more info`
            )
          )
        );
        this.bddTestIsNowDone(src, -1);
        statusMessagePretty(-1, src, runtime);
        reject(e);
      });
    });
  }

  launchPure = async (src: string, dest: string) => {
    console.log(ansiC.green(ansiC.inverse(`pure < ${src}`)));

    const processId = `pure-${src}-${Date.now()}`;
    const command = `pure test: ${src}`;

    // Create the promise
    const purePromise = (async () => {
      this.bddTestIsRunning(src);

      const reportDest = `testeranto/reports/${this.projectName}/${src
        .split(".")
        .slice(0, -1)
        .join(".")}/pure`;

      if (!fs.existsSync(reportDest)) {
        fs.mkdirSync(reportDest, { recursive: true });
      }

      const destFolder = dest.replace(".mjs", "");

      let argz = "";

      const testConfig = this.configs.tests.find((t) => {
        return t[0] === src;
      });

      if (!testConfig) {
        console.log(
          ansiC.inverse("missing test config! Exiting ungracefully!")
        );
        process.exit(-1);
      }
      const testConfigResource = testConfig[2];

      const portsToUse: string[] = [];
      if (testConfigResource.ports === 0) {
        argz = JSON.stringify({
          scheduled: true,
          name: src,
          ports: portsToUse,
          fs: reportDest,
          browserWSEndpoint: this.browser.wsEndpoint(),
        });
      } else if (testConfigResource.ports > 0) {
        const openPorts = Object.entries(this.ports).filter(
          ([portnumber, status]) => status === ""
        );

        if (openPorts.length >= testConfigResource.ports) {
          for (let i = 0; i < testConfigResource.ports; i++) {
            portsToUse.push(openPorts[i][0]);

            this.ports[openPorts[i][0]] = src; // port is now claimed
          }

          argz = JSON.stringify({
            scheduled: true,
            name: src,
            ports: portsToUse,
            fs: destFolder,
            browserWSEndpoint: this.browser.wsEndpoint(),
          });
        } else {
          this.queue.push(src);
          return [Math.random(), argz];
        }
      } else {
        console.error("negative port makes no sense", src);
        process.exit(-1);
      }

      const builtfile = dest;

      const logs = createLogStreams(reportDest, "pure");

      try {
        await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
          return module.default
            .then((defaultModule) => {
              return defaultModule
                .receiveTestResourceConfig(argz)
                .then(async (results: IFinalResults) => {
                  // Ensure the test results are properly processed
                  // The receiveTestResourceConfig should handle creating tests.json
                  statusMessagePretty(results.fails, src, "pure");
                  this.bddTestIsNowDone(src, results.fails);
                  return results.fails;
                });
            })
            .catch((e2) => {
              console.log(
                ansiColors.red(
                  `pure ! ${src} failed to execute. No "tests.json" file was generated. Check the logs for more info`
                )
              );

              // Create a minimal tests.json even on failure
              const testsJsonPath = `${reportDest}/tests.json`;
              if (!fs.existsSync(testsJsonPath)) {
                fs.writeFileSync(
                  testsJsonPath,
                  JSON.stringify(
                    {
                      tests: [],
                      features: [],
                      givens: [],
                      fullPath: src,
                    },
                    null,
                    2
                  )
                );
              }

              logs.exit.write(e2.stack);
              logs.exit.write(-1);
              this.bddTestIsNowDone(src, -1);
              statusMessagePretty(-1, src, "pure");
              throw e2;
            });
        });
      } catch (e3) {
        // Create a minimal tests.json even on uncaught errors
        const testsJsonPath = `${reportDest}/tests.json`;
        if (!fs.existsSync(testsJsonPath)) {
          fs.writeFileSync(
            testsJsonPath,
            JSON.stringify(
              {
                tests: [],
                features: [],
                givens: [],
                fullPath: src,
              },
              null,
              2
            )
          );
        }

        logs.writeExitCode(-1, e3);
        console.log(
          ansiC.red(
            ansiC.inverse(
              `${src} 1 errored with: ${e3}. Check logs for more info`
            )
          )
        );

        logs.exit.write(e3.stack);
        logs.exit.write("-1");
        this.bddTestIsNowDone(src, -1);
        statusMessagePretty(-1, src, "pure");
        throw e3;
      } finally {
        // Generate prompt files for Pure tests
        await this.generatePromptFiles(reportDest, src);

        for (let i = 0; i <= portsToUse.length; i++) {
          if (portsToUse[i]) {
            this.ports[portsToUse[i]] = ""; // port is open again
          }
        }
      }
    })();

    // Add to process manager
    this.addPromiseProcess(
      processId,
      purePromise,
      command,
      "bdd-test",
      src,
      "pure"
    );
  };

  launchNode = async (src: string, dest: string) => {
    console.log(ansiC.green(ansiC.inverse(`node < ${src}`)));

    const processId = `node-${src}-${Date.now()}`;
    const command = `node test: ${src}`;

    const nodePromise = (async () => {
      try {
        const { reportDest, testResources, portsToUse } =
          await this.setupTestEnvironment(src, "node");

        const builtfile = dest;
        const ipcfile = "/tmp/tpipe_" + Math.random();
        const logs = createLogStreams(reportDest, "node");

        let buffer = Buffer.from("");
        const queue = new Queue<string[]>();

        const onData = (data: Buffer) => {
          buffer = Buffer.concat([buffer, data]);

          // Process complete JSON messages
          for (let b = 0; b < buffer.length + 1; b++) {
            const c = buffer.slice(0, b);
            try {
              const d = JSON.parse(c.toString());
              queue.enqueue(d);
              buffer = buffer.slice(b);
              b = 0;
            } catch (e) {
              // Continue processing
            }
          }

          // Process messages
          while (queue.size() > 0) {
            const message = queue.dequeue();
            if (message) {
              this.mapping().forEach(async ([command, func]) => {
                if (message[0] === command) {
                  const args = message.slice(1, -1);
                  try {
                    const result = await (this as any)[command](...args);
                    child.send(
                      JSON.stringify({
                        payload: result,
                        key: message[message.length - 1],
                      })
                    );
                  } catch (error) {
                    console.error(`Error handling command ${command}:`, error);
                  }
                }
              });
            }
          }
        };

        const server = await this.createIpcServer(onData, ipcfile);
        const child = spawn("node", [builtfile, testResources, ipcfile], {
          stdio: ["pipe", "pipe", "pipe", "ipc"],
        });

        try {
          await this.handleChildProcess(child, logs, reportDest, src, "node");

          // Generate prompt files for Node tests
          await this.generatePromptFiles(reportDest, src);
        } finally {
          server.close();
          this.cleanupPorts(portsToUse);
        }
      } catch (error) {
        if (error.message !== "No ports available") {
          throw error;
        }
      }
    })();

    this.addPromiseProcess(
      processId,
      nodePromise,
      command,
      "bdd-test",
      src,
      "node"
    );
  };

  launchWeb = async (src: string, dest: string) => {
    console.log(ansiC.green(ansiC.inverse(`web < ${src}`)));

    const processId = `web-${src}-${Date.now()}`;
    const command = `web test: ${src}`;

    // Create the promise
    const webPromise = (async () => {
      this.bddTestIsRunning(src);

      const reportDest = `testeranto/reports/${this.projectName}/${src
        .split(".")
        .slice(0, -1)
        .join(".")}/web`;
      if (!fs.existsSync(reportDest)) {
        fs.mkdirSync(reportDest, { recursive: true });
      }

      const destFolder = dest.replace(".mjs", "");

      const webArgz = JSON.stringify({
        name: src,
        ports: [].toString(),
        fs: reportDest,
        browserWSEndpoint: this.browser.wsEndpoint(),
      });

      const d = `${dest}?cacheBust=${Date.now()}`;

      const logs = createLogStreams(reportDest, "web");

      logs.info?.write("testing123");
      logs.info?.write("wtf");

      return new Promise<void>((resolve, reject) => {
        this.browser
          .newPage()

          .then((page) => {
            // page.on("")
            page.on("console", (log: ConsoleMessage) => {
              console.log("mark9", log);

              const msg = `${log.text()}\n`;

              switch (log.type()) {
                case "info":
                  logs.info?.write(msg);
                  break;
                case "warn":
                  logs.warn?.write(msg);
                  break;
                case "error":
                  logs.error?.write(msg);
                  break;
                case "debug":
                  logs.debug?.write(msg);
                  break;
                default:
                  break;
              }
            });

            page.on("close", () => {
              logs.info?.write("close 1");
              logs.writeExitCode(0);
              logs.closeAll();
            });

            this.mapping().forEach(async ([command, func]) => {
              if (command === "page") {
                page.exposeFunction(command, (x?) => {
                  if (x) {
                    return func(x);
                  } else {
                    return func(page.mainFrame()._id);
                  }
                });
              } else {
                return page.exposeFunction(command, func);
              }
            });

            return page;
          })
          .then(async (page) => {
            const close = () => {
              logs.info?.write("close2");

              if (!files[src]) {
                files[src] = new Set();
              }

              delete files[src];

              Promise.all(screenshots[src] || []).then(() => {
                delete screenshots[src];
                page.close();
              });
            };

            page.on("pageerror", (err: Error) => {
              logs.info?.write("pageerror");
              // logs.writeExitCode(-1, err);
              // console.log(
              //   ansiColors.red(
              //     `web ! ${src} failed to execute No "tests.json" file was generated. Check ${reportDest}/error.log for more info`
              //   )
              // );
              // this.bddTestIsNowDone(src, -1);
              // close();
              reject(err);
            });

            await page.goto(`file://${`${destFolder}.html`}`, {});

            await page
              .evaluate(webEvaluator(d, webArgz))
              .then(async ({ fails, failed, features }: IFinalResults) => {
                logs.info?.write("\n idk1");
                statusMessagePretty(fails, src, "web");
                this.bddTestIsNowDone(src, fails);
                resolve();
              })
              .catch((e) => {
                logs.info?.write("\n idk2");
                console.log(ansiC.red(ansiC.inverse(e.stack)));
                console.log(
                  ansiC.red(
                    ansiC.inverse(
                      `web ! ${src} failed to execute. No "tests.json" file was generated. Check logs for more info`
                    )
                  )
                );

                // Create a minimal tests.json even on failure
                const testsJsonPath = `${reportDest}/tests.json`;
                if (!fs.existsSync(testsJsonPath)) {
                  fs.writeFileSync(
                    testsJsonPath,
                    JSON.stringify(
                      {
                        tests: [],
                        features: [],
                        givens: [],
                        fullPath: src,
                      },
                      null,
                      2
                    )
                  );
                }

                this.bddTestIsNowDone(src, -1);
                reject(e);
              })
              .finally(async () => {
                logs.info?.write("\n idk3");
                // Generate prompt files for Web tests
                await this.generatePromptFiles(reportDest, src);
                close();
              });
          })
          .catch((error) => {
            reject(error);
          });
      });
    })();

    // Add to process manager
    this.addPromiseProcess(
      processId,
      webPromise,
      command,
      "bdd-test",
      src,
      "web"
    );
  };

  launchPython = async (src: string, dest: string) => {
    console.log(ansiC.green(ansiC.inverse(`python < ${src}`)));

    const processId = `python-${src}-${Date.now()}`;
    const command = `python test: ${src}`;

    const pythonPromise = (async () => {
      try {
        const { reportDest, testResources, portsToUse } =
          await this.setupTestEnvironment(src, "python");

        const logs = createLogStreams(reportDest, "python");

        // Determine Python command
        const venvPython = `./venv/bin/python3`;
        const pythonCommand = fs.existsSync(venvPython)
          ? venvPython
          : "python3";

        const ipcfile = "/tmp/tpipe_python_" + Math.random();
        const child = spawn(pythonCommand, [src, testResources, ipcfile], {
          stdio: ["pipe", "pipe", "pipe", "ipc"],
        });

        // IPC server setup is similar to Node
        let buffer = Buffer.from("");
        const queue = new Queue<string[]>();

        const onData = (data: Buffer) => {
          buffer = Buffer.concat([buffer, data]);

          for (let b = 0; b < buffer.length + 1; b++) {
            const c = buffer.slice(0, b);
            try {
              const d = JSON.parse(c.toString());
              queue.enqueue(d);
              buffer = buffer.slice(b);
              b = 0;
            } catch (e) {
              // Continue processing
            }
          }

          while (queue.size() > 0) {
            const message = queue.dequeue();
            if (message) {
              this.mapping().forEach(async ([command, func]) => {
                if (message[0] === command) {
                  const args = message.slice(1, -1);
                  try {
                    const result = await (this as any)[command](...args);
                    child.send(
                      JSON.stringify({
                        payload: result,
                        key: message[message.length - 1],
                      })
                    );
                  } catch (error) {
                    console.error(`Error handling command ${command}:`, error);
                  }
                }
              });
            }
          }
        };

        const server = await this.createIpcServer(onData, ipcfile);

        try {
          await this.handleChildProcess(child, logs, reportDest, src, "python");

          // Generate prompt files for Python tests
          await this.generatePromptFiles(reportDest, src);
        } finally {
          server.close();
          this.cleanupPorts(portsToUse);
        }
      } catch (error) {
        if (error.message !== "No ports available") {
          throw error;
        }
      }
    })();

    this.addPromiseProcess(
      processId,
      pythonPromise,
      command,
      "bdd-test",
      src,
      "python"
    );
  };

  launchGolang = async (src: string, dest: string) => {
    console.log(ansiC.green(ansiC.inverse(`goland < ${src}`)));

    const processId = `golang-${src}-${Date.now()}`;
    const command = `golang test: ${src}`;

    const golangPromise = (async () => {
      try {
        const { reportDest, testResources, portsToUse } =
          await this.setupTestEnvironment(src, "golang");

        const logs = createLogStreams(reportDest, "golang");

        // Create IPC file path
        const ipcfile =
          "/tmp/tpipe_golang_" + Math.random().toString(36).substring(2);

        let buffer = Buffer.from("");
        const queue = new Queue<string[]>();

        const onData = (data: Buffer) => {
          buffer = Buffer.concat([buffer, data]);

          // Process complete JSON messages
          for (let b = 0; b < buffer.length + 1; b++) {
            const c = buffer.slice(0, b);
            try {
              const d = JSON.parse(c.toString());
              queue.enqueue(d);
              buffer = buffer.slice(b);
              b = 0;
            } catch (e) {
              // Continue processing
            }
          }

          // Process messages
          while (queue.size() > 0) {
            const message = queue.dequeue();
            if (message) {
              this.mapping().forEach(async ([command, func]) => {
                if (message[0] === command) {
                  const args = message.slice(1, -1);
                  try {
                    const result = await (this as any)[command](...args);
                    // Send response back through IPC
                    // This would need to be implemented based on your IPC protocol
                  } catch (error) {
                    console.error(`Error handling command ${command}:`, error);
                  }
                }
              });
            }
          }
        };

        // Create IPC server like in launchNode
        const server = await this.createIpcServer(onData, ipcfile);

        // For Go tests, we need to run from the directory containing the go.mod file
        // Find the nearest go.mod file by walking up the directory tree
        let currentDir = path.dirname(src);
        let goModDir = null;

        while (currentDir !== path.parse(currentDir).root) {
          if (fs.existsSync(path.join(currentDir, "go.mod"))) {
            // @ts-ignore
            goModDir = currentDir;
            break;
          }
          currentDir = path.dirname(currentDir);
        }

        if (!goModDir) {
          console.error(`Could not find go.mod file for test ${src}`);
          // Try running from the test file's directory as a fallback
          // @ts-ignore
          goModDir = path.dirname(src);
          console.error(`Falling back to: ${goModDir}`);
        }

        // Get the relative path to the test file from the go.mod directory
        // @ts-ignore
        const relativeTestPath = path.relative(goModDir, src);

        // Run go test from the directory containing go.mod
        const child = spawn(
          "go",
          ["test", "-v", "-json", "./" + path.dirname(relativeTestPath)],
          {
            stdio: ["pipe", "pipe", "pipe"],
            env: {
              ...process.env,
              TEST_RESOURCES: testResources,
              IPC_FILE: ipcfile,
              GO111MODULE: "on",
            },
            // @ts-ignore
            cwd: goModDir,
          }
        );

        await this.handleChildProcess(child, logs, reportDest, src, "golang");

        // Generate prompt files for Golang tests
        await this.generatePromptFiles(reportDest, src);

        // Ensure tests.json exists by parsing the go test JSON output
        await this.processGoTestOutput(reportDest, src);

        // Clean up
        server.close();
        try {
          fs.unlinkSync(ipcfile);
        } catch (e) {
          // Ignore errors during cleanup
        }
        this.cleanupPorts(portsToUse);
      } catch (error) {
        if (error.message !== "No ports available") {
          throw error;
        }
      }
    })();

    this.addPromiseProcess(
      processId,
      golangPromise,
      command,
      "bdd-test",
      src,
      "golang"
    );
  };

  private async processGoTestOutput(
    reportDest: string,
    src: string
  ): Promise<void> {
    const testsJsonPath = `${reportDest}/tests.json`;

    // Parse the stdout.log to extract test results from JSON output
    const stdoutPath = `${reportDest}/stdout.log`;
    if (fs.existsSync(stdoutPath)) {
      try {
        const stdoutContent = fs.readFileSync(stdoutPath, "utf-8");
        const lines = stdoutContent.split("\n").filter((line) => line.trim());

        const testResults = {
          tests: [],
          features: [],
          givens: [],
          fullPath: path.resolve(process.cwd(), src),
        };

        // Parse each JSON line from go test output
        for (const line of lines) {
          try {
            const event = JSON.parse(line);
            if (event.Action === "pass" || event.Action === "fail") {
              // @ts-ignore
              testResults.tests.push({
                name: event.Test || event.Package,
                status: event.Action === "pass" ? "passed" : "failed",
                time: event.Elapsed ? `${event.Elapsed}s` : "0s",
              });
            }
          } catch (e) {
            // Skip non-JSON lines
          }
        }

        fs.writeFileSync(testsJsonPath, JSON.stringify(testResults, null, 2));
        return;
      } catch (error) {
        console.error("Error processing go test output:", error);
      }
    }

    // Fallback: create a basic tests.json if processing fails
    const basicTestResult = {
      tests: [],
      features: [],
      givens: [],
      fullPath: path.resolve(process.cwd(), src),
    };
    fs.writeFileSync(testsJsonPath, JSON.stringify(basicTestResult, null, 2));
  }

  private async generatePromptFiles(
    reportDest: string,
    src: string
  ): Promise<void> {
    try {
      // Ensure the report directory exists
      if (!fs.existsSync(reportDest)) {
        fs.mkdirSync(reportDest, { recursive: true });
      }

      // Create message.txt
      const messagePath = `${reportDest}/message.txt`;
      const messageContent = `There are 3 types of test reports.
1) bdd (highest priority)
2) type checker
3) static analysis (lowest priority)

"tests.json" is the detailed result of the bdd tests.
if these files do not exist, then something has gone badly wrong and needs to be addressed.

"type_errors.txt" is the result of the type checker.
if this file does not exist, then type check passed without errors;

"lint_errors.txt" is the result of the static analysis.
if this file does not exist, then static analysis passed without errors;

BDD failures are the highest priority. Focus on passing BDD tests before addressing other concerns.
Do not add error throwing/catching to the tests themselves.`;

      fs.writeFileSync(messagePath, messageContent);

      // Create prompt.txt
      const promptPath = `${reportDest}/prompt.txt`;

      const promptContent = `/read node_modules/testeranto/docs/index.md
/read node_modules/testeranto/docs/style.md
/read node_modules/testeranto/docs/testing.ai.txt
/read node_modules/testeranto/src/CoreTypes.ts

/read ${reportDest}/tests.json
/read ${reportDest}/type_errors.txt
/read ${reportDest}/lint_errors.txt

/read ${reportDest}/stdout.log
/read ${reportDest}/stderr.log
/read ${reportDest}/exit.log
/read ${reportDest}/message.txt`;

      fs.writeFileSync(promptPath, promptContent);
    } catch (error) {
      console.error(`Failed to generate prompt files for ${src}:`, error);
    }
  }

  // private getGolangSourceFiles(src: string): string[] {
  //   // Get all .go files in the same directory as the test
  //   const testDir = path.dirname(src);
  //   const files: string[] = [];

  //   try {
  //     const dirContents = fs.readdirSync(testDir);
  //     dirContents.forEach((file) => {
  //       if (file.endsWith(".go")) {
  //         files.push(path.join(testDir, file));
  //       }
  //     });
  //   } catch (error) {
  //     console.error(`Error reading directory ${testDir}:`, error);
  //   }

  //   // Always include the main test file
  //   if (!files.includes(src)) {
  //     files.push(src);
  //   }

  //   return files;
  // }
}