package git

import (
	"context"
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"go.skia.org/infra/go/exec"
	"go.skia.org/infra/go/sklog"
)

/*
	Utility for managing a Git checkout.
*/

// Checkout is a struct used for managing a local git checkout.
type Checkout struct {
	GitDir
}

// NewCheckout returns a Checkout instance based in the given working directory.
// Uses any existing checkout in the given directory, or clones one if
// necessary. In general, servers should use Repo instead of Checkout unless it
// is absolutely necessary to have a working copy.
func NewCheckout(ctx context.Context, repoUrl, workdir string) (*Checkout, error) {
	g, err := newGitDir(ctx, repoUrl, workdir, false)
	if err != nil {
		return nil, err
	}
	return &Checkout{g}, nil
}

// FetchRefFromRepo syncs the specified ref from the repo without modifying the
// working copy.
func (c *Checkout) FetchRefFromRepo(ctx context.Context, repo, ref string) error {
	_, err := c.Git(ctx, "fetch", repo, ref)
	return err
}

// Fetch syncs refs from the remote without modifying the working copy.
func (c *Checkout) Fetch(ctx context.Context) error {
	_, err := c.Git(ctx, "fetch", "--prune", DefaultRemote)
	return err
}

// AddRemote checks to see if a remote already exists in the checkout, if it
// exists then the URL is matched with the repoURL. If the remote does not exist
// then it is added.
func (c *Checkout) AddRemote(ctx context.Context, remote, repoUrl string) error {
	// Check to see whether there is an upstream yet.
	remoteOutput, err := c.Git(ctx, "remote", "get-url", remote)
	if err != nil {
		if strings.Contains(err.Error(), "No such remote") {
			if _, err := c.Git(ctx, "remote", "add", remote, repoUrl); err != nil {
				return err
			}
		} else {
			return err
		}
	} else {
		// Remote already exists. Make sure that the URLs match.
		if strings.TrimSpace(remoteOutput) != repoUrl {
			return fmt.Errorf("%s points to %s instead of %s", remote, strings.TrimSpace(remoteOutput), repoUrl)
		}
	}
	return nil
}

// CleanupBranch forcibly resets all changes and checks out the given branch,
// forcing it to match the same branch from origin. All local changes will be
// lost.
func (c *Checkout) CleanupBranch(ctx context.Context, branch string) error {
	if _, err := c.Git(ctx, "checkout", branch, "-f"); err != nil {
		return err
	}
	if _, err := c.Git(ctx, "clean", "-d", "-f"); err != nil {
		return err
	}
	if _, err := c.Git(ctx, "reset", "--hard", fmt.Sprintf("origin/%s", branch)); err != nil {
		return err
	}
	return nil
}

// Cleanup forcibly resets all changes and checks out the main branch to match
// that of the remote. All local changes will be lost.
func (c *Checkout) Cleanup(ctx context.Context) error {
	return c.CleanupBranch(ctx, MainBranch)
}

// UpdateBranch syncs the Checkout from its remote. Forcibly resets and checks
// out the given branch, forcing it to match the same branch from origin. All
// local changes will be lost. Equivalent to c.Fetch() + c.CleanupBranch().
func (c *Checkout) UpdateBranch(ctx context.Context, branch string) error {
	if err := c.Fetch(ctx); err != nil {
		return err
	}
	if err := c.CleanupBranch(ctx, branch); err != nil {
		return err
	}
	return nil
}

// Update syncs the Checkout from its remote. Forcibly resets and checks out
// the main branch to match the remote. All local changes will be lost.
// Equivalent to c.Fetch() + c.Cleanup().
func (c *Checkout) Update(ctx context.Context) error {
	return c.UpdateBranch(ctx, MainBranch)
}

// IsDirty returns true if the Checkout is dirty, ie. any of the following are
// true:
// 1. There are unstaged changes.
// 2. There are untracked files (not including .gitignore'd files).
// 3. HEAD is not an ancestor of origin/main.
//
// Also returns the output of "git status", for human consumption if desired.
func (c *Checkout) IsDirty(ctx context.Context) (bool, string, error) {
	status, err := c.Git(ctx, "status")
	if err != nil {
		return false, "", err
	}
	if _, err := c.Git(ctx, "update-index", "--refresh"); err != nil {
		return true, status, nil
	}
	if _, err := c.Git(ctx, "diff-index", "--quiet", "HEAD", "--"); err != nil {
		return true, status, nil
	}
	output, err := c.Git(ctx, "ls-files", "--other", "--directory", "--exclude-standard")
	if err != nil {
		return false, status, err
	}
	output = strings.TrimSpace(output)
	if output != "" {
		return true, status, nil
	}
	if anc, err := c.IsAncestor(ctx, "HEAD", DefaultRemoteBranch); err != nil {
		return false, status, err
	} else if !anc {
		return true, status, nil
	}
	return false, status, nil
}

// TempCheckout is a temporary Git Checkout.
type TempCheckout struct {
	*Checkout
}

// NewTempCheckout returns a TempCheckout instance. Creates a temporary
// directory and then clones the repoUrl into a subdirectory, based on default
// "git clone" behavior.
func NewTempCheckout(ctx context.Context, repoUrl string) (*TempCheckout, error) {
	tmpDir, err := os.MkdirTemp("", "")
	if err != nil {
		return nil, err
	}
	c, err := NewCheckout(ctx, repoUrl, tmpDir)
	if err != nil {
		return nil, err
	}
	return &TempCheckout{
		Checkout: c,
	}, nil
}

// Delete removes the TempCheckout's working directory.
func (c *TempCheckout) Delete() {
	deleteDir := filepath.Dir(c.Dir())
	if err := os.RemoveAll(deleteDir); err != nil {
		// Some processes (eg. gclient) leave files that are owned by us but not
		// writeable. Make everything writeable before attempting to delete. We
		// do this only after the first RemoveAll attempt, in case there are a
		// large number of files.
		if _, err2 := exec.RunCwd(context.TODO(), ".", "chmod", "-R", "+w", deleteDir); err2 != nil {
			sklog.Errorf("Failed to remove git.TempCheckout with: %s; and failed to make writeable with: %s", err, err2)
			return
		}
		if err := os.RemoveAll(deleteDir); err != nil {
			sklog.Errorf("Failed to remove git.TempCheckout despite making writeable: %s", err)
		}
	}
}