// This is a simple example
package main

import (
	"errors"
	"fmt"
	"os"
	"path/filepath"

	"go.wit.com/log"

	"go.wit.com/lib/gui/shell"
	"go.wit.com/lib/protobuf/gitpb"
)

var findCounter int
var findFix bool = false
var findOk bool = true

func checkpkgcache(repo *gitpb.Repo) error {
	homedir, err := os.UserHomeDir()
	if err != nil {
		return err
	}
	rver := repo.GetLastTag()
	if rver == "" {
		return errors.New("could not get master version")
	}
	moddir := filepath.Join(homedir, "go/pkg/mod", repo.GetGoPath()+"@"+rver)
	if shell.IsDir(moddir) {
		return nil
	}

	getpath := repo.GetGoPath() + "@" + repo.GetLastTag()
	_, err = me.startRepo.RunVerbose([]string{"go", "get", getpath})
	return err
}

func rillRestore(repo *gitpb.Repo) error {
	if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
		return nil
	}
	if me.forge.Config.IsPrivate(repo.GetGoPath()) {
		return nil
	}
	if err := checkpkgcache(repo); err != nil {
		return err
	}
	_, err := repo.RunVerboseOnError([]string{"go-mod-clean", "--restore"})
	if err != nil {
		return err
	}
	log.Info("go-mod-clean restore worked ", repo.GetGoPath())
	return nil
}

func slowRestore() error {
	all := me.forge.Repos.All()
	for all.Scan() {
		repo := all.Next()
		if err := rillRestore(repo); err != nil {
			badExit(err)
		}
		if repo.ParseGoSum() {
			log.Info("go-mod-clean and parse worked", repo.GetGoPath())
			return nil
		}
	}
	return nil
}

func checkDeps(repo *gitpb.Repo) error {
	if repo.GoDeps == nil {
		return fmt.Errorf("%s has GoDeps == nil", repo.GetGoPath())
	}
	all := repo.GoDeps.All()
	for all.Scan() {
		dep := all.Next()
		// log.Info(repo.GetGoPath(), dep.GoPath, dep.Version)

		// check if the package in question is waiting for another package to publish
		found := me.forge.FindByGoPath(dep.GoPath)
		if found == nil {
			return fmt.Errorf("%s has dep == nil", repo.GetGoPath(), dep.GoPath)
		}
		all := me.found.SortByFullPath()
		for all.Scan() {
			check := all.Next()
			if found.GetGoPath() == check.GetGoPath() {
				// this package is waiting on other packages to publish
				return fmt.Errorf("%s is waiting on %s", repo.GetGoPath(), found.GetGoPath())
			}
		}
		// found package isn't being published. is the version correct?
		// never check this? we are done?
		/*
			if found.GetLastTag() == dep.Version {
				// everything is normal
			} else {
				return fmt.Errorf("%s version mismatch on %s (%s vs %s)", repo.GetGoPath(), found.GetGoPath(), found.GetLastTag(), dep.Version)
			}
		*/
	}
	// everything might be cool?
	return nil
}

// trys to figure out if there is still something to update
// todo: redo this logic as it is terrible
// rename this findNext()
func findNext() bool {
	findCounter = 0
	all := me.found.SortByFullPath()
	for all.Scan() {
		check := all.Next()
		if err := checkDeps(check); err != nil {
			log.Info("\t", check.GetGoPath(), err)
			continue
		} else {
			log.Info("Might be ok?", check.GetGoPath())
		}
		if check.GetMasterBranchName() != check.GetCurrentBranchName() {
			log.Info("YOU MUST BE ON THE MASTER BRANCHES")
			os.Exit(-1)
		}
		_, err := check.RunVerboseOnError([]string{"go-mod-clean", "--strict"})
		if err != nil {
			os.Exit(-1)
		}

		if check.IsDirty() {
			log.Info("findNext() skipping dirty")
			continue
		}
		findCounter += 1
		if !check.ParseGoSum() {
			log.Info("ParseGoSum() failed")
			log.Info("ParseGoSum() failed")
			log.Info("ParseGoSum() failed")
			continue
		}
		if me.forge.FinalGoDepsCheckOk(check, false) {
			setCurrentRepo(check, "should be good to release", "pretty sure")
			return true
		} else {
			log.Info("FinalGoDepsCheckOk() failed")
			log.Info("FinalGoDepsCheckOk() failed")
			log.Info("FinalGoDepsCheckOk() failed")
		}
		log.Info("findNext() got to the end. repo", check.GetGoPath(), "did not work. trying to find a new one now")
	}
	if findCounter == 0 {
		log.Info("NOTHING TO UPDATE. findCounter =", findCounter)
	} else {
		findFix = true
		log.Info("me.current is nil findCounter =", findCounter, "so set findFix =", findFix)
	}
	log.Info("tried to findNext() but not sure what to do next counter =", findCounter, "findFix =", findFix)
	me.release.status.SetText("ALL DONE?")
	return false
}

func runGoClean(check *gitpb.Repo, myarg string) bool {
	// check if the package dependancies changed, if so, re-publish
	check.GoDeps = nil

	cmd := []string{"go-mod-clean", myarg}
	// log.Info("Running", cmd, "in", check.GetGoPath())
	result := check.Run(cmd)
	if result.Error != nil {
		/*
			log.Info(cmd, "failed with", result.Error, check.GetGoPath())
			log.Info("STDOUT")
			log.Info(strings.Join(result.Stdout, "\n"))
			log.Info("STDERR")
			log.Info(strings.Join(result.Stderr, "\n"))
		*/
		return false
	}
	if result.Exit != 0 {
		/*
			log.Info(cmd, "failed with", result.Exit, check.GetGoPath())
			log.Info("STDOUT")
			log.Info(strings.Join(result.Stdout, "\n"))
			log.Info("STDERR")
			log.Info(strings.Join(result.Stderr, "\n"))
		*/
		return false
	}
	if check.ParseGoSum() {
		return true
	}
	log.Info("ParseGoSum() failed", check.GetGoPath())
	return false
}

// tries to fix the go.mod and go.sum files
func fixGodeps(check *gitpb.Repo) bool {
	log.Info("fixGoDeps() START", check.GetGoPath())
	log.Info("fixGoDeps() START", check.GetGoPath())
	log.Info("fixGoDeps() START", check.GetGoPath())
	var good bool = true
	if !runGoClean(check, "--strict") {
		log.Info("fixGoDeps() runGoClean() strict failed", check.GetGoPath())
		log.Info("fixGoDeps() runGoClean() strict failed", check.GetGoPath())
		log.Info("fixGoDeps() runGoClean() strict failed", check.GetGoPath())
		return false
	}
	// skip primative ones
	if check.GetGoPrimitive() {
		if check.Exists("go.sum") {
			log.Info("fixGoDeps() has go.sum but says it is primitive", check.GetGoPath())
			return false
		}
		log.Info("fixGoDeps() skipping primitive", check.GetGoPath())
		return true
	}
	log.Printf("current repo %s go dependancy count: %d\n", check.GetGoPath(), check.GoDepsLen())
	log.Printf("current repo %s go dependancy count: %d\n", check.GetGoPath(), check.GoDepsLen())
	log.Printf("current repo %s go dependancy count: %d\n", check.GetGoPath(), check.GoDepsLen())
	deps := check.GoDeps.SortByGoPath()
	for deps.Scan() {
		depRepo := deps.Next()
		// log.Info("found dep", depRepo.GetGoPath())
		if me.forge.Config.IsReadOnly(depRepo.GetGoPath()) {
			log.Info("IsReadOnly = true", depRepo.GetGoPath())
			continue
		} else {
			// log.Info("IsReadOnly = false", depRepo.GetGoPath())
		}
		found := me.forge.FindByGoPath(depRepo.GetGoPath())
		if found == nil {
			log.Info("not found:", depRepo.GetGoPath())
			continue
		}
		log.Printf("%-48s  dep ver=%10s repo ver=%10s target ver=%10s\n", found.GetGoPath(), depRepo.GetVersion(), found.GetMasterVersion(), found.GetTargetVersion())
		if depRepo.GetVersion() != found.GetMasterVersion() {
			log.Printf("%-48s  %10s (gitpb depRepo)\n", depRepo.GetGoPath(), depRepo.GetVersion())
			log.Printf("%-48s  %10s (gitpb found)\n", found.GetGoPath(), found.GetMasterVersion())
			cmd := []string{"go", "get", depRepo.GetGoPath() + "@latest"}
			check.RunVerbose(cmd)
		}
	}
	return good
}

func setCurrentRepo(check *gitpb.Repo, s string, note string) bool {
	me.release.repo.SetText(check.GetGoPath())
	me.release.status.SetText(s)
	me.release.notes.SetText(note)
	me.current = check
	me.release.version.SetText(check.GetTargetVersion())
	me.release.releaseVersionB.SetText("release version " + check.GetTargetVersion())
	me.release.openrepo.Enable()

	return true
}