package planr

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

/* 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()
}

func basename(path string) string {
  ext := filepath.Ext(path)
  return path[0:len(path) - len(ext)]
}

func Cname(root string, path string) string {
  rel, err := filepath.Rel(root, path) 
  
  if err != nil {
    log.Fatal(err)
  }
  
  rel = filepath.ToSlash(rel)
  parts := strings.Split(rel, "/")
  n := len(parts)

  if n == 0 {
    return ""
  }

  parts[n-1] = basename(parts[n-1])

  return strings.Join(parts, ".")
}

func collectUnits(root string, cfgs []AdapterConfig) []TestCase {
  tcs := make([]TestCase, 0)

  collectFromDir(root, nil, cfgs, &tcs)

  for i := range tcs {
    tcs[i].Cname = Cname(root, tcs[i].Path)
    tcs[i].readIdx = i
  }

  return tcs
}

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

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

    if err != nil {
      log.Fatalf("Error encounter in %s: %v\n", defaultsPath, err);
    }

    // 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(dir, ent.Name())
      nm := ent.Name()

      if ent.IsDir() {
        collectFromDir(child, defaults, cfgs, units)
      } else {
        if nm == DEFAULTS {
          continue
        }

        if path.Ext(nm) != ".toml" {
          continue
        }

        // Decode a unit
        config, err := DecodeRubricConfig(child, cfgs)

        if err != nil {
          log.Fatalf("Error encountered in %s: %v", child, config) 
        }

        if defaults != nil {
          config.Inherit(*defaults)
        }

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

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

func safeCd(newWd string) {
  if err := os.Chdir(newWd); err != nil {
    log.Fatalf("Could not change into directory %v\n", err)
  }
}