package gowit

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"time"

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

	"go.wit.com/lib/gadgets"
	"go.wit.com/lib/gui/repolist"
	"go.wit.com/lib/gui/repostatus"
	"go.wit.com/lib/gui/shell"
)

var lw *gadgets.BasicWindow

var allsections []*section

type witRepo struct {
	hidden     bool
	sec        *section
	path       *gui.Node
	downloadB  *gui.Node
	configureB *gui.Node
}

func (w *witRepo) Show() {
	w.hidden = false
	w.path.Show()
	w.downloadB.Show()
	w.configureB.Show()
}

func (w *witRepo) Hide() {
	w.hidden = true
	w.path.Hide()
	w.downloadB.Hide()
	w.configureB.Hide()
}

type section struct {
	name   string
	hidden bool

	parent       *gui.Node
	box          *gui.Node
	group        *gui.Node
	grid         *gui.Node // where the repos are listed
	hideCB       *gui.Node
	downloadAllB *gui.Node
	witRepos     []*witRepo
}

func CheckRegistered(rs *repostatus.RepoStatus) (bool, string) {
	var found bool = false
	var source string
	url := "https://" + rs.String()
	lines := dumpURL(url)
	for _, line := range lines {
		// log.Info("HTTP:", i, line)
		if strings.Contains(line, "\"go-import\"") {
			line = strings.TrimSuffix(line, "\">")
			parts := strings.Split(line, " ")
			source = parts[len(parts)-1]
			// log.Verbose("FOUND IMPORT:", i, source)
			found = true
		}
	}
	return found, source
}

func myrepolist(cfgfile string) []string {
	homeDir, _ := os.UserHomeDir()
	cfgfile = filepath.Join(homeDir, cfgfile)
	content, _ := ioutil.ReadFile(cfgfile)
	out := string(content)
	out = strings.TrimSpace(out)
	lines := strings.Split(out, "\n")
	return lines
}

func ListWindow(view *repolist.RepoList) *gadgets.BasicWindow {
	if lw != nil {
		if lw.Hidden() {
			lw.Show()
		} else {
			lw.Hide()
		}
		return lw
	}
	lw = gadgets.RawBasicWindow("go.wit.com repositories")
	lw.Custom = func() {
		log.Warn("got to close")
	}
	lw.Make()
	box := lw.Box()
	group := box.NewGroup("list")
	group.NewButton("make new go version list", func() {
		DumpVersions(view)
	})

	var lines []string
	var currents *section

	currents = NewSection(group, "local "+view.Cfgfile())
	for i, line := range myrepolist(view.Cfgfile()) {
		line = strings.TrimSpace(line)
		if line == "" {
			// skip blank lines
			continue
		}
		if strings.HasPrefix(line, "#") {
			// skip comment lines
			continue
		}
		parts := strings.Split(line, " ")
		log.Info("adding:", i, parts)
		currents.add(view, parts[0])
	}

	lines = dumpURL("https://go.wit.com/list")
	for i, line := range lines {
		if line == "" {
			continue
		}
		if line[0] == '#' {
			currents = NewSection(group, line)
			log.Warn("new group:", line)
			continue
		}
		log.Warn(i, line)
		parts := strings.Split(line, " ")
		if currents != nil {
			currents.add(view, parts[0])
		}
	}
	for i, sec := range allsections {
		log.Info("section name:", sec.name, "hidden:", sec.hidden, i)
		parts := strings.Split(sec.name, " ")
		if len(parts) > 1 {
			if parts[1] == "Applications" {
				// leave expanded
			} else if parts[0] == "local" {
				// leave expanded
			} else {
				sec.Hide()
			}
		}
	}
	return lw
}

func downloadRepo(path string) bool {
	log.Info("downloading", path, "here")
	os.Setenv("GO111MODULE", "off")

	homeDir, _ := os.UserHomeDir()
	goSrcDir := filepath.Join(homeDir, "go/src")

	cmd :=  []string{"go-clone", "--recursive", "--no-work", "--go-src", path}
	r := shell.PathRun(goSrcDir, cmd)
	if r.Error != nil {
		log.Info("go-clone failed error", r.Error)
		return false
	}
	log.Info("go-clone worked")
	return true
}

func (r *witRepo) doDownload() bool {
	/*
		if me.autoDryRun.Checked() {
			r.downloadB.SetLabel("uncheck --dry-run")
			return false
		}
	*/
	if r.downloadB.String() == "downloaded" {
		log.Info("skipping already downloaded", r.path.String())
		r.downloadB.Disable()
		return true
	}
	if downloadRepo(r.path.String()) {
		log.Info("download", r.path.String(), "worked")
		r.downloadB.SetLabel("downloaded")
		r.downloadB.Disable()
	} else {
		r.downloadB.SetLabel("failed")
		log.Info("download", r.path.String(), "failed")
		return false
	}
	return true
}

func (s *section) add(view *repolist.RepoList, path string) {
	if s == nil {
		return
	}
	tmp := new(witRepo)
	tmp.sec = s
	tmp.path = s.grid.NewLabel(path)
	tmp.downloadB = s.grid.NewButton("download", func() {
		lw.Disable()
		tmp.doDownload()
		lw.Enable()
	})
	repo := view.FindRepo(path)
	if repo != nil {
		log.Verbose("repo is already downloaded", path)
		tmp.downloadB.SetLabel("downloaded")
		tmp.downloadB.Disable()
		tmp.configureB = s.grid.NewButton("Configure", func() {
			log.Log(WIT, "todo: open the repo window here")
		})
	}

	s.grid.NextRow()
	s.witRepos = append(s.witRepos, tmp)
}

func NewSection(parent *gui.Node, desc string) *section {
	news := new(section)
	news.name = desc
	news.parent = parent
	news.box = news.parent.NewBox("bw vbox", true)
	news.group = news.box.NewGroup(desc)
	news.hideCB = news.box.NewCheckbox("hide")
	news.hideCB.Custom = func() {
		news.toggle()
	}
	news.downloadAllB = news.box.NewButton("download all", func() {
		lw.Disable()
		log.Warn("Download all here")
		for i, wrepo := range news.witRepos {
			log.Warn("download:", i, wrepo.path.String())
			wrepo.doDownload()
		}
		lw.Enable()
	})
	news.grid = news.parent.NewGrid("sections", 0, 0)
	allsections = append(allsections, news)
	return news
}

func (s *section) toggle() {
	log.Warn(s.name)
	if s.hidden {
		s.hidden = false
		for i, wrepo := range s.witRepos {
			log.Warn(i, wrepo.path.String())
			wrepo.Show()
		}
	} else {
		s.Hide()
	}
}

func (s *section) Hide() {
	s.hidden = true
	s.hideCB.SetChecked(true)
	for i, wrepo := range s.witRepos {
		log.Warn(i, wrepo.path.String())
		wrepo.Hide()
	}
}

/*
func dumpURL(url string) string {
	resp, err := http.Get(url)
	if err != nil {
		return ""
	}
	defer resp.Body.Close()

	return resp.Body.String()

		_, err = io.Copy(os.Stdout, resp.Body)
		if err != nil {
			return ""
		}
}
*/

func dumpURL(url string) []string {
	resp, err := http.Get(url)
	if err != nil {
		return nil
	}
	defer resp.Body.Close()

	bodyBytes, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil
	}

	return strings.Split(string(bodyBytes), "\n")
}

func formatDuration(d time.Duration) string {
	seconds := int(d.Seconds()) % 60
	minutes := int(d.Minutes()) % 60
	hours := int(d.Hours()) % 24
	days := int(d.Hours()) / 24

	result := ""
	if days > 0 {
		result += fmt.Sprintf("%dd ", days)
		return result
	}
	if hours > 0 {
		result += fmt.Sprintf("%dh ", hours)
		return result
	}
	if minutes > 0 {
		result += fmt.Sprintf("%dm ", minutes)
		return result
	}
	if seconds > 0 {
		result += fmt.Sprintf("%ds", seconds)
	}
	return result
}