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

package main

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

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

//	/tmp/go-nsupdate$ git ls-remote
//	From git@github.com:SpComb/go-nsupdate.git
//	d65f28d10991354b3af0168001a4beea6b8242f9	HEAD
//	d65f28d10991354b3af0168001a4beea6b8242f9	refs/heads/master
//	fb04ebe13a16c01e1a7eb3892a0aca8c6db96fa0	refs/pull/3/head
//	d774220311b2d44c770e7431ec663c8875488a1e	refs/pull/6/head
//	fefb9ea80745893a2203576bdc2872d33e539064	refs/pull/7/head
//	c09c90d0a931888862262a6ed3753eed0af4ddca	refs/pull/8/head

func doStats(cmd *StatsCmd) (string, error) {
	if cmd.All != nil {
		if cmd.Reload {
			fixed := me.forge.RunOnRepos(me.forge.Repos, doReload)
			if fixed.Len() == 0 {
				return "no git config changes", nil
			}

			// show the changed repos & save cache .pb file
			fixed = fixed.SortActual()
			footer := me.forge.PrintErrorsTB(fixed)
			me.forge.Repos.SaveVerbose()
			return ".git/config problems: " + footer, nil
		}
		if cmd.ReloadClean {
			var counter int
			for repo := range me.forge.Repos.IterAll() {
				os.Chdir(repo.FullPath)
				globPattern := ".git/*.pb"
				files, err := filepath.Glob(globPattern)
				if err != nil {
					log.Info("glob error", err, files)
					continue
				}
				for _, filename := range files {
					log.Info("DELETE", filename)
					counter += 1
					os.Remove(filename)
				}
			}
			return fmt.Sprintf("cleaned %d pb files", counter), nil
		}
	}

	repo := workingDirToRepo()
	if repo == nil {
		return "no repo", errors.New("working dir isn't a repo I know about")
	}
	if cmd.Repo != "" {
		r := me.forge.Repos.FindByNamespace(cmd.Repo)
		if r == nil {
			return "no repo " + cmd.Repo, errors.New("no repo " + cmd.Repo)
		}
		for _, rmote := range r.Config.Remotes {
			stats, err := r.LoadRemoteRefs(rmote.Name)
			if err != nil {
				// return err
			}
			if env.True("resort") {
				stats.SaveByHash()
				log.Info("stats should have been resorted and saved")
			} else {
				footer := stats.PrintTable()
				log.Info("full remote refs footer:", footer)
			}
		}
		return "remote refs table", nil
	}

	if cmd.Reload {
		err := doReload(repo)
		return "doReload()", err
	}

	if cmd.CheckRefs {
		err := doCheckRefs(repo)
		return "checked refs", err
	}

	if cmd.CheckRemote {
		err := doCheckRemote(repo)
		return "checked remote refs", err
	}

	if cmd.CheckRemoteRefs {
		err := doCheckRemoteRefs(repo)
		return "checked remote refs", err
	}

	if cmd.UpdateRefs {
		err := doUpdateRefs(repo)
		return "update refs", err
	}

	if cmd.UpdateRemote {
		err := doUpdateRemote(repo)
		return "update remote", err
	}

	if cmd.UpdateRemoteRefs {
		err := doUpdateRemoteRefs(repo)
		return "update remote refs", err
	}

	if cmd.List {
	}

	return "do what?", nil
}

func doCheckRefs(r *gitpb.Repo) error {
	stats, err := r.LoadRefs()
	if err != nil {
		return err
	}

	if env.True("resort") {
		stats.SaveByHash()
		log.Info("stats should have been resorted and saved")
		return nil
	}
	footer := stats.PrintTable()
	log.Info("stats footer:", footer)
	return nil
}

func doCheckRemote(r *gitpb.Repo) error {
	for _, rmote := range r.Config.Remotes {
		morestats, err := r.MakeRemote(rmote.Name)
		if err != nil {
			// return err
		}
		if env.True("resort") {
			morestats.SaveByHash()
			return errors.New("stats should have been resorted and saved")
		}
		footer := morestats.PrintTable()
		log.Printf("full %s remote refs footer: %s\n", rmote.Name, footer)
	}

	return nil
}

func doCheckRemoteRefs(r *gitpb.Repo) error {
	for _, rmote := range r.Config.Remotes {
		morestats, err := r.MakeRemoteRefs(rmote.Name)
		if err != nil {
			// return err
		}
		if env.True("resort") {
			morestats.SaveByHash()
			return errors.New("stats should have been resorted and saved")
		}
		footer := morestats.PrintTable()
		log.Printf("full %s remote refs footer: %s\n", rmote.Name, footer)
	}

	return nil
}

func doUpdateRefs(r *gitpb.Repo) error {
	stats, err := r.LoadRefs()
	if err != nil {
		return err
	}

	footer := stats.PrintTableLimit(2)
	log.Info("stats footer:", footer)

	err = r.UpdateRefs(stats)
	return err
}

func doUpdateRemote(r *gitpb.Repo) error {
	for _, rmote := range r.Config.Remotes {
		err := r.UpdateRemote(rmote.Name)
		if err != nil {
			return err
		}
		// footer := morestats.PrintTableLimit(20)
		log.Printf("full %s remote update remote footer\n", rmote.Name)
	}

	return nil
}

func doUpdateRemoteRefs(r *gitpb.Repo) error {
	for _, rmote := range r.Config.Remotes {
		/*
			morestats, err := r.LoadRemoteRefs(rmote.Name)
			if err != nil {
				return err
			}
		*/

		err := r.UpdateRemoteRefs(rmote.Name)
		if err != nil {
			return err
		}
	}

	return nil
}