package gtest

import (
	"context"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"os/exec"
        "time"
	"path"
        "errors"
	"golang.flu0r1ne.net/planr"
)

const GTEST_CMAKE = "CMakeLists.txt"

func mkUnit(tc *planr.TestCase) cmakeUnit {
  cfg := tc.AdapterConfig().(*GtestConfig)

  return cmakeUnit {
    tc.Cname,
    cfg.joinTests(*cfg.Testfile),
    cfg.srcList(),
  };
}

func chdir(dir string) {
  if err := os.Chdir(dir); err != nil {
    log.Fatal(err)
  }
}

type GtestAdapter struct {}

func (a *GtestAdapter) Config() planr.AdapterConfig {
  return planr.AdapterConfig {
    Name: "gtest",
    ParseConfig: ParseConfig,
    ParseDefaultConfig: ParseDefaultConfig,
 }
}

func (adapter *GtestAdapter) Build(tcs []*planr.TestCase) {
  buildDir :=  adapter.Config().Dir()
  cmakeFile := path.Join(buildDir, GTEST_CMAKE)

  units := make([]cmakeUnit, 0)
  for _, tc := range tcs {
    
    fmt.Printf("[R] Building %s (%s)\n", tc.Cname, tc.Path)
    cfg := tc.AdapterConfig().(*GtestConfig)
    cfg.ensureSatisfied(tc.Path)

    units = append(units, mkUnit(tc))
  }

  genCmake(cmakeFile, units)
  
  chdir(buildDir)
  planr.RunCmd("cmake", "-S", ".", "-B", ".")
}

type ResultFromId map[string] planr.TestResult

func (adapter *GtestAdapter) execTests(cnames []string) ResultFromId {
  buildDir := adapter.Config().Dir()

  lut := make(ResultFromId, 0)
  for _, exe := range cnames {
      fmt.Printf("[R] Evaluating %s\n", exe)

      exePath := path.Join(buildDir, exe)

      f, err := ioutil.TempFile(buildDir, "gtest_adapter_*.json")

      if err != nil {
        log.Fatal(err)
      }

      ctx, cancel := context.WithTimeout(context.Background(), 9999*time.Millisecond)
      cmd := exec.CommandContext(ctx, exePath, "--gtest_output=json:" + f.Name())

      defer cancel()
      defer os.Remove(f.Name())

      exitFail := false
      if err := cmd.Run(); err != nil {
        var exiterr *exec.ExitError

        if errors.As(err, &exiterr) && exiterr.ExitCode() == 1{
          exitFail = true              
        } else {
          log.Printf("%v\n", err)
          os.Exit(exiterr.ExitCode())
        }
      }

      if exitFail {
        fmt.Printf("")
      }

      for _, r  := range decodeResults(f) {
        lut[exe + "." + r.id] = r.result
      }
  }

  return lut
}

func exes(tcs []*planr.TestCase) []string {
  set := make(map[string] bool, 0)
  
  for _, tc := range tcs {
    if(!set[tc.Cname]) {
      set[tc.Cname] = true
    }
  }
 
  exes := make([]string, 0)
  for k := range set {
    exes = append(exes, k)
  }
  
  return exes
}

func id(tc *planr.TestCase) string {
  cfg := tc.AdapterConfig().(*GtestConfig)
  return tc.Cname + "." + *cfg.Suite + "." + *cfg.Name
}

func (adapter *GtestAdapter) Evaluate(tcs []*planr.TestCase) {
  buildDir := adapter.Config().Dir()
  chdir(buildDir)

  planr.RunCmd("make", "-k")

  files := exes(tcs)
  resultById := adapter.execTests(files)

  for _, tc := range tcs {
    result := resultById[id(tc)]
    tc.Result = &result 
  }
}