package git

import (
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/go-git/go-git/v5"
	"github.com/go-git/go-git/v5/plumbing"
	"github.com/go-git/go-git/v5/plumbing/object"
	"github.com/google/go-github/v41/github"
	"github.com/synapsecns/sanguine/contrib/git-changes-action/detector/actionscore"
	"github.com/synapsecns/sanguine/contrib/git-changes-action/detector/tree"
	"github.com/synapsecns/sanguine/core"
	"os"
	"strings"
)

// getChangeTreeFromGit returns a tree of all the files that have changed between the current commit and the commit with the given hash.
// nolint: cyclop, gocognit
func getChangeTreeFromGit(repoPath string, ghContext *actionscore.Context, head, base string) (tree.Tree, error) {
	// open the repository
	repository, err := git.PlainOpen(repoPath)
	if err != nil {
		return nil, fmt.Errorf("could not open repository %s: %w", repoPath, err)
	}

	head, err = GetHead(repository, ghContext, head)
	if err != nil {
		return nil, fmt.Errorf("could not get head: %w", err)
	}
	head = getShortName(head)

	base = getShortName(getBase(ghContext, base))

	_, err = hex.DecodeString(base)
	isBaseSha := err == nil
	isBaseSameAsHead := base == head

	var baseSha string

	// If base is commit SHA we will do comparison against the referenced commit
	// Or if base references same branch it was pushed to, we will do comparison against the previously pushed commit
	//nolint: nestif
	if isBaseSha || isBaseSameAsHead {
		if !isBaseSha {
			var ok bool
			baseSha, head, ok, _ = tryGetPushEvent()
			isBaseSha = true

			if !ok {
				baseSha, head, err = getHeadBase(repository)
				if err != nil {
					// TODO: we might need to add error handling here for last commit on a branch, see: https://github.com/dorny/paths-filter/blob/master/src/main.ts#L141
					return nil, fmt.Errorf("could not get last commit hash: %w", err)
				}
			}
		}
	}

	if head == "" {
		rawHead, err := repository.Head()
		if err != nil {
			return nil, fmt.Errorf("could not get HEAD: %w", err)
		}

		head = rawHead.String()
	}

	// nolint: nestif
	if !isBaseSha {
		res, err := convertToSha(repository, base)
		if err != nil {
			return nil, fmt.Errorf("could not convert base to sha: %w", err)
		}

		baseSha = res.String()
	}

	// create the change tree
	changeTree := tree.NewTree()

	// get each commit object (before and after)
	baseObject, err := repository.CommitObject(plumbing.NewHash(baseSha))
	if err != nil {
		return nil, fmt.Errorf("could not get commit object for base %s: %w", baseSha, err)
	}

	headHash, err := convertToSha(repository, head)
	if err != nil {
		return nil, fmt.Errorf("could not convert head to sha: %w", err)
	}

	headObject, err := repository.CommitObject(*headHash)
	if err != nil {
		return nil, fmt.Errorf("could not get commit object for head %s: %w", head, err)
	}

	diff, err := fastDiff(baseObject, headObject)
	if err != nil {
		return nil, fmt.Errorf("could not get diff: %w", err)
	}

	changeTree.Add(diff...)

	return changeTree, nil
}

func convertToSha(repository *git.Repository, ref string) (res *plumbing.Hash, err error) {
	// already a sha
	_, err = hex.DecodeString(ref)
	if err == nil {
		return core.PtrTo(plumbing.NewHash(ref)), nil
	}

	refs, err := repository.References()
	if err != nil {
		return nil, fmt.Errorf("could not get references: %w", err)
	}

	remotes, err := repository.Remotes()
	if err != nil {
		return nil, fmt.Errorf("could not get remotes: %w", err)
	}

	err = refs.ForEach(func(reference *plumbing.Reference) error {
		if reference.Name().String() == ref {
			res = core.PtrTo(reference.Hash())
		}

		for _, remote := range remotes {
			refName := plumbing.NewRemoteReferenceName(remote.Config().Name, ref)
			if refName == reference.Name() {
				res = core.PtrTo(reference.Hash())
			}
		}

		return nil
	})

	if err != nil {
		return nil, errors.New("could not iterate through references")
	}

	if res != nil {
		return res, nil
	}

	return nil, fmt.Errorf("could not convert reference %s to %T", ref, core.PtrTo(plumbing.NewHash("")))
}

// fastDiff is a faster way to get the diff between two commits.
// it returns a boolean rather than a full blob diff.
func fastDiff(from, to *object.Commit) (changedFiles []string, err error) {
	fromTree, err := from.Tree()
	if err != nil {
		return []string{}, fmt.Errorf("could not get tree for commit %s: %w", from.Hash.String(), err)
	}

	toTree, err := to.Tree()
	if err != nil {
		return []string{}, fmt.Errorf("could not get tree for commit %s: %w", to.Hash.String(), err)
	}

	changes, err := fromTree.Diff(toTree)
	if err != nil {
		return []string{}, fmt.Errorf("could not get diff for commit %s: %w", to.Hash.String(), err)
	}

	for _, change := range changes {
		if change.From.Name != "" {
			changedFiles = append(changedFiles, change.From.Name)
		}
		if change.To.Name != "" {
			changedFiles = append(changedFiles, change.To.Name)
		}
	}

	return changedFiles, nil
}

func tryGetPushEvent() (base, head string, ok bool, err error) {
	f, err := os.Open(os.Getenv("GITHUB_EVENT_PATH"))
	if err != nil {
		return "", "", false, fmt.Errorf("could not open event path: %w", err)
	}
	defer func() {
		_ = f.Close()
	}()

	var gpe github.PushEvent

	if err := json.NewDecoder(f).Decode(&gpe); err != nil {
		return "gpe", "", false, fmt.Errorf("could not decode event: %w", err)
	}

	return gpe.GetBefore(), gpe.GetAfter(), true, nil
}

// note: we don't  handle the case of no previous commit, this will error.
func getHeadBase(repo *git.Repository) (head string, base string, err error) {
	co, err := repo.Head()
	if err != nil {
		return "", "", fmt.Errorf("could not get head: %w", err)
	}

	citer, err := repo.Log(&git.LogOptions{From: co.Hash()})
	if err != nil {
		return "", "", fmt.Errorf("could not get logs: %w", err)
	}

	_, err = citer.Next()
	if err != nil {
		return "", "", fmt.Errorf("could not pass head: %w", err)
	}
	lastCommit, err := citer.Next()
	if err != nil {
		return "", "", fmt.Errorf("could not get last commit: %w", err)
	}

	return co.Hash().String(), lastCommit.Hash.String(), nil
}

// GetHead gets the head of the current branch.
// it attempts to mirror the logic of  https://github.com/dorny/paths-filter/blob/0ef5f0d812dc7b631d69e07d2491d70fcebc25c8/src/main.ts#L104
func GetHead(repo *git.Repository, ghContext *actionscore.Context, head string) (string, error) {
	if head != "" {
		return head, nil
	}

	if ghContext.Ref != "" {
		return ghContext.Ref, nil
	}

	gitHead, err := repo.Head()
	if err != nil {
		// TODO: there's some other logic here: https://github.com/dorny/paths-filter/blob/4067d885736b84de7c414f582ac45897079b0a78/src/git.ts#L174
		// we might want to build in
		return "", fmt.Errorf("could not get head: %w", err)
	}

	return gitHead.Name().Short(), nil
}

func getBase(ghContext *actionscore.Context, base string) string {
	if base != "" {
		return base
	}

	return ghContext.Payload.Repository.GetDefaultBranch()
}

// emulates https://github.com/dorny/paths-filter/blob/master/src/git.ts#L185
func getShortName(ref string) string {
	const heads = "refs/heads/"
	const tags = "refs/tags/"

	if strings.HasPrefix(ref, heads) {
		return strings.TrimPrefix(ref, heads)
	}

	if strings.HasPrefix(ref, tags) {
		return strings.TrimPrefix(ref, tags)
	}

	return ref
}