package main

import (
	"embed"
	"os"
	"path/filepath"

	"go.wit.com/dev/alexflint/arg"
	"go.wit.com/gui"
	"go.wit.com/lib/gui/gowit"
	"go.wit.com/lib/gui/shell"
	"go.wit.com/log"
)

var VERSION string

//go:embed resources/*
var resources embed.FS

var myargs argv

func main() {
	me = new(autoType)

	// load the ~/.config/forge/ config
	if err := me.forge.ConfigLoad(); err != nil {
		log.Warn("forgepb.ConfigLoad() failed", err)
		os.Exit(-1)
	}

	// load the ~/.config/forge/ machine file from zoopb
	if err := me.machine.ConfigLoad(); err != nil {
		log.Warn("zoopb.ConfigLoad() failed", err)
		os.Exit(-1)
	}

	// parse the command line
	arg.MustParse(&myargs)

	// save the ENV var here
	me.releaseReasonS = os.Getenv("GUIRELEASE_REASON")

	if me.releaseReasonS == "" {
		log.Info("shell ENV GUIRELEASE_REASON not set")
		os.Exit(0)
	}

	// unset the go development ENV var to generate release files
	// this is required for go mod init & tidy. Also, if the
	// user drops to a shell or xterm, then they shouldn't be set there either
	os.Unsetenv("GO111MODULE")

	me.myGui = gui.New()
	me.myGui.InitEmbed(resources)
	me.myGui.Default()

	// our main window
	me.mainWindow = me.myGui.NewWindow("GUI release manager " + VERSION)
	me.mainBox = me.mainWindow.NewBox("bw hbox", true)

	// start the http server for polling status
	go startHTTP()

	// sanity check of things that might be around that mess
	// up things later
	// if you have a go.work file, you must delete it
	// TODO: check for go.work files anywhere
	homeDir, _ := os.UserHomeDir()
	gowork := filepath.Join(homeDir, "go/src/go.work")
	if shell.Exists(gowork) {
		log.Info("go.work must be deleted")
		os.Exit(0)
	}

	/*
		// sanity check of things that might be around that mess
		// up things later
		// check to make sure we have a go.sum here
		gosum := filepath.Join(homeDir, "go/src/go.wit.com/apps/guireleaser/go.sum")
		if !shell.Exists(gosum) {
			log.Info("go.sum must exist here")
			os.Exit(0)
		}
	*/

	log.Info("Creating the Release Window")

	// initialize the repo list window
	// which should be all the git repositories in ~/go/src & the .config file
	me.repos = makeRepoView()

	if myargs.DumpVersions {
		gowit.DumpVersions(me.repos.View)
		os.Exit(0)
	}
	// the left side of the window options
	globalDisplayOptions(me.mainBox)

	// create the right side of the main window
	createReleaseBox(me.mainBox)

	// disable the open repo button. this isn't really important
	// but does indicates the app (and toolkit) is working
	// this can be removed later, but in these early days, I'm using this
	// tool to release the code for this app, the gui and the gui toolkits
	// and sometimes they lie, don't display stuff, don't even disable things
	// so I can't trust even what I see. It's complicated right now still.
	me.release.openrepo.Disable()

	// disable the gui until the repos are scanned
	me.release.box.Disable()
	me.Disable()

	// parse config file and scan for .git repos
	me.repos.initRepoList()
	// setTargetVersion()

	// register a Show/Hide function for the repo list table
	me.repos.View.RegisterHideFunction(hideFunction)

	// scan in the State of all the repos
	// TODO: should not really be necessary directly after init()
	me.repos.View.ScanRepositories()


	loop := me.repos.View.ReposSortByName()
	for loop.Scan() {
		repo := loop.Repo()
		if me.forge.IsReadOnly(repo.GoPath()) {
			repo.Status.SetReadOnly(true)
		} else {
			repo.Status.SetReadOnly(false)
		}
		if me.forge.IsPrivate(repo.GoPath()) {
			repo.Status.SetPrivate(true)
		} else {
			repo.Status.SetPrivate(false)
		}
	}

	// the repo from the command line
	// var myrepo *repolist.RepoRow

	// find myself. the guireleaser directory is used as a working scratchpad
	// for running go commands that can mess up the go.* files
	loop = me.repos.View.ReposSortByName()
	for loop.Scan() {
		repo := loop.Repo()
		if repo.GoPath() == "go.wit.com/apps/guireleaser" {
			if me.release.guireleaser == nil {
				me.release.guireleaser = repo
			}
		}
		/*
			if repo.GoPath() == myargs.Repo {
				myrepo = repo
			}
		*/
	}

	if me.release.guireleaser == nil {
		log.Info("Can not release if guireleaser was not found")
		os.Exit(0)
	}
	me.Enable()

	// intermittently scans the status indefinitly
	me.repos.View.Watchdog(func() {
		log.Info("In main()")
		// processing is done. update the repo summary box
		// me.summary.Update()
	})
}

// start the initail scan and make sure each repo is set
// to the master branch
func setAllBranchesToMaster() bool {
	var worked bool = true
	loop := me.repos.View.ReposSortByName()
	for loop.Scan() {
		repo := loop.Repo()
		if repo.ReadOnly() {
			continue
		}
		if repo.IsDirty() {
			continue
		}
		if repo.Status.Whitelist {
			continue
		}
		if repo.Status.CheckoutMaster() {
			log.Warn("git checkout master branch worked", repo.Name())
		} else {
			log.Warn("git checkout master branch failed", repo.Name())
			worked = false
		}
		// repo.NewScan()
	}
	return worked
}