package projet

import chisel3.simulator.scalatest.ChiselSim
import org.scalatest.freespec.AnyFreeSpec
import org.scalatest.matchers.must.Matchers
import java.nio.file.{Files, Paths}
import scala.jdk.CollectionConverters._
import scala.io.Source
import scala.collection.mutable.ListBuffer
import java.nio.file.FileSystems
import java.nio.file.Path
import org.scalatest.ParallelTestExecution

class ZzTopAllSpec
    extends AnyFreeSpec
    with Matchers
    with ParallelTestExecution
    with ChiselSim {

    def expectedValuesFromAsm(path: String): Seq[BigInt] = {
        val line =
            Source.fromFile(path).getLines().find(_.startsWith("# expected:"))
        line match {
            case Some(l) =>
                l.stripPrefix("# expected:")
                    .split(",")
                    .map(_.trim)
                    .filter(_.nonEmpty)
                    .map(str => BigInt(str, 16))
                    .toSeq
            case None =>
                Seq.empty
        }
    }

    def failTrace(msg: String = "Erreur", trace: ListBuffer[String]): Unit = {
        val prefix = s"🛑 $msg\n"
        val traceStr =
            if (trace.nonEmpty)
                "Trace:\n" + trace.map("  - " + _).mkString("\n") + "\n"
            else ""
        fail(prefix + traceStr)
    }

    def expectNextValue(
        dut: ZzTop,
        expected: BigInt,
        timeout: Int,
        trace: ListBuffer[String]
    ): Unit = {
        var cycles = 0
        dut.clock.step(12) // Attente d'un cycle proc (12 cycles systeme)
        // Attendre une écriture dans x31
        while (!dut.io.valid_x31.get.peek().litToBoolean && cycles < timeout) {
            dut.clock.step(12) // Attente d'un cycle proc
            cycles += 1
            trace += f"Attente $cycles cycles"
        }

        if (cycles < timeout) {
            // Vérifier la nouvelle valeur
            val got = dut.io.x31.get.peek().litValue
            trace += f"Valeur attendue = 0x$expected%08X, reçue = 0x$got%08X"
            if (got != expected) failTrace("Mauvaise sortie", trace)
        } else {
            trace += f"Valeur attendue = 0x$expected%08X, reçue = ⏰"
            failTrace("Simulation bloquée", trace)
        }
    }

    // Fonction de test commune
    def testWith(file: String): Unit = {
        val path = file.replace("/mem/", "/").replace(".mem", ".s")
        if (Files.exists(Paths.get(path))) {
            val expected = expectedValuesFromAsm(path)
            val test_name = file.hashCode();

            simulate(
                new ZzTop(file, true),
                subdirectory = Some(test_name.toString())
            ) { dut =>
                val trace = ListBuffer[String]()
                expected.foreach { value =>
                    expectNextValue(dut, value, timeout = 100, trace)
                }
            }
        }
    }

    val dir =
        FileSystems.getDefault().getPath(sys.env("PROOT") + "/bench/mem/tests")
    // val suffix = ".mem"

    // val path = dir + name + suffix
    // print(path)

    var tests = Files
        .walk(dir)
        .iterator()
        .asScala
        .filter(path => path.getFileName().toString().split('.').last == "mem")
        .toArray[Path];

    for (t <- tests) {
        s"Sim ${t.toString()}" in {
            testWith(t.toString());
        }
    }
}