package main

import (
	"bytes"
	"fmt"
	"io/fs"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"time"

	"github.com/bazelbuild/rules_go/go/runfiles"

	"edge-infra.dev/pkg/lib/build/bazel"
)

const rootdir = "."

func main() {
	startTime := time.Now()
	defer func() {
		duration := time.Since(startTime)
		log.Println("CouchCTL Integration Test Duration: ", duration, "Config", os.Args[1:])
	}()
	// gather and print all the paths
	var paths []string
	walkdir := os.DirFS(".")
	if err := fs.WalkDir(walkdir, rootdir, func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}

		if d.IsDir() {
			return nil
		}
		info, err := d.Info()
		if err != nil {
			return err
		}

		fmt.Println(path, info.Mode())
		paths = append(paths, path)

		return nil
	}); err != nil {
		log.Fatal(err)
	}

	// if its not a bazel run fake a test run
	if !bazel.IsBazelRun() && !bazel.IsBazelTest() {
		os.Setenv("TEST_WORKSPACE", "edge_infra")
	}

	_, exists := os.LookupEnv("RUNFILES_DIR")
	if !exists {
		os.Setenv("RUNFILES_DIR", os.Args[0]+".runfiles")
	}

	// go through the paths and execute test binaries
	for _, path := range paths {
		if strings.Contains(path, "couchctl_test") { // not fantastic
			if executeBinary(path) {
				fmt.Println("it passed")
			} else {
				fmt.Println("it did not pass")
			}
			break //
		}
	}
}

// execute a binary and return a bool for pass / fail
func executeBinary(path string) bool {
	r, _ := runfiles.New()
	rfilesPath := filepath.Join("edge_infra", path)

	p, err := r.Rlocation(rfilesPath)
	if err != nil {
		fmt.Printf("rlocation: %v", err)
		return false
	}
	fmt.Println("path: ", p)

	cmd := exec.Command(p)
	cmd.Env = os.Environ()
	args := os.Args[1:]
	cmd.Args = append(cmd.Args, args...)
	fmt.Println("cmd.Args: ", cmd.Args)
	var out bytes.Buffer
	var stderr bytes.Buffer
	cmd.Stdout = &out
	cmd.Stderr = &stderr
	err = cmd.Run()
	if err != nil {
		fmt.Println(fmt.Sprint(err) + ": " + stderr.String())
		return false
	}
	fmt.Println("Result: " + out.String())

	return true
}