package generate

import "os"
import "fmt"
import "os/exec"
import "testing"
import "path/filepath"

func testGenerateRun(test *testing.T, protocol *Protocol, imports string, testCase string) {
	// reset data directory
	dir := "test/generate-run"
	err := os.RemoveAll(dir)
	if err != nil { test.Fatal(err) }
	err = os.MkdirAll(dir, 0750)
	if err != nil { test.Fatal(err) }

	// open files
	sourceFile, err := os.Create(filepath.Join(dir, "protocol.go"))
	if err != nil { test.Fatal(err) }
	defer sourceFile.Close()
	mainFile, err := os.Create(filepath.Join(dir, "main.go"))
	if err != nil { test.Fatal(err) }
	defer mainFile.Close()

	// generate protocol
	generator := Generator {
		Output: sourceFile,
		PackageName: "main",
	}
	_, err = generator.Generate(protocol)
	if err != nil { test.Fatal(err) }

	// build static source files
	imports = `
		import "log"
		import "bytes"
		import "slices"
		import "git.tebibyte.media/sashakoshka/hopp/tape"
		` + imports
	setup := `log.Println("*** BEGIN TEST CASE OUTPUT ***")`
	teardown := `log.Println("--- END TEST CASE OUTPUT ---")`
	static := `
		func testEncode(message Message, correct ...byte) {
			buffer := bytes.Buffer { }
			encoder := tape.NewEncoder(&buffer)
			n, err := message.Encode(encoder)
			if err != nil { log.Fatalf("at %d: %v\n", n, err) }
			got := buffer.Bytes()
			if n != len(got) {
				log.Fatalln("len incorrect: %d != %d", got, correct)
			}
			if !slices.Equal(got, correct) {
				log.Fatalln("not equal:")
			}
		}
		`
	fmt.Fprintf(
		mainFile, "package main\n%s\nfunc main() {\n%s\n%s\n%s\n}\n%s",
		imports, setup, testCase, teardown, static)

	// build and run test
	command := exec.Command("go", "run", "./generate/test/generate-run")
	workingDirAbs, err := filepath.Abs("..")
	if err != nil { test.Fatal(err) }
	command.Dir = workingDirAbs
	command.Env = os.Environ()
	output, err := command.CombinedOutput()
	test.Logf("output of %v:\n%s", command, output)
	if err != nil { test.Fatal(err) }
}