package config

import (
  "fmt"
  "runtime"
  "os"
  "strings"
  "path/filepath"
  "nilfm.cc/git/nirvash/adapter"
)

type Config struct {
  Adapter adapter.Adapter // adapter for this instance
  Root string // root of the site data
  StaticRoot string // root of static files for StaticFileManager
  AssetRoot string // root of Nirvash dist files (CSS, images)
  Plugins map[string]interface{}
}

func GetConfigLocation() string {
  home := os.Getenv("HOME")
  appdata := os.Getenv("APPDATA")
  switch (runtime.GOOS) {
    case "windows":
      return filepath.Join(appdata, "nirvash")
    case "darwin":
      return filepath.Join(home, "Library", "Application Support", "nirvash")
    case "plan9":
      return filepath.Join(home, "lib", "nirvash")
    default:
      return filepath.Join(home, ".config", "nirvash")
  }
}

func ensureConfigLocationExists() {
  _, err := os.Stat(GetConfigLocation())
  
  if os.IsNotExist(err) {
    os.MkdirAll(GetConfigLocation(), os.ModePerm)
  }
}

func Read() *Config {
  ensureConfigLocationExists()
	return parseConfig(filepath.Join(GetConfigLocation(), "nirvash.conf"))
}

func Write(cfg *Config) error {
  ensureConfigLocationExists()
  return writeConfig(cfg, filepath.Join(GetConfigLocation(), "nirvash.conf"))
}


func SetAdapter(cfg *Config, adptr string) {
  switch adptr {
  case "eureka": 
    cfg.Adapter = &adapter.EurekaAdapter{}
  default:
    panic("Unsupported adapter! Try one of [ eureka ]")
  }
}



func IsNull(cfg *Config) bool {
  return cfg.Adapter == nil || len(cfg.Root) == 0 || len(cfg.StaticRoot) == 0 || len(cfg.AssetRoot) == 0
}

func RunWizard(cfg *Config) {
  fmt.Printf("All options are required.\n")
  defer func(cfg *Config) {
    if r := recover(); r != nil {
      fmt.Printf("Invalid selection, starting over...")
      RunWizard(cfg)
    }
  }(cfg)
  inputBuf := ""
  fmt.Printf("adapter? (eureka) [eureka] ")
  fmt.Scanln(&inputBuf)
  if len(strings.TrimSpace(inputBuf)) == 0 {
    inputBuf = "eureka"
  }
  SetAdapter(cfg, inputBuf)
  
  inputBuf = ""
  fmt.Printf("site data root? ")
  ensureNonEmptyOption(&inputBuf)
  cfg.Root = inputBuf
  
  inputBuf = ""
  
  fmt.Printf("static file root? ")
  ensureNonEmptyOption(&inputBuf)
  cfg.StaticRoot = inputBuf
  
  inputBuf = ""
  fmt.Printf("nirvash asset root? ")
  ensureNonEmptyOption(&inputBuf)
  cfg.AssetRoot = inputBuf
  
  inputBuf = ""
  fmt.Printf("plugins? (not implemented yet) ")
  ensureNonEmptyOption(&inputBuf)
  //cfg.Plugins = processPlugins(inputBuf)
  
  fmt.Printf("Configuration complete!\n")
  Write(cfg)
}

func ensureNonEmptyOption(buffer *string) {
  for ;; {
    fmt.Scanln(buffer)
    if len(strings.TrimSpace(*buffer)) != 0 {
      break
    }
  }
}

func writeConfig(cfg *Config, configFile string) error {
  f, err := os.Create(configFile)
  if err != nil {
    return err
  }
  
  defer f.Close()
  
  f.WriteString("root=" + cfg.Root + "\n")
  f.WriteString("staticRoot=" + cfg.StaticRoot + "\n")
  f.WriteString("assetRoot=" + cfg.AssetRoot + "\n")
  f.WriteString("adapter=" + cfg.Adapter.Name() + "\n")
  f.WriteString("plugins=\n")
  return nil
}

func parseConfig(configFile string) *Config {
  f, err := os.ReadFile(configFile)
  cfg := &Config{}
  if err != nil {
    return cfg
  }
  
  fileData := string(f[:])
  
  lines := strings.Split(fileData, "\n")
  
  for _, l := range lines {
    if len(l) == 0 {
      continue
    }
    if !strings.Contains(l, "=") {
      panic("Malformed config not in INI format")
    }
    
    kvp := strings.Split(l, "=")
    k := strings.TrimSpace(kvp[0])
    v := strings.TrimSpace(kvp[1])
    switch k {
    case "root":
      cfg.Root = v
    case "staticRoot":
      cfg.StaticRoot = v
    case "assetRoot":
      cfg.AssetRoot = v
    case "plugins":
      // not implemented
    case "adapter":
      SetAdapter(cfg, v)
    default:
      panic("Unrecognized config option: " + k)
    }
  }
  return cfg
}