package main

import (
	"fmt"

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

func doList() error {
	log.Info("do list here")

	me.all = forgepb.NewPatchsets()

	/*
		err := filepath.WalkDir("/var/lib/forged/patchset", func(path string, d os.DirEntry, err error) error {
			if err != nil {
				// Handle possible errors, like permission issues
				fmt.Fprintf(os.Stderr, "error accessing path %q: %v\n", path, err)
				return err
			}

			if d.IsDir() {
				// log.Info("path is dir", path)
				return nil
			} else {
				_, fname := filepath.Split(path)
				log.Info("found", fname, path)
				return nil
			}

			return nil
		})
	*/
	for pset := range me.all.IterAll() {
		showPatchsets(pset)
	}
	return nil
}

func showPatchsets(pb *forgepb.Patchset) error {
	author := "Author: " + pb.GitAuthorName
	author += " <" + pb.GitAuthorEmail + ">"

	// author := "Author: " + os.Getenv("GIT_AUTHOR_NAME")
	// author += " <" + os.Getenv("GIT_AUTHOR_EMAIL") + ">"
	fmt.Println(pb.Name, pb.Comment, author)
	for i, patches := range pb.Patches.Patches {
		log.Info("\tnew patches:", i, patches.CommitHash, patches.Namespace)
	}
	/*
		for patch := range pb.IterAll() {
			comment := cleanSubject(patch.Comment)
			log.Info("\tnew patch:", patch.NewHash, "commithash:", patch.CommitHash, patch.Namespace, comment)
		}
	*/
	return nil
}

/*
// adds submitted patches not specifically assigned to a patchset
// to the generic patchset called "forge auto commit"
func addRandomPatch(patch *forgepb.Patch) {
	for pset := range me.all.IterAll() {
		if pset.Name == "forge auto commit" {
			newpb := proto.Clone(patch).(*forgepb.Patch)
			if newpb != nil {
				pset.Patches.Append(newpb)
			}
		}
	}
	log.Warn("patchset.Name == 'forge auto commit' could not be found so the patch in", patch.Namespace, "could not be added")
}

func addPatchset(filename string, pb *forgepb.Patchset) {
	if pb.Name == "forge auto commit" {
		author := "Author: " + pb.GitAuthorName
		author += " <" + pb.GitAuthorEmail + ">"

		// author := "Author: " + os.Getenv("GIT_AUTHOR_NAME")
		// author += " <" + os.Getenv("GIT_AUTHOR_EMAIL") + ">"
		fmt.Println(filename, pb.Name, pb.Comment, author)
		for _, patch := range pb.Patches.Patches {
			// log.Info("\tnew patch:", i, patch.CommitHash, patch.Namespace)
			if findPatch(patch) {
				// log.Info("\talready found!!!!!!!", pset.Uuid, patch.Namespace)
			} else {
				log.Info("\tnew patch:", filename, pb.Name, pb.Comment, author)
			}
		}
		// add each of the patches to the general pool
	} else {
		// Clone() this protobuf into me.all
		var newpb *forgepb.Patchset
		newpb = proto.Clone(pb).(*forgepb.Patchset)
		if newpb != nil {
			me.all.Append(newpb)
		}
	}
}
*/

// returns true if the patch already exists in the protobuf
func findPatch(newpatch *forgepb.Patch) bool {
	// log.Info("\tlook for patch:", newpatch.CommitHash, newpatch.Namespace)

	for pset := range me.all.IterAll() {
		for _, patch := range pset.Patches.Patches {
			if patch.CommitHash == newpatch.CommitHash {
				// log.Info("\tfound pset!!!!!!", pset.Uuid, patch.Namespace)
				return true
			}

		}
	}

	return false
}

/*
func mergePatchsets() {
	dirname := filepath.Join(LIBDIR, "patchset/")
	// Open the directory
	entries, err := os.ReadDir(dirname)
	if err != nil {
		fmt.Printf("Error reading directory: %v\n", err)
		return
	}

	// Iterate through the directory entries
	for _, entry := range entries {
		// Check if the entry is a file and matches the *.pb pattern
		if !entry.IsDir() && filepath.Ext(entry.Name()) == ".pb" {
			bytes, err := os.ReadFile(filepath.Join(dirname, entry.Name()))
			if err != nil {
				fmt.Println(entry.Name(), err)
				continue
			}
			var p *forgepb.Patchset
			p = new(forgepb.Patchset)
			err = p.Unmarshal(bytes)
			if err != nil {
				fmt.Println(entry.Name(), err)
				continue
			}
			addPatchset(entry.Name(), p)
		}
	}
}
*/