// 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 isPackageOnMirrors(repo *gitpb.Repo) bool {
	manufactured := repo.GetCurrentVersion()
	ver := trimNonNumericFromStart(manufactured)
	name := me.forge.Config.DebName(repo.GetGoPath())
	if actualp := me.machine.FindByVersion(name, ver); actualp != nil {
		// end += " (version match) " + actualp.Version + " " + ver + " "
		// repo.State = "on mirrors"
		return true
	}
	return false
}

func printRepos(pb *gitpb.Repos) {
	tablePB := pb.NewTable("deb details")
	tablePB.NewUuid()

	var col *gitpb.RepoFunc

	col = tablePB.AddNamespace()
	col.Width = 32

	col = tablePB.AddStringFunc("RepoType", func(r *gitpb.Repo) string {
		return me.forge.GetRepoType(r)
	})
	col.Width = 8

	col = tablePB.AddStringFunc("Build Version", func(r *gitpb.Repo) string {
		return me.forge.GetPackageVersion(r)
	})
	col.Width = 24

	col = tablePB.AddStringFunc("is old", func(r *gitpb.Repo) string {
		manufactured := r.GetCurrentVersion()
		ver := trimNonNumericFromStart(manufactured)
		name := me.forge.Config.DebName(r.GetGoPath())
		if actualp := me.machine.FindByVersion(name, ver); actualp != nil {
			// end += " (version match) " + actualp.Version + " " + ver + " "
			return ""
		}
		if installedPackage := me.machine.FindInstalledByName(name); installedPackage != nil {
			return installedPackage.Version
		}
		return ""
	})
	col.Width = 10

	col = tablePB.AddStringFunc("I", func(r *gitpb.Repo) string {
		name := me.forge.Config.DebName(r.GetNamespace())
		if me.machine.IsInstalled(name) {
			return "X"
		}
		// debname := me.forge.Config.DebName(r.GetNamespace())
		// if actualp := me.machine.FindInstalledByName(debname); actualp != nil {
		// 	return "X"
		// }
		return ""
	})
	col.Width = 1

	col = tablePB.AddStringFunc("done", func(r *gitpb.Repo) string {
		if isPackageOnMirrors(r) {
			return "yes"
		}
		return ""
	})
	col.Width = 4

	col = tablePB.AddStringFunc("build", func(r *gitpb.Repo) string {
		if willBuild(r) {
			return "yes"
		}
		return ""
	})
	col.Width = 5

	col = tablePB.AddStringFunc("deb name", func(r *gitpb.Repo) string {
		name := me.forge.Config.DebName(r.GetNamespace())
		ver := me.forge.GetPackageVersion(r)
		debname := name + "_" + ver + "_amd64.deb"
		return debname
	})
	col.Width = 32

	col = tablePB.AddState()
	col.Width = 32

	col = tablePB.AddStringFunc("end", func(r *gitpb.Repo) string {
		return getStatusEnd(r)
	})
	col.Width = -1

	tablePB.PrintTable()
}

func getStatusEnd(repo *gitpb.Repo) string {
	var end string

	manufactured := repo.GetCurrentVersion()
	ver := trimNonNumericFromStart(manufactured)
	name := me.forge.Config.DebName(repo.GetGoPath())
	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 + " "
		// repo.State = "on mirrors"
	} else {
		if realver != "" {
			end += fmt.Sprintf(" (version  miss) %s vs %s ", realver, ver)
		}
		// end += "" + ver + " "
	}

	debname := name + "_" + ver + "_amd64.deb"
	// debnames[repo] = debname
	outdir := getOutdir(repo)
	_, err := os.Stat(filepath.Join(outdir, debname))
	if err == nil {
		// log.Info("exists", filepath.Join(outdir, debname))
		repo.State = "in incoming"
	} else {
		// log.Info(debname, "does not exist")
	}
	if strings.HasPrefix(repo.GetState(), "unknown bran") {
		end += " (will build) "
	}

	if repo.State == "" {
		end += " (will build) "
	}

	if repo.State == "need to build" {
		end += " (will build) "
	}

	if name == "" {
		// err := fmt.Sprintf("name is blank error %+v", repo)
		log.Warn("name is blank error", repo.GetGoPath())
	}
	return end
}

func willBuild(repo *gitpb.Repo) bool {
	if strings.HasPrefix(repo.GetState(), "unknown bran") {
		return true
	}

	if repo.State == "" {
		return true
	}

	if repo.State == "need to build" {
		return true
	}

	return false
}