package git

import (
	"testing"
	"time"
)

func createBranch(repo *Repository, branch string) error {
	head, err := repo.Head()
	if err != nil {
		return err
	}
	commit, err := repo.LookupCommit(head.Target())
	if err != nil {
		return err
	}
	_, err = repo.CreateBranch(branch, commit, false)
	if err != nil {
		return err
	}

	return nil
}

func signature() *Signature {
	return &Signature{
		Name:  "Emile",
		Email: "emile@emile.com",
		When:  time.Now(),
	}
}

func commitSomething(repo *Repository, something string) (*Oid, error) {
	head, err := repo.Head()
	if err != nil {
		return nil, err
	}

	headCommit, err := repo.LookupCommit(head.Target())
	if err != nil {
		return nil, err
	}

	index, err := NewIndex()
	if err != nil {
		return nil, err
	}
	defer index.Free()

	blobOID, err := repo.CreateBlobFromBuffer([]byte("fou"))
	if err != nil {
		return nil, err
	}

	entry := &IndexEntry{
		Mode: FilemodeBlob,
		Id:   blobOID,
		Path: something,
	}

	if err := index.Add(entry); err != nil {
		return nil, err
	}

	newTreeOID, err := index.WriteTreeTo(repo)
	if err != nil {
		return nil, err
	}

	newTree, err := repo.LookupTree(newTreeOID)
	if err != nil {
		return nil, err
	}

	if err != nil {
		return nil, err
	}
	commit, err := repo.CreateCommit("HEAD", signature(), signature(), "Test rebase onto, Baby! "+something, newTree, headCommit)
	if err != nil {
		return nil, err
	}

	opts := &CheckoutOpts{
		Strategy: CheckoutRemoveUntracked | CheckoutForce,
	}
	err = repo.CheckoutIndex(index, opts)
	if err != nil {
		return nil, err
	}

	return commit, nil
}

func entryExists(repo *Repository, file string) bool {
	head, err := repo.Head()
	if err != nil {
		return false
	}
	headCommit, err := repo.LookupCommit(head.Target())
	if err != nil {
		return false
	}
	headTree, err := headCommit.Tree()
	if err != nil {
		return false
	}
	_, err = headTree.EntryByPath(file)

	return err == nil
}

func TestRebaseOnto(t *testing.T) {
	repo := createTestRepo(t)
	defer cleanupTestRepo(t, repo)

	fileInMaster := "something"
	fileInEmile := "something else"

	// Seed master
	seedTestRepo(t, repo)

	// Create a new branch from master
	err := createBranch(repo, "emile")
	checkFatal(t, err)

	// Create a commit in master
	_, err = commitSomething(repo, fileInMaster)
	checkFatal(t, err)

	// Switch to this emile
	err = repo.SetHead("refs/heads/emile")
	checkFatal(t, err)

	// Check master commit is not in emile branch
	if entryExists(repo, fileInMaster) {
		t.Fatal("something entry should not exist in emile branch")
	}

	// Create a commit in emile
	_, err = commitSomething(repo, fileInEmile)
	checkFatal(t, err)

	// Rebase onto master
	master, err := repo.LookupBranch("master", BranchLocal)
	branch, err := repo.AnnotatedCommitFromRef(master.Reference)
	checkFatal(t, err)

	rebase, err := repo.RebaseInit(nil, nil, branch, nil)
	checkFatal(t, err)
	defer rebase.Free()

	operation, err := rebase.Next()
	checkFatal(t, err)

	commit, err := repo.LookupCommit(operation.ID)
	checkFatal(t, err)

	err = rebase.Commit(operation.ID, signature(), signature(), commit.Message())
	checkFatal(t, err)

	rebase.Finish()

	// Check master commit is now also in emile branch
	if !entryExists(repo, fileInMaster) {
		t.Fatal("something entry should now exist in emile branch")
	}
}