import fs from "node:fs"
import path from "node:path"
import { performance } from "node:perf_hooks"

import type { Solution } from "./Solution.js"
import { docker } from "./Docker.js"
import { SolutionTestsResult } from "./SolutionTestsResult.js"
import { TemporaryFolder } from "./TemporaryFolder.js"

export interface InputOutput {
  input: string
  output: string
}

export interface TestRunOptions {
  testNumber: number
  path: string
  solution: Solution
}

export interface TestOptions {
  testNumber: number
  path: string
  isSuccess: boolean
  input: string
  output: string
  stdout: string
}

export class Test implements TestOptions {
  public testNumber: number
  public path: string
  public isSuccess: boolean
  public input: string
  public output: string
  public stdout: string

  constructor(options: TestOptions) {
    this.testNumber = options.testNumber
    this.path = options.path
    this.isSuccess = options.isSuccess
    this.input = options.input
    this.output = options.output
    this.stdout = options.stdout
  }

  static async runAll(solution: Solution): Promise<SolutionTestsResult> {
    const testsPath = path.join(solution.challenge.path, "test")
    const testsFolders = await fs.promises.readdir(testsPath)
    const testsNumbers = testsFolders.map((test) => {
      return Number(test)
    })
    const testsPromises: Array<Promise<Test>> = []
    const start = performance.now()
    for (const testNumber of testsNumbers) {
      const testPath = path.join(testsPath, testNumber.toString())
      testsPromises.push(Test.run({ testNumber, path: testPath, solution }))
    }
    const tests = await Promise.all(testsPromises)
    const end = performance.now()
    const elapsedTimeMilliseconds = end - start
    return new SolutionTestsResult({ solution, tests, elapsedTimeMilliseconds })
  }

  static async getInputOutput(testPath: string): Promise<InputOutput> {
    const inputPath = path.join(testPath, "input.txt")
    const outputPath = path.join(testPath, "output.txt")
    const input = await fs.promises.readFile(inputPath, { encoding: "utf-8" })
    const output = await fs.promises.readFile(outputPath, {
      encoding: "utf-8",
    })
    return { input, output }
  }

  static async runManyWithSolutions(solutions: Solution[]): Promise<number> {
    const solutionTestsResultsPromises: Array<Promise<SolutionTestsResult>> = []
    let isSolutionSuccess = true
    for (const solution of solutions) {
      const solutionTestsResultPromise = solution.test()
      solutionTestsResultsPromises.push(solutionTestsResultPromise)
      solutionTestsResultPromise
        .then((solutionTestsResult) => {
          solutionTestsResult.print()
          if (!solutionTestsResult.isSuccess) {
            isSolutionSuccess = false
          }
        })
        .catch(() => {})
    }
    await Promise.all(solutionTestsResultsPromises)
    await TemporaryFolder.cleanAll()
    if (isSolutionSuccess) {
      console.log(SolutionTestsResult.SUCCESS_MESSAGE)
      return 0
    }
    return 1
  }

  static async run(options: TestRunOptions): Promise<Test> {
    const { input, output } = await Test.getInputOutput(options.path)
    try {
      const { stdout } = await docker.run(
        input,
        options.solution.temporaryFolder.id,
      )
      const test = new Test({
        path: options.path,
        testNumber: options.testNumber,
        input,
        output,
        stdout,
        isSuccess: stdout === output,
      })
      return test
    } catch (error: any) {
      throw new Error(
        `solution: ${options.solution.path}\n${error.message as string}\n`,
      )
    }
  }
}