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

package main

import (
	"bytes"
	"errors"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"strings"

	"go.wit.com/lib/ENV"
	"go.wit.com/lib/fhelp"
	"go.wit.com/lib/protobuf/forgepb"
	"go.wit.com/lib/protobuf/gitpb"
	"go.wit.com/log"
)

func isPatchingSafe() bool {
	if me.forge.IsModeNormal() {
		return true
	}
	log.Info("This patch command is not safe to run now")
	log.Info("you must reset the state of your git repositories. Run:")
	log.Info("")
	log.Info("forge normal (or use --force)")
	log.Info("")
	if argv.Force {
		return true
	}
	return false
}

func doPatch() (string, error) {
	// var changed bool
	me.curpatches = forgepb.NewPatches()
	me.curpatches.Filename = ENV.Get("curpatches")
	if me.curpatches.Filename == "" {
		panic("config failed. no 'curpatches' set in ~/.config/forge/config.text")
	}
	if err := me.curpatches.Load(); err != nil {
		me.curpatches.Save()
		me.curpatches.Save()
		log.Info(err)
		panic("no file")
		// return
		// // THIS IS NEEDED? NOTSURE
		me.curpatches = forgepb.NewPatches()
		me.curpatches.Filename = ENV.Get("curpatches")
		me.curpatches.Save()
	}

	// just show the table and exit
	if argv.Patch.Show {
		footer := me.curpatches.PrintTable()
		return "all current patches: " + footer, nil
	}

	// send them onward again
	if argv.Patch.Submit {
		return doPatchSubmit()
	}

	psets := forgepb.NewSets()
	newpb, _, _ := psets.HttpPostVerbose(myServer(), "get")
	footer, err := doPatchGet(newpb)
	if footer == "" {
		log.Info(footer)
	}

	// forces patching to be done in 'NORMAL' mode
	// forge is too new to be able to handle anything else
	if !isPatchingSafe() {
		return "not safe", errors.New("not safe to work on patches")
	}

	s, err := doPatchProcess()
	return s, err
}

// submit's current working patches
func doPatchSubmit() (string, error) {
	pset, err := me.forge.MakeDevelPatchSet("testing")
	if err != nil {
		return "MakeDevelPatchSet(testing)", err
	}
	if pset.Patches == nil {
		return "pset.Patches == nil", err
	}
	if pset.Patches.Len() == 0 {
		return "did not find any patches", nil
	}
	footer := pset.PrintTable()
	_, _, err = pset.HttpPost(myServer(), "new")
	return footer, err
}

func doPatchProcess() (string, error) {
	var needfix int
	needapply := forgepb.NewPatches()
	for patch := range me.curpatches.IterAll() {
		repo := me.forge.Repos.FindByNamespace(patch.Namespace)
		if repo == nil {
			// log.Info("no namespace", patch.PatchId, patch.Namespace, patch.Comment)
			patch.State = "no namespace"
			continue
		}
		if patch.NewHash == "na" {
			patch.State = "was na"
			needfix = 1
		}
		newId, newHash, err := isPatchIdApplied(repo, patch)
		if errors.Is(err, ErrorGitPullOnDirty) {
			log.Info(patch.PatchId, newId, repo.Namespace, "repo dirty", patch.Comment)
			patch.State = "repo dirty"
			// log.Info("a patch with that comment couldn't be found in the repo")
		} else if err != nil {
			// log.Info(patch.PatchId, newId, repo.Namespace, err, patch.Comment)
			patch.State = "applied err"
			patch.StateChange = log.Sprintf("%v", err)
			// return "isPatchIdApplied() error", patch.Error(err)
		}
		if newId == "" {
			// new patch !
			// log.Info(patch.PatchId, "newId==''", patch.Comment)
		} else {
			if (newId == patch.PatchId) && (newHash == patch.CommitHash) {
				// log.Info(patch.PatchId, newId, repo.Namespace, "patch made here", patch.Comment)
				patch.StateChange = "made here"
				patch.NewHash = "author"
				continue
			}
			if newId == patch.PatchId {
				patch.NewHash = patch.CommitHash
				// log.Info(patch.PatchId, newId, repo.Namespace, "patch already applied", patch.Comment)
				patch.StateChange = "did already"
				if patch.State == "was na" {
					patch.State = "applied"
				}
				continue
			}
			if newId != patch.PatchId {
				// log.Info(patch.PatchId, newId, repo.Namespace, "probably duplicate subject? (mismatch)", patch.Comment)
				patch.StateChange = "dup subject?"
				// try this. it should compute every patch id in the repo
				// os.Chdir(repo.FullPath)
				// newNewId, err := searchAllCommits(targetPatchID string) (string, error) {
			}
		}
		// log.Info(patch.PatchId, newId, repo.Namespace, "new patch", patch.Comment)
		patch.State = "new patch"
		needapply.Clone(patch)
	}
	var applycounter int
	for patch := range needapply.IterAll() {
		repo := me.forge.Repos.FindByNamespace(patch.Namespace)
		if repo == nil {
			if argv.Verbose {
				// dump the whole patch
				log.Info("skipping patch for unknown namespace", patch.Namespace)
			}
			continue
		}
		if argv.Patch == nil {
			needfix += 1
			continue
		}
		// if !me.argv.If("--apply") {
		if !argv.Patch.Apply {
			// --apply isn't set. don't go any further
			needfix += 1
			continue
		}
		// show some of the patch details
		if argv.Verbose {
			// dump the whole patch
			log.Info(string(patch.Data))
		}
		log.Info(repo.FullPath, "")
		log.Info(repo.FullPath, patch.Comment)
		for _, fname := range patch.Files {
			log.Info(repo.FullPath, fname)
		}
		for _, line := range strings.Split(string(patch.Data), "\n") {
			// log.Info(repo.FullPath, line)
			if strings.HasPrefix(line, "From: ") {
				log.Info(repo.FullPath, line)
				continue
			}
			if strings.HasPrefix(line, "Date: ") {
				log.Info(repo.FullPath, line)
				continue
			}
			if strings.HasPrefix(line, "---") {
				break
			}
			if line == "-- " {
				break
			}
		}
		log.Info(repo.FullPath, patch.Gan, patch.Gae, patch.GaI)
		// prompt user to apply patch
		applycounter += 1
		s := log.Sprintf("apply this patch (%d/%d)? (--force to autoapply)", applycounter, needapply.Len())
		if fhelp.QuestionUser(s) {
			newhash, err := applyPatch(repo, patch)
			if err != nil {
				log.Info("apply results:", newhash, err)
			}
			if err != nil {
				return "git am problem. manually investigate or purge everything and start over", err
			}
		}
	}
	// NOW, FINALLY, AFTER A LOT OF WORK, THE FUN PART
	newpatches := forgepb.NewPatches()
	for p := range me.curpatches.IterAll() {
		if p.NewHash == "author" {
			// this is your patch
			continue
		}
		if (p.NewHash != "") && p.StateChange == "did already" {
			// already applied
			continue
		}
		if p.State == "no namespace" {
			// you don't have this repo on your disk
			continue
		}
		newpatches.Clone(p)
	}
	me.curpatches.Save()
	if newpatches.Len() == 0 {
		s := log.Sprintf("All (%d) current patches are appled. You are completely up to date!", me.curpatches.Len())
		return s, nil
	}
	footer := newpatches.PrintTable()
	log.Info("BRAND NEW PATCHES:", footer)
	var s string
	s = log.Sprintf("There are %d new patches. Use --apply to apply them", needfix)
	return s, nil
}

func applyPatch(repo *gitpb.Repo, p *forgepb.Patch) (string, error) {
	_, filen := filepath.Split(p.Filename)
	tmpname := filepath.Join("/tmp", filen)
	log.Info("saving as", tmpname, p.Filename)
	raw, err := os.OpenFile(tmpname, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
	if err != nil {
		return "", err
	}
	raw.Write(p.Data)
	raw.Close()

	log.Info("")
	// always run abort first
	cmd := []string{"git", "am", "--abort"}
	stats := repo.Run(cmd)
	if stats.Error != nil {
		panic("git am --abort failed")
	}
	log.Info("Ran 'git am --abort' for safety and everything seems ok")
	// if stats.Outp == nil {
	// 	log.Info("todo: move this to linux/ and do things correctly")
	// }

	// git apply --check /tmp/0001-renamed-file-and-added-stuff.patch
	cmd = []string{"git", "apply", "--check", tmpname}
	stats = repo.Run(cmd)
	if stats.Error != nil {
		panic("git apply --check failed")
	}
	if stats.Exit != 0 {
		panic("git apply --check failed")
	}
	log.Info("Ran 'git apply --check' and everything seems ok")

	/*
			// The current 'best practice' thanks to Gemini. the current LLM's are useful for this sorta thing

			// git apply --reject /tmp/0001-renamed-file-and-added-stuff.patch

		     Step 4: Fix the Conflict

		      1. List the reject files: ls *.rej.
		      2. Open the .rej file and the corresponding source file (e.g., some/file.go.rej and some/file.go).
		      3. The .rej file shows you the lines that couldn't be applied. Manually edit your source file to incorporate the changes
		         from the patch correctly.
		      4. Once you've fixed the file, delete the .rej file.

		     Step 5: Commit the Result

		     Once all .rej files are gone and your code is in the state you want, you need to finalize the operation. Since you
		     applied the changes manually, you now need to commit them.

		      1 # Add all the files you manually fixed
		      2 git add .
		      3
		      4 # Now, commit the changes. You can get the commit message from the patch file.
		      5 git commit -F /tmp/0001-renamed-file-and-added-stuff.patch

			git reset --hard HEAD
			git clean -fd          # The -f flag forces the removal, and -d removes untracked directories.
	*/

	cmd = []string{"git", "am", tmpname}
	err = repo.RunVerbose(cmd)
	if err != nil {
		// always run abort after failure. todo: add --keep
		cmd := []string{"git", "am", "--abort"}
		err = repo.RunVerbose(cmd)
		log.Info("git am failed. run 'git am --abort' here")
		return "", log.Errorf("git am failed")
	}
	log.Info(cmd)
	log.Info("everything worked ok")
	return "patch applied with git am", nil
}

func doPatchGet(newpb *forgepb.Sets) (string, error) {
	newpatches := forgepb.NewPatches()
	for pset := range newpb.IterAll() {
		if pset.Patches.Len() == 0 {
			log.Info("pset is empty", pset.Name)
			continue
		}
		for patch := range pset.Patches.IterAll() {
			if len(patch.Data) == 0 {
				continue
			}
			patchid, hash, err := gitpb.FindPatchIdFromGitAm(patch.Data)
			if err != nil {
				log.Info("git patchid exec err", err)
				continue
			}
			if hash != patch.CommitHash {
				log.Info("ERROR: patch commit hashes's didn't match", hash, patch.CommitHash)
				continue
			}
			if patchid != patch.PatchId {
				log.Info("ERROR: patchid's didn't match", patchid, patch.PatchId)
				continue
			}
			found := me.curpatches.FindByPatchId(patch.PatchId)
			if found != nil {
				// already have this patch
				continue
			}
			// gitpb.FindPatchIdFromGitAmBroken(patch.Data) // doesn't os.Exec()
			log.Info("adding new patch", patch.CommitHash, patch.PatchId, patch.Filename)
			me.curpatches.AppendByPatchId(patch)
			newpatches.AppendByPatchId(patch)
		}
	}
	if newpatches.Len() == 0 {
		return "", nil
	}
	footer := newpatches.PrintTable()
	me.curpatches.Save()
	s := log.Sprintf("got %d new patches. %s", newpatches.Len(), footer)
	return s, nil
}

var ErrorGitPullOnDirty error = errors.New("git comment is not there")

func isPatchIdApplied(repo *gitpb.Repo, patch *forgepb.Patch) (string, string, error) {
	comment := cleanSubject(patch.Comment)

	os.Chdir(repo.GetFullPath())
	newhash, err := findCommitBySubject(repo, comment, patch)
	if err != nil {
		return "", "", err
	}

	patchId, err := repo.FindPatchIdByHash(newhash)
	if err != nil {
		return "", "", err
	}

	// log.Infof("%s %s found hash by comment %s \n", patchId, newhash, patch.Comment)
	return patchId, newhash, nil
}

func cleanSubject(line string) string {
	// Regular expression to remove "Subject:" and "[PATCH...]" patterns
	re := regexp.MustCompile(`(?i)^Subject:\s*(\[\s*PATCH[^\]]*\]\s*)?`)
	cleaned := re.ReplaceAllString(line, "")
	return strings.TrimSpace(cleaned)
}

func findCommitBySubject(repo *gitpb.Repo, subject string, newpatch *forgepb.Patch) (string, error) {
	parts := strings.Split(subject, " /")
	subject = parts[0]
	if subject == "" {
		return "", errors.New("subject blank. must brute force")
	}
	cmd := exec.Command("git", "log", "--pretty=format:%H %s", "--grep="+subject, "-i")
	var out bytes.Buffer
	cmd.Stdout = &out
	err := cmd.Run()
	if err != nil {
		return "", err
	}

	lines := strings.Split(out.String(), "\n")
	for _, line := range lines {
		if strings.Contains(strings.ToLower(line), strings.ToLower(subject)) {
			parts := strings.Fields(line)
			patchId, _ := repo.FindPatchIdByHash(parts[0])
			if patchId == newpatch.PatchId {
				return strings.Fields(line)[0], nil // return the commit hash
			}
		}
	}
	return "", fmt.Errorf("no commit found for subject: %s", subject)
}