package planr

import (
	"log"
	"os"
        "io"
	"path"
	"path/filepath"
        // "fmt"
)

/* CONFIG DIRECTORY */

// Consumes path
// Returns true if traversal should halt
type traversalFunc func(path string) bool;

// Traverse up until the root is reached
// Calls traverseFunc each iteration
// Returns true if prematurely stopped
func traverseUp(reference string, shouldStop traversalFunc) bool {
  cursor := reference
  
  for !shouldStop(cursor) {
    if filepath.ToSlash(cursor) == "/" {
      return false 
    }
    cursor = filepath.Join(cursor, "..")
  }

  return true
}

func directoryExists(path string) bool {
  info, err := os.Stat(path)

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

    return false;
  }

  return info.IsDir()
}

// Find the configuration directory
// Uses:
// 1. PlANR_DIRECTORY env if set
// 2. planr
// 3. .planr
func configDir() string {

  // Return environmental override if set
  if dir, isSet := os.LookupEnv("PLANR_DIRECTORY"); isSet {

    if !directoryExists(dir) {
      log.Fatalf("Cannot find planr directory %s", dir);
    }

    return dir;
  }

  cwd, err := os.Getwd()

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

  var rubricDir string

  rubric_search_dirs := [2]string{
    "planr",
    ".planr",
  }

  found := traverseUp(cwd, func (path string) bool {

    for _, dir := range rubric_search_dirs {
      rubricDir = filepath.Join(path, dir)
      
      if directoryExists(rubricDir) {
        return true
      }
    }

    return false 
  });

  if !found {
    log.Fatal("Could not find planr directory");
  }

  return rubricDir
}

// Find rubric directory at PLANR_DIR/rubric
func RubricDir() string {
  rubricDir := path.Join(configDir(), "rubric");

  if !directoryExists(rubricDir) {
    log.Fatal("Could not find the rubric directory inside of planr") 
  }

  return rubricDir
}

// Collects the units from the configuration tree
// TODO: Cleanup
func collectUnits(
  name      string,
  defaults *Defaults,
  cfgs      []AdapterConfig,
  units    *[]TestCase,
) {
  fp, err := os.Open(name)
  if err != nil {
    log.Fatal(err)
  }

  // Process defaults for this directory if a defaults.toml is found
  defaultsPath := path.Join(name, "defaults.toml")
  if info, err := os.Stat(defaultsPath); err == nil && !info.IsDir() {
    d := DecodeDefaults(defaultsPath, cfgs)

    // inherit the properties not defined in this defaults
    if defaults != nil {
      d.Inherit(defaults)
    }

    defaults = &d
  }

  // Read the entries in this directory
  for {
    dirs, err := fp.ReadDir(100)
    if err == io.EOF {
      break
    } else if err != nil {
      log.Fatal(err)
    }


    for _, ent := range dirs {
      child := path.Join(name, ent.Name())
      nm := ent.Name()

      if ent.IsDir() {
        collectUnits(child, defaults, cfgs, units)
      } else {
        if nm == "defaults.toml" {
          continue
        }

        // Decode a unit
        config := DecodeConfig(child, cfgs)
        config.Inherit(*defaults)

        tc := TestCase {
          Path: child,
          Cname: nm,
          Config: config,
        }

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