package repostatus

import 	(
	"strconv"
	"strings"

	"go.wit.com/log"
	"go.wit.com/gui/gadgets"
)

// creates the actual widgets.
// it's assumed you are always passing in a box
func draw(rs *RepoStatus) {
	if ! rs.Ready() {return}
	rs.group = rs.window.Box().NewGroup("What GO Knows It Has")
	rs.grid = rs.group.NewGrid("gridnuts", 2, 2)
	rs.grid.SetNext(1,1)
	rs.grid.Margin()
	rs.grid.Pad()

	rs.path			= gadgets.NewOneLiner(rs.grid, "path")
	rs.currentBranch	= gadgets.NewOneLiner(rs.grid, "branch")
	rs.lasttag		= gadgets.NewOneLiner(rs.grid, "last tag")
	rs.currentVersion	= gadgets.NewOneLiner(rs.grid, "Version")
	rs.tagsDrop		= gadgets.NewBasicDropdown(rs.grid, "existing tags")
	rs.masterBranch		= gadgets.NewOneLiner(rs.grid, "master")
	rs.develBranch		= gadgets.NewOneLiner(rs.grid, "devel")
	rs.jcarrBranch		= gadgets.NewOneLiner(rs.grid, "jcarr")

	rs.dirtyLabel	= gadgets.NewOneLiner(rs.grid, "dirty")

	rs.speed	= gadgets.NewOneLiner(rs.grid, "refresh speed =")
	rs.speedActual	= gadgets.NewOneLiner(rs.grid, "speed actual =")

	rs.vgroup = rs.window.Box().NewGroup("git commands")
	newgrid := rs.vgroup.NewGrid("gridnuts", 2, 2)

	newgrid.NewButton("update", func() {
		rs.Update()
	})

	rs.develMerge = newgrid.NewButton("merge devel to master", func() {
		rs.checkoutBranch("master")
		if rs.getCurrentBranchName() != "master" {
			log.Warn("something went wrong switching to the master branch. full stop!")
			return
		}
		log.Warn("Should merge devel into master here")
		out := run(rs.repopath, "git", "merge devel")
		log.Warn("devel is merged? merginess is complete. perhaps", out)
		rs.develMerge.Disable() // don't let this run twice for now
	})

	rs.major = gadgets.NewBasicCombobox(newgrid, "master")
	rs.major.Custom = func () {
		rs.setTag()
		rs.generateCmd()
	}
	rs.minor = gadgets.NewBasicCombobox(newgrid, "minor")
	rs.minor.Custom = func () {
		rs.setTag()
		rs.generateCmd()
	}
	rs.revision = gadgets.NewBasicCombobox(newgrid, "revision")
	rs.revision.Custom = func () {
		rs.setTag()
		rs.generateCmd()
	}
	newgrid.NewLabel("new tag version")
	rs.newversion = newgrid.NewLabel("3.1.4")

	rs.versionMessage = gadgets.NewBasicEntry(newgrid, "tag message")
	rs.versionMessage.Custom = func () {
		rs.generateCmd()
	}
	rs.versionCmdOutput = gadgets.NewOneLiner(newgrid, "tag cmd")

	rs.releaseVersion = newgrid.NewButton("tag and release new version", func() {
		if ! rs.generateCmd() {
			log.Warn("something is wrong. fix the errors first")
			return
		}
		log.Warn("COMMIT IT HERE")
		rs.runGitCommands()
	})

	newgrid.Margin()
	newgrid.Pad()

	// figure out what the state of the git repository is
	rs.Update()
}

func (rs *RepoStatus) setTag() bool {
	lasttag := rs.lasttag.Get()
	var major, minor, revision string
	major, minor, revision = splitVersion(lasttag)

	olda, _ := strconv.Atoi(major)
	oldb, _ := strconv.Atoi(minor)
	oldc, _ := strconv.Atoi(revision)

	log.Warn("current version here", lasttag)
	log.Warn("current release a,b,c =", major, minor, revision)

	newa, _ := strconv.Atoi(rs.major.Get())
	newb, _ := strconv.Atoi(rs.minor.Get())
	newc, _ := strconv.Atoi(rs.revision.Get())

	newver := strconv.Itoa(newa)
	if newa < olda {
		log.Warn("new version bad", newver, "vs old version", lasttag)
		rs.newversion.Set("bad")
		return false
	}
	if newa > olda {
		log.Warn("new version ok", newver, "vs old version", lasttag)
		rs.newversion.Set(newver)
		rs.minor.Set("")
		rs.revision.Set("")
		return true
	}

	newver = strconv.Itoa(newa) + "." + strconv.Itoa(newb)
	if newb < oldb {
		log.Warn("new version bad", newver, "vs old version", lasttag)
		rs.newversion.Set("bad")
		return false
	}

	if newb > oldb {
		log.Warn("new version ok", newver, "vs old version", lasttag)
		rs.newversion.Set(newver)
		rs.revision.Set("")
		return true
	}

	newver = strconv.Itoa(newa) + "." + strconv.Itoa(newb) + "." + strconv.Itoa(newc)
	if newc <= oldc {
		log.Warn("new version bad", newver, "vs old version", lasttag)
		rs.newversion.Set("bad")
		return false
	}
	log.Warn("new version ok", newver, "vs old version", lasttag)
	rs.newversion.Set(newver)
	return true
}

func (rs *RepoStatus) incrementVersion() {
	lasttag := rs.lasttag.Get()
	var major, minor, revision string
	major, minor, revision = splitVersion(lasttag)
	log.Warn("Should release version here", lasttag)
	log.Warn("Should release a,b,c", major, minor, revision)

	a, _ := strconv.Atoi(major)
	b, _ := strconv.Atoi(minor)
	c, _ := strconv.Atoi(revision)

	rs.major.Add(a)
	rs.major.Add(a + 1)
	rs.major.Set(a)

	rs.minor.Add(b)
	rs.minor.Add(b + 1)
	rs.minor.Set(b)

	// rs.c := strconv.Atoi(revision)
	rs.revision.Add(c + 1)
	rs.revision.Add(c + 2)
	rs.revision.Set(c + 1)
}

func (rs *RepoStatus) recommend() {
	log.Warn("Is repo dirty?", rs.dirtyLabel.Get())
	log.Warn("list the known tags")
	rs.DisableEverything()
	rs.populateTags()
	log.Warn("Does devel == jcarr?", rs.develBranch.Get(), rs.jcarrBranch.Get())
	if rs.develBranch.Get() != rs.jcarrBranch.Get() {
		log.Warn("devel does not equal jcarr")
		log.Warn("merge or squash?")
		return
	}
	log.Warn("Does master == devel? ", rs.masterBranch.Get(), rs.develBranch.Get())
	if rs.masterBranch.Get() != rs.develBranch.Get() {
		log.Warn("master does not equal devel. merge devel into master")
		rs.EnableMergeDevel()
		return
	}
	rs.getLastTagVersion()
	if rs.lasttag.Get() != rs.masterBranch.Get() {
		log.Warn("master does not equal last tag")
		rs.incrementVersion()
		rs.EnableSelectTag()
		rs.setTag()
		return
	}
	log.Warn("Is repo pushed upstream? git.wit.org or github?")
}

func (rs *RepoStatus) generateCmd() bool {
	// the length of 24 is arbitrary, but should be short
	// they should be things like perhaps, major release names
	// or something the users might see.
	// aka: "Topsy", "Picasso", "Buzz", etc

	if ! rs.setTag() {
		log.Warn("tag sucked. fix your tag version")
		rs.versionMessage.SetLabel("tag message (bad version)")
		rs.releaseVersion.Disable()
		return false
	}

	log.Warn("tag is valid!!!!")
	rs.setGitCommands()

	if rs.versionMessage.Get() == "" {
		log.Warn("tag message is empty!!!!")
		rs.releaseVersion.Disable()
		return false
	}
	if len(rs.versionMessage.Get()) > 24 {
		rs.versionMessage.SetLabel("tag message (too long)")
	} else {
		rs.versionMessage.SetLabel("tag message")
	}
	rs.releaseVersion.Enable()
	return true
}

func (rs *RepoStatus) setGitCommands() {
	var line1, line2, line3 []string
	var all [][]string

	newTag := rs.newversion.GetText()
	line1 = append(line1, "git", "tag", "v" + newTag, "-m", rs.versionMessage.Get())
	all = append(all, line1)
	line2 = append(line2, "git", "push", "--tags")
	all = append(all, line2)
	line3 = append(line3, "git", "push", "--prune", "--tags")
	all = append(all, line3)

	rs.versionCmds = all

	var tmp []string
	// convert to displayable to the user text
	for _, line := range all {
		s := strings.Join(line, " ")
		log.Warn("s =", s)
		tmp = append(tmp, s)
	}

	rs.versionCmdOutput.Set(strings.Join(tmp, "\n"))
}
func (rs *RepoStatus) runGitCommands() {
	for _, line := range rs.versionCmds {
		s := strings.Join(line, " ")
		log.Warn("NEED TO RUN:", s)
		b, output := runCmd(rs.repopath, line)
		log.Warn("Returned with b =", b)
		log.Warn("output was =", output)
		log.Warn("RUN DONE")
	}
}