package fhelp

import (
	"os"
	"path/filepath"

	"go.wit.com/log"
)

// BEFORE YOU READ ANYTHING UNDERSTAND THIS IS THE DEFAULT:
//
// ~/.config/    # put things you might care about here
// ~/.cache/     # this is never imporant and can be deleted at any time
//
//
// Additionally:
//
//    NEVER WRITE OUT ANYTHING TO ~/   EVER. The ONLY DIRECTORIES YOU ARE EVER ALLOWED TO USE ARE ~/.config and ~/.cache/ (maybe ~/.local but really, why?)
//
// There are no exceptions to this unless you are a jerk or don't know better (in which you will be easily forgiven -- don't worry. there isn't a manual)
//
//
// ADVICE FOR ALL FUTURE PROGRAMMERS:
//
//
// Config files are a perfect way to stop things from proceeding. You do NOT want options in your programs. Configuration options, if you do
// things correctly, should never actually be needed. Nonetheless, there are initial states. ISOLATE ALL OPTIONS TO THE ITIAL STATES.
// then, never let anthing change anything. If your code is correct, then all is good.
//
//
// This defines the "default" behavior for forge when doing GO lang development
//
// Since this code is common, it's in a seperate package so it can be used elsewhere
//
// The default behavior is:
//
//   * If your current directory or parent directory has a go.work file, make that your default spot
//   * Otherwise, set the default to ~/go/src
//
// This routine ensures the following ENV vars are set:
//
// FORGE_CONFIG == where forge's configs are stored (normally ~/.config/forge)
// FORGE_REPOSPB == where the repos.pb protobuf cache file is stored (normally ~/.cache/forge/repos.pb)
// FORGE_GOSRC  == based on the path, what the user probably want for developing in GO (Defaults to ~/go/src)
// FORGE_GOWORK == true or false depending on the GOSRC result
//
// returns:
// string	# ~/go/src or the path to the go.work file
// bool	# true if the user is using a go.work file
// err	# if everything goes wrong, the error
//

func ConfigureENV() error {
	err := doConfigureENV()
	if os.Getenv("FORGE_VERBOSE") == "true" {
		DumpENV("fhelp:")
	}
	return err
}

func DumpENV(what string) {
	log.Printf("%s FORGE_CONFIG   = %s\n", what, os.Getenv("FORGE_CONFIG"))
	log.Printf("%s FORGE_REPOSDIR = %s\n", what, os.Getenv("FORGE_REPOSDIR"))
	log.Printf("%s FORGE_REPOSPB  = %s\n", what, os.Getenv("FORGE_REPOSPB"))
	log.Printf("%s FORGE_PATCHDIR = %s\n", what, os.Getenv("FORGE_PATCHDIR"))
	log.Printf("%s FORGE_URL      = %s\n", what, os.Getenv("FORGE_URL"))
	log.Printf("%s FORGE_GOWORK   = %s\n", what, os.Getenv("FORGE_GOWORK"))
	log.Printf("%s FORGE_VERBOSE  = %s\n", what, os.Getenv("FORGE_VERBOSE"))
	log.Printf("%s HOSTNAME       = %s\n", what, os.Getenv("HOSTNAME"))
}

// set the ENV vars
// always set them to _something_ even when everything seems to be failing
func doConfigureENV() error {
	var anyerr error
	if os.Getenv("FORGE_CONFIG") != "" {
		return nil
	}
	// setup the forge config dir
	if os.Getenv("FORGE_CONFIG") == "" {
		homeDir, err := getConfigDir()
		if err == nil {
			fullpath := filepath.Join(homeDir, ".config/forge")
			os.MkdirAll(fullpath, os.ModePerm)
			os.Setenv("FORGE_CONFIG", fullpath)
		} else {
			log.Info("user home dir error", err)
			os.Setenv("FORGE_CONFIG", "/tmp")
			anyerr = err
		}
	}

	if os.Getenv("FORGE_REPOSDIR") == "" {
		reposDir, err := getReposDir()
		if err != nil {
			return err
		}
		os.Setenv("FORGE_REPOSDIR", reposDir)
	}

	if os.Getenv("FORGE_REPOSPB") == "" {
		pbdir, err := getCacheDir()
		if err != nil {
			return err
		}
		os.Setenv("FORGE_REPOSPB", filepath.Join(pbdir, "repos.pb"))
	}

	if os.Getenv("FORGE_PATCHDIR") == "" {
		pbdir, err := getCacheDir()
		if err != nil {
			return err
		}
		os.Setenv("FORGE_PATCHDIR", pbdir)
	}

	// setting FORGE_URL
	if os.Getenv("FORGE_URL") == "" {
		os.Setenv("FORGE_URL", "https://forge.wit.com/")
	}

	// hostname is needed. allow ENV to pass it in
	if os.Getenv("HOSTNAME") == "" {
		if hname, err := os.Hostname(); err == nil {
			os.Setenv("HOSTNAME", hname)
		} else {
			os.Setenv("HOSTNAME", "unconfigured.hostname.forge")
		}
	}
	return anyerr
}

func getConfigDir() (string, error) {
	homeDir, err := os.UserHomeDir()
	if err != nil {
		return "/tmp", err
	}
	fullpath := filepath.Join(homeDir, ".config/forge")
	err = os.MkdirAll(fullpath, os.ModePerm)
	if err != nil {
		return "/tmp", err
	}

	return fullpath, nil
}

func getCacheDir() (string, error) {
	homeDir, err := os.UserHomeDir()
	if err != nil {
		return "/tmp", err
	}
	fullpath := filepath.Join(homeDir, ".cache/forge")
	err = os.MkdirAll(fullpath, os.ModePerm)
	if err != nil {
		return "/tmp", err
	}

	return fullpath, nil
}

func getReposDir() (string, error) {
	homeDir, err := os.UserHomeDir()
	if err != nil {
		return "/tmp", err
	}
	fullpath := filepath.Join(homeDir, "go/src")
	err = os.MkdirAll(fullpath, os.ModePerm)
	if err != nil {
		return "/tmp", err
	}

	return fullpath, nil
}

func getCachegDir() (string, error) {
	homeDir, err := os.UserHomeDir()
	if err != nil {
		return "/tmp", err
	}
	fullpath := filepath.Join(homeDir, ".cache/forge")
	err = os.MkdirAll(fullpath, os.ModePerm)
	if err != nil {
		return "/tmp", err
	}

	return fullpath, nil
}

// this is the 'old way" and works fine for me. I use it because I like the ~/go/src directory
// because I know exactly what is in it: GO stuff & nothing else
func useGoSrc() (string, error) {
	homeDir, err := os.UserHomeDir()
	if err != nil {
		return "", err
	}
	pwd := filepath.Join(homeDir, "go/src")
	err = os.MkdirAll(pwd, os.ModePerm)
	return pwd, err
}

func goWorkExists(dir string) bool {
	var err error
	workFilePath := filepath.Join(dir, "go.work")
	if _, err = os.Stat(workFilePath); err == nil {
		// log.Info("f.goWorkExists() found", workFilePath)
		return true
	} else if !os.IsNotExist(err) {
		// log.Info("f.goWorkExists() missing", workFilePath)
		return false
	}
	// probably false, but some other error
	// log.Info("f.goWorkExists() os.Stat() error", err, workFilePath)
	return false
}

// findGoWork searches for a "go.work" file starting from the current directory
// and moving up the directory tree. It returns the path to the directory containing
// the file and a boolean indicating whether the file was found.
func findGoWork() (string, bool) {
	dir, err := os.Getwd()
	if err != nil {
		return "", false
	}

	for {
		workFilePath := filepath.Join(dir, "go.work")
		if _, err := os.Stat(workFilePath); err == nil {
			return dir, true
		}
		parent := filepath.Dir(dir)
		if parent == dir {
			break // Reached root
		}
		dir = parent
	}

	return "", false
}