// 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 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 check.GetMasterBranchName() != check.GetCurrentBranchName() {
			log.Info("YOU MUST BE ON THE MASTER BRANCH", check.GetGoPath())
			continue
		}
		if check.IsDirty() {
			log.Info("CAN NOT RELEASE DIRTY REPO", check.GetGoPath())
			continue
		}
		if alreadyDone(check) {
			log.Info("findNext() alreadyDone. WHY IS THIS STILL CHECKING?", check.GetGoPath())
			continue
		}
		log.Info("CHECKING START:", check.GetGoPath())

		if me.forge.Config.IsPrivate(check.GetGoPath()) {
			log.Info("GOOD TO GO ON PRIVATE REPO", check.GetGoPath())
			setCurrentRepo(check, "should be good to release", "pretty sure")
			return true
		}

		godepsNew, err := check.GoSumFromRepo()
		if err != nil {
			log.Info("CHECKING go deps from repo failed", err)
			continue

		}
		if godepsNew == nil {
			// don't check godepsNew, but check to make sure go mod tidy actually ran without error
			os.Unsetenv("GO111MODULE")
			cmd := []string{"go", "mod", "tidy"}
			err := check.RunVerbose(cmd)
			if err != nil {
				log.Info("go mod tidy failed. this go package needs to be examined by hand as it doesn't appear to be primitive")
				os.Exit(-1)
			}
			// if godepsNew == nil, then this go package is a primitive and there is no go.sum file
		} else {
			if err := testGoDepsCheckOk(godepsNew, argv.Verbose); err != nil {
				log.Info("CHECKING current repo deps failed", err)
				continue
			}
		}

		if err := me.forge.FinalGoDepsCheckOk(check, argv.Verbose); err != nil {
			// if err := me.forge.FinalGoDepsCheckOk(check, false); err != nil {
			log.Info("FinalGoDepsCheckOk() repo=", check.GetGoPath(), "err:", err)
			log.Info("CHECKING END:", check.GetGoPath())
			log.Info("")
			continue
		}
		log.Info("GOOD TO GO ON", check.GetGoPath())
		setCurrentRepo(check, "should be good to release", "pretty sure")
		return true
	}
	if findCounter == 0 {
		log.Info("NOTHING TO UPDATE. findCounter =", findCounter, "found len =", me.found.Len())
		if me.found.Len() == 0 {
			printDone()
			log.Info("cd lib/; make debian")
			wit := me.forge.FindByGoPath("go.wit.com/apps/utils/wit-test")
			if wit != nil {
				log.Info("cd", wit.GetFullPath())
				os.Chdir(wit.GetFullPath())
				shell.Exec([]string{"ls", "-l"})
				shell.Exec([]string{"make", "debian-release-force"})
			}
			okExit("")
		}
	} else {
		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)
	setCurrentRepo(nil, "findNext found nothing", "crap")
	me.release.status.SetText("ALL DONE?")
	return false
}

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

	return true
}

func testGoDepsCheckOk(godeps *gitpb.GoDeps, verbose bool) error {
	if godeps == nil {
		return errors.New("testGoDepsCheckOk() godeps == nil")
	}
	all := godeps.SortByGoPath()
	for all.Scan() {
		depRepo := all.Next()
		fullpath := filepath.Join(me.forge.GetGoSrc(), depRepo.GetGoPath())
		found := me.found.FindByFullPath(fullpath)
		if found == nil {
			continue
		}
		return fmt.Errorf("dep is being upgraded %s", depRepo.GetGoPath())
	}
	return nil
}