#!/usr/bin/env node

/**
 * Integration Tests for Pake CLI
 *
 * These tests verify that different components work together correctly.
 * They may take longer to run as they test actual build processes.
 */

import { spawn, execSync } from "child_process";
import fs from "fs";
import path from "path";
import config, { TIMEOUTS, TEST_URLS } from "./test.config.js";
import ora from "ora";

class IntegrationTestRunner {
  constructor() {
    this.tests = [];
    this.results = [];
    this.tempFiles = [];
  }

  addTest(name, testFn, timeout = TIMEOUTS.MEDIUM) {
    this.tests.push({ name, testFn, timeout });
  }

  async runAll() {
    console.log("🔧 Integration Tests");
    console.log("====================\n");

    for (const [index, test] of this.tests.entries()) {
      const spinner = ora(`Running ${test.name}...`).start();

      try {
        const result = await Promise.race([
          test.testFn(),
          new Promise((_, reject) =>
            setTimeout(() => reject(new Error("Timeout")), test.timeout),
          ),
        ]);

        if (result) {
          spinner.succeed(`${index + 1}. ${test.name}: PASS`);
          this.results.push({ name: test.name, passed: true });
        } else {
          spinner.fail(`${index + 1}. ${test.name}: FAIL`);
          this.results.push({ name: test.name, passed: false });
        }
      } catch (error) {
        spinner.fail(
          `${index + 1}. ${test.name}: ERROR - ${error.message.slice(0, 50)}...`,
        );
        this.results.push({
          name: test.name,
          passed: false,
          error: error.message,
        });
      }
    }

    this.cleanup();
    this.displayResults();
  }

  cleanup() {
    // Clean up any temporary files created during tests
    this.tempFiles.forEach((file) => {
      try {
        if (fs.existsSync(file)) {
          fs.unlinkSync(file);
        }
      } catch (error) {
        console.warn(`Warning: Could not clean up ${file}`);
      }
    });
  }

  displayResults() {
    const passed = this.results.filter((r) => r.passed).length;
    const total = this.results.length;

    console.log(`\n📊 Integration Test Results: ${passed}/${total} passed\n`);

    if (passed === total) {
      console.log("🎉 All integration tests passed!");
    } else {
      console.log("❌ Some integration tests failed");
      this.results
        .filter((r) => !r.passed)
        .forEach((result) => {
          console.log(
            `   - ${result.name}${result.error ? `: ${result.error}` : ""}`,
          );
        });
    }
  }

  trackTempFile(filepath) {
    this.tempFiles.push(filepath);
  }
}

const runner = new IntegrationTestRunner();

// Integration Tests
runner.addTest("CLI Process Spawning", () => {
  return new Promise((resolve) => {
    const child = spawn("node", [config.CLI_PATH, "--version"], {
      stdio: ["pipe", "pipe", "pipe"],
    });

    let output = "";
    child.stdout.on("data", (data) => {
      output += data.toString();
    });

    child.on("close", (code) => {
      resolve(code === 0 && /\d+\.\d+\.\d+/.test(output));
    });

    // Kill after 3 seconds if still running
    setTimeout(() => {
      child.kill();
      resolve(false);
    }, 3000);
  });
});

runner.addTest(
  "Interactive Mode Simulation",
  () => {
    return new Promise((resolve) => {
      const child = spawn("node", [config.CLI_PATH, TEST_URLS.WEEKLY], {
        stdio: ["pipe", "pipe", "pipe"],
      });

      let output = "";
      let prompted = false;

      child.stdout.on("data", (data) => {
        output += data.toString();
        // If we see a prompt for application name, provide input
        if (output.includes("Enter your application name") && !prompted) {
          prompted = true;
          child.stdin.write("TestApp\n");
          setTimeout(() => {
            child.kill();
            resolve(true);
          }, 1000);
        }
      });

      child.on("close", () => {
        resolve(prompted);
      });

      // Timeout after 10 seconds
      setTimeout(() => {
        child.kill();
        resolve(false);
      }, 10000);
    });
  },
  TIMEOUTS.MEDIUM,
);

runner.addTest(
  "Command Line Argument Parsing",
  () => {
    try {
      // Test argument validation by running CLI with --help to verify args are parsed
      const helpOutput = execSync(`node "${config.CLI_PATH}" --help`, {
        encoding: "utf8",
        timeout: 3000,
      });

      // Verify that our command structure is valid by checking help includes our options
      const validOptions = ["--width", "--height", "--debug", "--name"].every(
        (opt) => helpOutput.includes(opt),
      );

      return validOptions;
    } catch (error) {
      return false;
    }
  },
  TIMEOUTS.QUICK,
);

runner.addTest("File System Permissions", () => {
  try {
    // Test that we can write to current directory
    const testFile = "test-write-permission.tmp";
    fs.writeFileSync(testFile, "test");
    runner.trackTempFile(testFile);

    // Test that we can read from CLI directory
    const cliStats = fs.statSync(config.CLI_PATH);
    return cliStats.isFile();
  } catch (error) {
    return false;
  }
});

runner.addTest("Dependency Resolution", () => {
  try {
    // Verify that essential runtime dependencies are available
    const packageJsonPath = path.join(config.PROJECT_ROOT, "package.json");
    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));

    const essentialDeps = [
      "commander",
      "chalk",
      "fs-extra",
      "execa",
      "prompts",
    ];

    return essentialDeps.every((dep) => {
      try {
        // Try to resolve the dependency
        import.meta.resolve
          ? import.meta.resolve(dep)
          : require.resolve(dep, { paths: [config.PROJECT_ROOT] });
        return true;
      } catch {
        return packageJson.dependencies && packageJson.dependencies[dep];
      }
    });
  } catch {
    return false;
  }
});

// Run integration tests if this file is executed directly
if (import.meta.url === `file://${process.argv[1]}`) {
  runner.runAll().catch(console.error);
}

export default runner;