// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
// Use of this source code is governed by the GPL 3.0

package main

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"go.wit.com/lib/protobuf/gitpb"
	"go.wit.com/log"
)

func doBuild() (string, error) {
	initForge()

	if argv.Build.Install != nil {
		if err := doInstall(me.forge.Repos); err != nil {
			// log.Info("doInstall() failed", err)
			me.argv.BadExit("doInstall() failed", err)
		}
		if argv.DryRun {
			me.argv.GoodExit("Nothing built --dry-run")
		}
		me.argv.GoodExit("EVERYTHING BUILT!")
	}

	if argv.Build.MacBuild != nil {
		return "todo: add mac builds", nil
	}

	if argv.Build.Debian != nil {
		// figure out what to build
		// found := findBuildDeb()
		data, err := resources.ReadFile("resources/go-deb")
		if err != nil {
			return "missing resources/go-deb list", err
		}
		for i, line := range strings.Split(string(data), "\n") {
			var path string
			var debname string
			var arches string
			parts := strings.Split(line, ",")
			if len(parts) > 0 {
				path = parts[0]
			}
			if len(parts) > 1 {
				debname = parts[1]
			}
			if len(parts) > 2 {
				arches = parts[2]
			}
			log.Info("MAKE DEB FOR:", i, path, debname, arches)
		}

		/*
			if err := doInstall(found); err != nil {
				// log.Info("doInstall() failed", err)
				me.argv.BadExit("doInstall() failed", err)
			}
			return doBuildDeb(found)
		*/
	}

	return "todo: doBuild()", nil
}

func doInstall(all *gitpb.Repos) error {
	// doInstallScan()

	found := gitpb.NewRepos()
	for check := range all.IterAll() {
		if me.forge.Config.IsReadOnly(check.Namespace) {
			continue
		}

		if !check.IsBinary() {
			continue
		}

		if check.IsGoPlugin() {
			continue
		}
		found.Append(check)
	}
	footer := found.PrintForgedTable()
	log.Info("Starting 'go install' on these repos:", footer)

	if argv.DryRun {
		return nil
	}

	me.forge.ConfigRill(16, 16)
	os.Setenv("GO111MODULE", "off")
	stats := me.forge.RunOnRepos(found, doInstallRepo)
	os.Unsetenv("GO111MODULE")
	failed := gitpb.NewRepos()
	for s, stat := range stats {
		if stat.Err == nil {
			continue
		}
		// log.Info("CRAP. INSTALL FAILED", config.FormatDuration(dur), s, stat.Err)
		msg := "go install FAILED " + s
		log.Info(msg)
		found := me.forge.Repos.FindByFullPath(s)
		if found == nil {
			log.Info("found", found, "'"+s+"'")
			panic("wrong namespace logic. couldn't find repo from stats")
		}
		failed.Append(found)
	}
	os.Remove(filepath.Join(me.homedir, "go/bin/forged"))
	if failed.Len() > 0 {
		for r := range failed.IterAll() {
			log.Info("r.Namespace", r.Namespace)
		}
		failed.SortNamespace()
		footer = failed.PrintForgedTable()
		log.Info("TABLE WITH NULLS", footer)
		me.argv.BadExit("go install Failed for: "+footer, nil)
	}
	return nil
}

func doInstallRepo(check *gitpb.Repo) error {
	repotype := check.GetRepoType()
	if repotype == "binary" || repotype == "plugin" {
		// we only want to process things that can be compiled with 'go build'
	} else {
		// log.Info("skipping repo", check.Namespace, repotype)
		return nil
	}

	if me.forge.Config.IsReadOnly(check.Namespace) {
		// ignore read only stuff
		return nil
	}

	if argv.Verbose {
		verbose := []string{"-v", "-x"}
		if err := me.forge.Install(check, verbose); err != nil {
			log.Warn("INSTALL FAILED", check.Namespace, err)
			return err
		}
	} else {
		if err := me.forge.Install(check, nil); err != nil {
			log.Warn("INSTALL FAILED", check.Namespace, err)
			return err
		}
	}
	return nil
}

func doInstallScan() {
	all := me.forge.Repos.SortByFullPath()
	for all.Scan() {
		check := all.Next()

		repotype := check.GetRepoType()
		if repotype == "binary" || repotype == "plugin" {
			// we only want to process things that can be compiled with 'go build'
		} else {
			// log.Info("skipping repo", check.Namespace, repotype)
			continue
		}

		if me.forge.Config.IsReadOnly(check.Namespace) {
			// ignore read only stuff
			continue
		}

		if check.GetState() == "" {
			check.State = "need to build"
		}

		// var cmd []string
		var start string
		var end string

		manufactured := check.GetCurrentVersion()
		ver := trimNonNumericFromStart(manufactured)
		name := me.forge.Config.DebName(check.GetNamespace())
		var realver string
		if installedPackage := me.machine.FindInstalledByName(name); installedPackage != nil {
			realver = installedPackage.Version
		}
		if actualp := me.machine.FindByVersion(name, ver); actualp != nil {
			end += " (version match) " + actualp.Version + " " + ver + " "
			check.State = "on mirrors"
		} else {
			if realver != "" {
				end += fmt.Sprintf(" (version  miss) %s vs %s ", realver, ver)
			}
			// end += "" + ver + " "
		}
		if me.machine.IsInstalled(name) {
			if actualp := me.machine.FindInstalledByName(name); actualp != nil {
				if ver != actualp.Version {
					end += "(installed " + actualp.Version + ") "
				} else {
					end += "(installed ok) "
				}
			} else {
				end += "(installed) "
			}
		}

		state := check.GetState()
		// todo: get all this shit into the protobuf
		start = fmt.Sprintf("%-18.18s %-24s", state, ver)
		if strings.HasPrefix(check.GetState(), "unknown bran") {
			state = "need to build"
		}

		if state == "need to build" {
			end = "(will build)" + end
		}

		end = strings.TrimSpace(end)
		if end == "" {
			end = check.GetState()
		}
		log.Info(start, check.GetRepoType(), end)
		if name == "" {
			// err := fmt.Sprintf("name is blank error %+v", repo)
			log.Warn("name is blank error", check.GetNamespace())
		}
	}
}