package main

import (
	"time"

	"go.wit.com/lib/gadgets"
	"go.wit.com/lib/gui/repolist"
	"go.wit.com/lib/gui/shell"
	"go.wit.com/log"

	"go.wit.com/gui"
)

type repoWindow struct {
	win         *gadgets.BasicWindow // the window widget itself
	box         *gui.Node            // notsure
	topbox      *gui.Node            // the top box of the repolist window
	mergeDevel  *gui.Node            // the buttton for merging user into devel
	mergeMaster *gui.Node            // the buttton for merging devel into master
	View        *repolist.RepoList   // old code
}

func (r *repoWindow) Hidden() bool {
	return r.win.Hidden()
}

func (r *repoWindow) Show() {
	r.win.Show()
	now := time.Now()

	// check for devel branches
	total, count, nope, _ := IsEverythingOnDevel()
	log.Printf("Devel branch check. %d total repos. (%d ok) (%d not on devel branch) (%s)\n", total, count, nope, shell.FormatDuration(time.Since(now)))
	if nope != 0 {
		r.mergeDevel.Disable()
	} else {
		// everything is on the devel branch
		r.mergeDevel.Enable()
	}

	// check for master branches
	total, count, nope, _ = IsEverythingOnMaster()
	log.Printf("Master branch check. %d total repos. (%d ok) (%d not on master branch) (%s)\n", total, count, nope, shell.FormatDuration(time.Since(now)))
	if nope != 0 {
		r.mergeMaster.Disable()
	} else {
		// everything is on the master branch
		r.mergeMaster.Enable()
	}
	log.Info("TODO: update the rows")
	loop := r.View.ReposSortByName()
	for loop.Scan() {
		// var repo *repolist.RepoRow
		view := loop.Repo()
		if view.Hidden() {
			continue
		}
		view.Update()
	}
}

func (r *repoWindow) Hide() {
	r.win.Hide()
}

func (r *repoWindow) Disable() {
	r.box.Disable()
}

func (r *repoWindow) Enable() {
	r.box.Enable()
}

// you can only have one of these
func makeRepoView() *repoWindow {
	r := new(repoWindow)
	r.win = gadgets.RawBasicWindow("All git repositories in ~/go/src/")
	r.win.Make()

	r.box = r.win.Box().NewBox("bw vbox", false)
	// me.reposwin.Draw()
	r.win.Custom = func() {
		log.Warn("Repo Window close. hidden=true")
		// sets the hidden flag to false so Toggle() works
		r.win.Hide()
	}

	r.topbox = r.repoMenu()

	r.View = repolist.InitBox(me.forge, r.box)
	r.View.Enable()

	// need to update this logic
	r.View.ScanRepositoriesOld()
	return r
}

func (r *repoWindow) repoMenu() *gui.Node {
	// reposbox.SetExpand(false)
	group1 := r.box.NewGroup("Filter:")

	hbox := group1.Box()
	// hbox.Horizontal()
	hbox.Vertical()

	box2 := hbox.Box().Horizontal()

	dirty := box2.NewCheckbox("dirty")
	dirty.Custom = func() {
		log.Info("filter dirty =", dirty.Checked())
	}

	r.mergeDevel = box2.NewButton("merge to devel", func() {
		r.Disable()
		defer r.Enable()
		loop := r.View.ReposSortByName()
		for loop.Scan() {
			// var repo *repolist.RepoRow
			view := loop.Repo()
			if view.Hidden() {
				continue
			}
			repo := view.GetPb()
			log.Info("repo:", repo.GetGoPath())
			if result, err := repo.MergeToDevel(); err == nil {
				log.Warn("THINGS SEEM OK", repo.GetFullPath())
			} else {
				log.Warn("THINGS FAILED ", repo.GetFullPath())
				log.Warn("err", err)
				for _, line := range result.Stdout {
					log.Warn("stdout:", line)
				}
				for _, line := range result.Stderr {
					log.Warn("stderr:", line)
				}
				break
			}
			me.forge.SetConfigSave(true)
			repo.Reload() // move this to gitpb
			view.Update()
		}
		me.forge.ConfigSave()
	})

	r.mergeMaster = box2.NewButton("merge to master", func() {
		r.Disable()
		// r.mergeAllDevelToMain()
		r.Enable()
	})

	/*
		box2.NewButton("show apps", func() {
			loop := me.repos.View.ReposSortByName()
			for loop.Scan() {
				var repo *repolist.RepoRow
				repo = loop.Repo()
				if repo.IsBinary() {
					// log.Info(repo.Status.Path(), "compile here. Show()")
					repo.Show()
				} else {
					// log.Info(repo.Status.Path(), "library here. Hide()")
					repo.Hide()
				}
			}
		})
	*/
	/*
		box2.NewButton("Table()", func() {
			me.found = new(gitpb.Repos)
			loop := me.forge.Repos.All()
			for loop.Scan() {
				repo := loop.Next()
				me.found.AppendByGoPath(repo)
			}
			me.forge.PrintHumanTable(me.found)
		})
			box2.NewButton("Prep for release()", func() {
				r.Disable()
				defer r.Enable()
				if IsAnythingDirty() {
					log.Info("You can't apply patches when repos are dirty")
					me.forge.PrintHumanTable(me.found)
					return
				}
				if !r.mergeAllUserToDevel() {
					return
				}
				if !r.mergeAllDevelToMain() {
					return
				}
				doAllCheckoutMaster()
				os.Exit(0)

			})
	*/

	return box2
}

/*
func (r *repoWindow) mergeAllDevelToMain() bool {
	var count int
	log.Info("merge all here")
	loop := me.forge.Repos.All()
	for loop.Scan() {
		repo := loop.Next()
		if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
			log.Info("skipping readonly", repo.GetFullPath())
			continue
		}
		if repo.IsDirty() {
			log.Info("skipping dirty", repo.GetFullPath())
			continue
		}
		if repo.GetDevelVersion() != repo.GetUserVersion() {
			log.Info("devel and user branch are different", repo.GetFullPath())
			continue
		}
		if repo.GetDevelVersion() == repo.GetMasterVersion() {
			log.Info("devel and master branch are the same", repo.GetFullPath())
			continue
		}
		count += 1
		if result, err := repo.MergeDevelToMaster(); err == nil {
			log.Warn("MERGE WORKED", repo.GetFullPath())
			repo.Reload()
			vrepo := me.repos.View.FindByPath(repo.GetGoPath())
			if vrepo != nil {
				vrepo.UpdatePb(repo)
				vrepo.NewScan()
			}
			me.forge.SetConfigSave(true)
			// continue
			continue
		} else {
			log.Warn("THINGS FAILED ", repo.GetFullPath())
			log.Warn("err", err)
			for _, line := range result.Stdout {
				log.Warn("stdout:", line)
			}
			for _, line := range result.Stderr {
				log.Warn("stderr:", line)
			}
			return false
		}
	}
	log.Warn("EVERYTHING WORKED count =", count)
	return true
}

func (r *repoWindow) mergeAllUserToDevel() bool {
	log.Info("merge all here")
	loop := me.forge.Repos.All()
	for loop.Scan() {
		repo := loop.Next()
		if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
			// log.Info("skipping readonly", repo.GetFullPath())
			continue
		}
		if repo.IsDirty() {
			log.Info("skipping dirty", repo.GetFullPath())
			continue
		}
		if repo.GetCurrentBranchName() != repo.GetUserBranchName() {
			log.Info("not on user branch", repo.GetFullPath())
			continue
		}
		if repo.GetDevelVersion() == repo.GetUserVersion() {
			log.Info("devel and user branch are the same", repo.GetFullPath())
			continue
		}
		if result, err := repo.MergeUserToDevel(); err == nil {
			log.Warn("THINGS SEEM OK", repo.GetFullPath())
			repo.Reload()
			vrepo := me.repos.View.FindByPath(repo.GetGoPath())
			if vrepo != nil {
				vrepo.UpdatePb(repo)
				vrepo.NewScan()
			}
			me.forge.SetConfigSave(true)
			continue
		} else {
			log.Warn("THINGS FAILED ", repo.GetFullPath())
			log.Warn("err", err)
			for _, line := range result.Stdout {
				log.Warn("stdout:", line)
			}
			for _, line := range result.Stderr {
				log.Warn("stderr:", line)
			}
			return false
		}
	}
	log.Warn("EVERYTHING WORKED")
	return true
}
*/