package fs_clstore

import (
	"context"
	"strconv"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.skia.org/infra/go/firestore"
	"go.skia.org/infra/go/testutils/unittest"
	"go.skia.org/infra/golden/go/clstore"
	"go.skia.org/infra/golden/go/code_review"
)

func TestPutGetChangelist(t *testing.T) {
	unittest.LargeTest(t)
	c, cleanup := firestore.NewClientForTesting(context.Background(), t)
	defer cleanup()

	f := New(c, "gerrit")
	ctx := context.Background()

	expectedID := "987654"

	// Should not exist initially
	_, err := f.GetChangelist(ctx, expectedID)
	require.Error(t, err)
	require.Equal(t, clstore.ErrNotFound, err)

	cl := code_review.Changelist{
		SystemID: expectedID,
		Owner:    "test@example.com",
		Status:   code_review.Abandoned,
		Subject:  "some code",
		Updated:  time.Date(2019, time.August, 13, 12, 11, 10, 0, time.UTC),
	}

	err = f.PutChangelist(ctx, cl)
	require.NoError(t, err)

	actual, err := f.GetChangelist(ctx, expectedID)
	require.NoError(t, err)
	require.Equal(t, cl, actual)
}

func TestPutGetPatchset(t *testing.T) {
	unittest.LargeTest(t)
	c, cleanup := firestore.NewClientForTesting(context.Background(), t)
	defer cleanup()

	f := New(c, "gerrit")
	ctx := context.Background()

	expectedCLID := "987654"
	expectedPSID := "abcdef012345"

	// Should not exist initially
	_, err := f.GetPatchset(ctx, expectedCLID, expectedPSID)
	require.Error(t, err)
	require.Equal(t, clstore.ErrNotFound, err)

	ps := code_review.Patchset{
		SystemID:                      expectedPSID,
		ChangelistID:                  expectedCLID,
		Order:                         3,
		GitHash:                       "fedcba98765443321",
		LastCheckedIfCommentNecessary: time.Date(2020, time.May, 1, 2, 3, 4, 0, time.UTC),
		CommentedOnCL:                 true,
	}

	err = f.PutPatchset(ctx, ps)
	require.NoError(t, err)

	actual, err := f.GetPatchset(ctx, expectedCLID, expectedPSID)
	require.NoError(t, err)
	require.Equal(t, ps, actual)
}

func TestPutGetPatchsetByOrder(t *testing.T) {
	unittest.LargeTest(t)
	c, cleanup := firestore.NewClientForTesting(context.Background(), t)
	defer cleanup()

	f := New(c, "gerrit")
	ctx := context.Background()

	expectedCLID := "987654"
	expectedPSOrder := 3
	otherPSOrder := 117

	// Should not exist initially
	_, err := f.GetPatchsetByOrder(ctx, expectedCLID, expectedPSOrder)
	require.Error(t, err)
	require.Equal(t, clstore.ErrNotFound, err)

	ps := code_review.Patchset{
		SystemID:     "abcdef012345",
		ChangelistID: expectedCLID,
		Order:        expectedPSOrder,
		GitHash:      "fedcba98765443321",
	}

	err = f.PutPatchset(ctx, ps)
	require.NoError(t, err)

	ps2 := code_review.Patchset{
		SystemID:     "zyx9876",
		ChangelistID: expectedCLID,
		Order:        otherPSOrder,
		GitHash:      "notthisone",
	}

	err = f.PutPatchset(ctx, ps2)
	require.NoError(t, err)

	actual, err := f.GetPatchsetByOrder(ctx, expectedCLID, expectedPSOrder)
	require.NoError(t, err)
	require.Equal(t, ps, actual)

	actual, err = f.GetPatchsetByOrder(ctx, expectedCLID, otherPSOrder)
	require.NoError(t, err)
	require.Equal(t, ps2, actual)
}

// TestDifferentSystems makes sure that two systems in the same
// firestore namespace don't overlap.
func TestDifferentSystems(t *testing.T) {
	unittest.LargeTest(t)
	c, cleanup := firestore.NewClientForTesting(context.Background(), t)
	defer cleanup()

	gerrit := New(c, "gerrit")
	github := New(c, "github")
	ctx := context.Background()

	expectedCLID := "987654"

	gerritCL := code_review.Changelist{
		SystemID: expectedCLID,
		Owner:    "test@example.com",
		Status:   code_review.Abandoned,
		Subject:  "some code on gerrit",
		Updated:  time.Date(2019, time.August, 13, 12, 11, 10, 0, time.UTC),
	}

	githubCL := code_review.Changelist{
		SystemID: expectedCLID,
		Owner:    "test2@example.com",
		Status:   code_review.Open,
		Subject:  "some code on github",
		Updated:  time.Date(2019, time.August, 15, 12, 11, 10, 0, time.UTC),
	}

	// Both systems have a CL with the same ID
	err := gerrit.PutChangelist(ctx, gerritCL)
	require.NoError(t, err)
	err = github.PutChangelist(ctx, githubCL)
	require.NoError(t, err)

	actualGerrit, err := gerrit.GetChangelist(ctx, expectedCLID)
	require.NoError(t, err)
	actualGithub, err := github.GetChangelist(ctx, expectedCLID)
	require.NoError(t, err)

	require.NotEqual(t, actualGerrit, actualGithub)
	require.Equal(t, gerritCL, actualGerrit)
	require.Equal(t, githubCL, actualGithub)
}

// TestGetPatchsets stores several patchsets and then makes sure we can fetch the ones
// for a specific CL and they arrive sorted by Order, even if the Patchsets are sparse.
func TestGetPatchsets(t *testing.T) {
	unittest.LargeTest(t)
	c, cleanup := firestore.NewClientForTesting(context.Background(), t)
	defer cleanup()

	f := New(c, "gerrit")
	ctx := context.Background()

	expectedID := "987654"
	sparseID := "sparse"
	// None should exist initially
	xps, err := f.GetPatchsets(ctx, expectedID)
	require.NoError(t, err)
	require.Empty(t, xps)

	// Create the Changelist, but don't add any Patchsets yet.
	err = f.PutChangelist(ctx, code_review.Changelist{SystemID: expectedID})
	require.NoError(t, err)

	// Still no Patchsets
	xps, err = f.GetPatchsets(ctx, expectedID)
	require.NoError(t, err)
	require.Empty(t, xps)

	for i := 0; i < 3; i++ {
		ps := code_review.Patchset{
			SystemID:     "other_id" + strconv.Itoa(i),
			ChangelistID: "not this CL",
			GitHash:      "nope",
			Order:        i + 1,
		}
		require.NoError(t, f.PutPatchset(ctx, ps))
	}
	// use random ids to make sure the we are truly sorting on ids
	randIDs := []string{"zkdf", "bkand", "d-sd9f9s3n", "csdfksdfn1"}
	// put them in backwards to make sure they get resorted by order
	for i := 4; i > 0; i-- {
		ps := code_review.Patchset{
			// use an ID
			SystemID:     randIDs[i-1],
			ChangelistID: expectedID,
			GitHash:      "whatever",
			Order:        i,
		}
		require.NoError(t, f.PutPatchset(ctx, ps))
	}

	for i := 0; i < 9; i += 3 {
		ps := code_review.Patchset{
			SystemID:     "other_other_id" + strconv.Itoa(20-i),
			ChangelistID: sparseID,
			GitHash:      "sparse",
			Order:        i + 1,
		}
		require.NoError(t, f.PutPatchset(ctx, ps))
	}

	// Check that sequential orders work
	xps, err = f.GetPatchsets(ctx, expectedID)
	require.NoError(t, err)
	require.Len(t, xps, 4)
	// Make sure they are in order
	for i, ps := range xps {
		require.Equal(t, i+1, ps.Order)
		require.Equal(t, expectedID, ps.ChangelistID)
		require.Equal(t, "whatever", ps.GitHash)
	}

	// Check that sparse patchsets work.
	xps, err = f.GetPatchsets(ctx, sparseID)
	require.NoError(t, err)
	require.Len(t, xps, 3)
	// Make sure they are in order
	for i, ps := range xps {
		require.Equal(t, i*3+1, ps.Order)
		require.Equal(t, sparseID, ps.ChangelistID)
		require.Equal(t, "sparse", ps.GitHash)
	}
}

func TestGetChangelists(t *testing.T) {
	unittest.LargeTest(t)
	c, cleanup := firestore.NewClientForTesting(context.Background(), t)
	defer cleanup()

	f := New(c, "gerrit")
	ctx := context.Background()

	// None to start
	cls, total, err := f.GetChangelists(ctx, clstore.SearchOptions{
		StartIdx: 0,
		Limit:    50,
	})
	require.NoError(t, err)
	require.Len(t, cls, 0)
	require.Equal(t, 0, total)

	for i := 0; i < 40; i += 2 {
		cl := code_review.Changelist{
			SystemID: "cl" + strconv.Itoa(i),
			Owner:    "test@example.com",
			Status:   code_review.Open,
			Subject:  "blarg",
			Updated:  time.Date(2019, time.August, 31, 14, i, i, 0, time.UTC),
		}
		require.NoError(t, f.PutChangelist(ctx, cl))
	}

	// Put in a few other ones:
	for i := 1; i < 10; i += 2 {
		cl := code_review.Changelist{
			SystemID: "cl" + strconv.Itoa(i),
			Owner:    "test@example.com",
			Status:   code_review.Abandoned,
			Subject:  "blarg",
			Updated:  time.Date(2019, time.September, 1, 4, i, i, 0, time.UTC),
		}
		require.NoError(t, f.PutChangelist(ctx, cl))
	}

	for i := 31; i < 40; i += 2 {
		cl := code_review.Changelist{
			SystemID: "cl" + strconv.Itoa(i),
			Owner:    "test@example.com",
			Status:   code_review.Landed,
			Subject:  "blarg",
			Updated:  time.Date(2019, time.September, 1, 2, i, i, 0, time.UTC),
		}
		require.NoError(t, f.PutChangelist(ctx, cl))
	}

	// Get all of them
	cls, total, err = f.GetChangelists(ctx, clstore.SearchOptions{
		StartIdx: 0,
		Limit:    50,
	})
	require.NoError(t, err)
	require.Len(t, cls, 30)
	require.Equal(t, 30, total)

	// Get the first ones
	cls, total, err = f.GetChangelists(ctx, clstore.SearchOptions{
		StartIdx: 0,
		Limit:    3,
	})
	require.NoError(t, err)
	require.Len(t, cls, 3)
	require.Equal(t, clstore.CountMany, total)
	// spot check the dates to make sure the CLs are in the right order.
	require.Equal(t, time.Date(2019, time.September, 1, 4, 9, 9, 0, time.UTC), cls[0].Updated)
	require.Equal(t, time.Date(2019, time.September, 1, 4, 7, 7, 0, time.UTC), cls[1].Updated)
	require.Equal(t, time.Date(2019, time.September, 1, 4, 5, 5, 0, time.UTC), cls[2].Updated)

	// Get some in the middle
	cls, total, err = f.GetChangelists(ctx, clstore.SearchOptions{
		StartIdx: 5,
		Limit:    2,
	})
	require.NoError(t, err)
	require.Len(t, cls, 2)
	require.Equal(t, clstore.CountMany, total)
	require.Equal(t, time.Date(2019, time.September, 1, 2, 39, 39, 0, time.UTC), cls[0].Updated)
	require.Equal(t, time.Date(2019, time.September, 1, 2, 37, 37, 0, time.UTC), cls[1].Updated)

	// Get some at the end.
	cls, total, err = f.GetChangelists(ctx, clstore.SearchOptions{
		StartIdx: 28,
		Limit:    10,
	})
	require.NoError(t, err)
	require.Len(t, cls, 2)
	require.Equal(t, 30, total)
	require.Equal(t, time.Date(2019, time.August, 31, 14, 2, 2, 0, time.UTC), cls[0].Updated)
	require.Equal(t, time.Date(2019, time.August, 31, 14, 0, 0, 0, time.UTC), cls[1].Updated)

	// If we query off the end, we don't know how many there are, so 0 is a fine response.
	cls, total, err = f.GetChangelists(ctx, clstore.SearchOptions{
		StartIdx: 999,
		Limit:    3,
	})
	require.NoError(t, err)
	require.Len(t, cls, 0)
	require.Equal(t, 999, total)
}

// TestGetChangelistsOptions checks that various search options function.
func TestGetChangelistsOptions(t *testing.T) {
	unittest.LargeTest(t)
	c, cleanup := firestore.NewClientForTesting(context.Background(), t)
	defer cleanup()

	f := New(c, "gerrit")
	ctx := context.Background()
	clA := code_review.Changelist{
		SystemID: "abc",
		Owner:    "first@example.com",
		Status:   code_review.Open,
		Subject:  "Open sesame",
		Updated:  time.Date(2019, time.October, 5, 4, 3, 2, 0, time.UTC),
	}
	clB := code_review.Changelist{
		SystemID: "def",
		Owner:    "second@example.com",
		Status:   code_review.Landed,
		Subject:  "Landed Panda",
		Updated:  time.Date(2019, time.October, 10, 4, 3, 2, 0, time.UTC),
	}
	clC := code_review.Changelist{
		SystemID: "ghi",
		Owner:    "third@example.com",
		Status:   code_review.Open,
		Subject:  "Open again",
		Updated:  time.Date(2019, time.October, 15, 4, 3, 2, 0, time.UTC),
	}

	require.NoError(t, f.PutChangelist(ctx, clA))
	require.NoError(t, f.PutChangelist(ctx, clB))
	require.NoError(t, f.PutChangelist(ctx, clC))

	xcl, _, err := f.GetChangelists(ctx, clstore.SearchOptions{
		Limit: 10,
	})
	require.NoError(t, err)
	assert.Equal(t, []code_review.Changelist{clC, clB, clA}, xcl)

	xcl, _, err = f.GetChangelists(ctx, clstore.SearchOptions{
		OpenCLsOnly: true,
		Limit:       10,
	})
	require.NoError(t, err)
	assert.Equal(t, []code_review.Changelist{clC, clA}, xcl)

	xcl, _, err = f.GetChangelists(ctx, clstore.SearchOptions{
		After: time.Date(2019, time.September, 28, 0, 0, 0, 0, time.UTC),
		Limit: 10,
	})
	require.NoError(t, err)
	assert.Equal(t, []code_review.Changelist{clC, clB, clA}, xcl)

	xcl, _, err = f.GetChangelists(ctx, clstore.SearchOptions{
		After: time.Date(2019, time.November, 28, 0, 0, 0, 0, time.UTC),
		Limit: 10,
	})
	require.NoError(t, err)
	assert.Empty(t, xcl)

	xcl, _, err = f.GetChangelists(ctx, clstore.SearchOptions{
		After: time.Date(2019, time.October, 7, 0, 0, 0, 0, time.UTC),
		Limit: 10,
	})
	require.NoError(t, err)
	assert.Equal(t, []code_review.Changelist{clC, clB}, xcl)
	xcl, _, err = f.GetChangelists(ctx, clstore.SearchOptions{
		OpenCLsOnly: true,
		After:       time.Date(2019, time.October, 7, 0, 0, 0, 0, time.UTC),
		Limit:       10,
	})
	require.NoError(t, err)
	assert.Equal(t, []code_review.Changelist{clC}, xcl)
}

func TestGetChangelistsNoLimit(t *testing.T) {
	unittest.LargeTest(t)
	c, cleanup := firestore.NewClientForTesting(context.Background(), t)
	defer cleanup()

	f := New(c, "gerrit")
	ctx := context.Background()

	_, _, err := f.GetChangelists(ctx, clstore.SearchOptions{})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "limit")
}