package archetype

import (
	"fmt"
	"os"
	"path/filepath"
	"runtime"
	"strings"
)

type Config struct {
	Adapter          Adapter // adapter for this instance
	Root             string  // root of the site data
	StaticRoot       string  // root of static files for StaticFileManager
	StaticShowHidden bool    // whether to show hidden files in the StaticFileManager
	StaticShowHtml   bool    // whether to show html files in the 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() {
	fileInfo, err := os.Stat(GetConfigLocation())

	if os.IsNotExist(err) {
		os.MkdirAll(GetConfigLocation(), os.ModePerm)
	} else if !fileInfo.IsDir() {
		panic("Config location is not a directory!")
	}
}

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

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

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

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

func (self *Config) RunWizard() {
	fmt.Printf("All options are required.\n")
	defer func(cfg *Config) {
		if r := recover(); r != nil {
			fmt.Printf("Invalid selection, starting over...")
			cfg.RunWizard()
		}
	}(self)
	inputBuf := ""
	fmt.Printf("adapter? (eureka) [eureka] ")
	fmt.Scanln(&inputBuf)
	if len(strings.TrimSpace(inputBuf)) == 0 {
		inputBuf = "eureka"
	}
	self.SetAdapter(inputBuf)

	inputBuf = ""
	fmt.Printf("site data root? ")
	ensureNonEmptyOption(&inputBuf)
	self.Root = inputBuf

	inputBuf = ""

	fmt.Printf("static file root? ")
	ensureNonEmptyOption(&inputBuf)
	self.StaticRoot = inputBuf

	inputBuf = ""
	fmt.Printf("nirvash asset root? ")
	ensureNonEmptyOption(&inputBuf)
	self.AssetRoot = inputBuf

	inputBuf = ""
	fmt.Printf("plugins? (not implemented yet) ")
	ensureNonEmptyOption(&inputBuf)
	//self.Plugins = processPlugins(inputBuf)

	fmt.Printf("Configuration complete!\n")
	self.Write()
}

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":
			cfg.SetAdapter(v)
		default:
			panic("Unrecognized config option: " + k)
		}
	}
	return cfg
}