// Copyright 2016 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package sbtree_test

import (
	"reflect"
	"testing"

	"v.io/v23/syncbase"
	"v.io/v23/vdl"
	_ "v.io/x/ref/runtime/factories/generic"
	"v.io/x/ref/services/debug/debug/browseserver/sbtree"
	tu "v.io/x/ref/services/syncbase/testutil"
)

func TestEmptyCollection(t *testing.T) {
	ctx, serverName, cleanup := tu.SetupOrDie(nil)
	defer cleanup()
	var (
		service = syncbase.NewService(serverName)
		db      = tu.CreateDatabase(t, ctx, service, "the_db", nil)
		coll    = tu.CreateCollection(t, ctx, db, "the_collection")
	)

	got := sbtree.AssembleCollectionTree(
		ctx,
		serverName,
		db.Id().Blessing,
		"the_db",
		coll.Id().Blessing,
		"the_collection",
		"",
		100,
	)

	if got.Service.FullName() != serverName {
		t.Errorf("got %q, want %q", got.Service.FullName(), serverName)
	}
	if got.Database.Id().Name != "the_db" {
		t.Errorf(`got %q, want "the_db"`, got.Database.Id().Name)
	}
	if got.Collection.Id().Name != "the_collection" {
		t.Errorf(`got %q, want "the_collection"`, got.Database.Id().Name)
	}
	if got.RowCount != 0 {
		t.Errorf("got %d rows, want none", got.RowCount)
	}
	if got.TotKeySize != 0 {
		t.Errorf("got %d bytes of keys, want zero", got.TotKeySize)
	}
	if got.KeysPage.HasPrev {
		t.Error("Got previous page, want no previous page")
	}
	if len(got.KeysPage.KeyVals) != 0 {
		t.Errorf("Want no keys, got %v (length %d)",
			got.KeysPage.KeyVals, len(got.KeysPage.KeyVals))
	}
	if got.KeysPage.NextKey != "" {
		t.Errorf("Got %q, want empty string", got.KeysPage.NextKey)
	}
}

func TestSingleKeysPage(t *testing.T) {
	ctx, serverName, cleanup := tu.SetupOrDie(nil)
	defer cleanup()
	var (
		service        = syncbase.NewService(serverName)
		db             = tu.CreateDatabase(t, ctx, service, "the_db", nil)
		coll           = tu.CreateCollection(t, ctx, db, "the_collection")
		wantTotKeySize = len("Bravo") + len("Alfa") + len("Delta") + len("Charlie")
	)
	// Put keys of sundry types in non-alphabethical order
	coll.Put(ctx, "Bravo", int64(9999))
	coll.Put(ctx, "Alfa", complex(11, 22))
	coll.Put(ctx, "Delta", "something")
	coll.Put(ctx, "Charlie", 'x')

	got := sbtree.AssembleCollectionTree(
		ctx,
		serverName,
		db.Id().Blessing,
		"the_db",
		coll.Id().Blessing,
		"the_collection",
		"",
		100,
	)

	if got.RowCount != 4 {
		t.Errorf("got %d rows, want 4", got.RowCount)
	}
	if int(got.TotKeySize) != wantTotKeySize {
		t.Errorf("got %d bytes of keys, want %d", got.TotKeySize, wantTotKeySize)
	}
	if got.KeysPage.HasPrev {
		t.Error("Got previous page, want no previous page")
	}
	if len(got.KeysPage.KeyVals) != 4 {
		t.Errorf("Wanted 4 keys, got %v (length %d)",
			got.KeysPage.KeyVals, len(got.KeysPage.KeyVals))
	}
	for i := 0; i < 4; i++ {
		if got.KeysPage.KeyVals[i].Index != i {
			t.Errorf("got %d, want %d", got.KeysPage.KeyVals[i].Index, i)
		}
	}
	// Make sure keys come back in alphabetical order
	for i, want := range []string{"Alfa", "Bravo", "Charlie", "Delta"} {
		if got.KeysPage.KeyVals[i].Key != want {
			t.Errorf("got %q, want %q", got.KeysPage.KeyVals[i].Key, want)
		}
	}
	for i, want := range []interface{}{complex(11, 22), int64(9999), 'x', "something"} {
		if val := vdl.ValueOf(want); !reflect.DeepEqual(got.KeysPage.KeyVals[i].Value, val) {
			t.Errorf("got %v of type %T, want %v of type %T",
				got.KeysPage.KeyVals[i].Value, got.KeysPage.KeyVals[i].Value, val, val)
		}
	}

	if got.KeysPage.NextKey != "" {
		t.Errorf("Got %q, want empty string", got.KeysPage.NextKey)
	}
}

func TestFirstOfMultiplePages(t *testing.T) {
	ctx, serverName, cleanup := tu.SetupOrDie(nil)
	defer cleanup()
	var (
		service = syncbase.NewService(serverName)
		db      = tu.CreateDatabase(t, ctx, service, "the_db", nil)
		coll    = tu.CreateCollection(t, ctx, db, "the_collection")
	)
	// Ten keys, in pages of four, starting with the first key
	coll.Put(ctx, "555", 99)
	coll.Put(ctx, "000", 99)
	coll.Put(ctx, "999", 99)
	coll.Put(ctx, "111", 99)
	coll.Put(ctx, "444", 99)
	coll.Put(ctx, "666", 99)
	coll.Put(ctx, "222", 99)
	coll.Put(ctx, "777", 99)
	coll.Put(ctx, "333", 99)
	coll.Put(ctx, "888", 99)
	got := sbtree.AssembleCollectionTree(
		ctx,
		serverName,
		db.Id().Blessing,
		"the_db",
		coll.Id().Blessing,
		"the_collection",
		"",
		4,
	)

	if got.RowCount != 10 {
		t.Errorf("got %d rows, want 10", got.RowCount)
	}
	if int(got.TotKeySize) != 30 { // 10 keys, each of length 3
		t.Errorf("got %d bytes of keys, want 30", got.TotKeySize)
	}
	if got.KeysPage.HasPrev {
		t.Error("Got previous page, want no previous page")
	}
	if len(got.KeysPage.KeyVals) != 4 {
		t.Errorf("Wanted 4 keys, got %v (length %d)",
			got.KeysPage.KeyVals, len(got.KeysPage.KeyVals))
	}
	for i := 0; i < 4; i++ {
		if got.KeysPage.KeyVals[i].Index != i {
			t.Errorf("got %d, want %d", got.KeysPage.KeyVals[i].Index, i)
		}
	}
	for i, want := range []string{"000", "111", "222", "333"} {
		if got.KeysPage.KeyVals[i].Key != want {
			t.Errorf("got %q, want %q", got.KeysPage.KeyVals[i].Key, want)
		}
	}
	if got.KeysPage.NextKey != "444" {
		t.Errorf(`Got %q, want "444"`, got.KeysPage.NextKey)
	}
}

func TestMiddleOfMultiplePages(t *testing.T) {
	ctx, serverName, cleanup := tu.SetupOrDie(nil)
	defer cleanup()
	var (
		service = syncbase.NewService(serverName)
		db      = tu.CreateDatabase(t, ctx, service, "the_db", nil)
		coll    = tu.CreateCollection(t, ctx, db, "the_collection")
	)
	// Ten keys, in pages of four, starting with fifth key
	coll.Put(ctx, "555", 99)
	coll.Put(ctx, "000", 99)
	coll.Put(ctx, "999", 99)
	coll.Put(ctx, "111", 99)
	coll.Put(ctx, "444", 99)
	coll.Put(ctx, "666", 99)
	coll.Put(ctx, "222", 99)
	coll.Put(ctx, "777", 99)
	coll.Put(ctx, "333", 99)
	coll.Put(ctx, "888", 99)
	got := sbtree.AssembleCollectionTree(
		ctx,
		serverName,
		db.Id().Blessing,
		"the_db",
		coll.Id().Blessing,
		"the_collection",
		"444",
		4,
	)

	if got.RowCount != 10 {
		t.Errorf("got %d rows, want 10", got.RowCount)
	}
	if int(got.TotKeySize) != 30 { // 10 keys, each of length 3
		t.Errorf("got %d bytes of keys, want 30", got.TotKeySize)
	}
	if !got.KeysPage.HasPrev {
		t.Error("No previous page, want previous page")
	}
	if len(got.KeysPage.KeyVals) != 4 {
		t.Errorf("Wanted 4 keys, got %v (length %d)",
			got.KeysPage.KeyVals, len(got.KeysPage.KeyVals))
	}
	for i := 0; i < 4; i++ {
		if got.KeysPage.KeyVals[i].Index != i+4 {
			t.Errorf("got %d, want %d", got.KeysPage.KeyVals[i].Index, i+4)
		}
	}
	for i, want := range []string{"444", "555", "666", "777"} {
		if got.KeysPage.KeyVals[i].Key != want {
			t.Errorf("got %q, want %q", got.KeysPage.KeyVals[i].Key, want)
		}
	}
	if got.KeysPage.NextKey != "888" {
		t.Errorf(`Got %q, want "888"`, got.KeysPage.NextKey)
	}
}

func TestLastOfMultiplePages(t *testing.T) {
	ctx, serverName, cleanup := tu.SetupOrDie(nil)
	defer cleanup()
	var (
		service = syncbase.NewService(serverName)
		db      = tu.CreateDatabase(t, ctx, service, "the_db", nil)
		coll    = tu.CreateCollection(t, ctx, db, "the_collection")
	)
	// Ten keys, in pages of four, starting with ninth key.
	coll.Put(ctx, "555", 99)
	coll.Put(ctx, "000", 99)
	coll.Put(ctx, "999", 99)
	coll.Put(ctx, "111", 99)
	coll.Put(ctx, "444", 99)
	coll.Put(ctx, "666", 99)
	coll.Put(ctx, "222", 99)
	coll.Put(ctx, "777", 99)
	coll.Put(ctx, "333", 99)
	coll.Put(ctx, "888", 99)
	got := sbtree.AssembleCollectionTree(
		ctx,
		serverName,
		db.Id().Blessing,
		"the_db",
		coll.Id().Blessing,
		"the_collection",
		"888",
		4,
	)

	if got.RowCount != 10 {
		t.Errorf("got %d rows, want 10", got.RowCount)
	}
	if int(got.TotKeySize) != 30 { // 10 keys, each of length 3
		t.Errorf("got %d bytes of keys, want 30", got.TotKeySize)
	}
	if !got.KeysPage.HasPrev {
		t.Error("No previous page, want previous page")
	}
	if len(got.KeysPage.KeyVals) != 2 {
		t.Errorf("Wanted 2 keys, got %v (length %d)",
			got.KeysPage.KeyVals, len(got.KeysPage.KeyVals))
	}
	for i := 0; i < 2; i++ {
		if got.KeysPage.KeyVals[i].Index != i+8 {
			t.Errorf("got %d, want %d", got.KeysPage.KeyVals[i].Index, i+8)
		}
	}
	// Make sure keys come back in alphabetical order.
	for i, want := range []string{"888", "999"} {
		if got.KeysPage.KeyVals[i].Key != want {
			t.Errorf("got %q, want %q", got.KeysPage.KeyVals[i].Key, want)
		}
	}
	if got.KeysPage.NextKey != "" {
		t.Errorf(`Got %q, want empty string`, got.KeysPage.NextKey)
	}
}

func TestNonBuiltInType(t *testing.T) {
	ctx, serverName, cleanup := tu.SetupOrDie(nil)
	defer cleanup()
	var (
		service = syncbase.NewService(serverName)
		db      = tu.CreateDatabase(t, ctx, service, "the_db", nil)
		coll    = tu.CreateCollection(t, ctx, db, "the_collection")
	)
	type childType struct {
		I int64
		C complex128
	}
	type someCustomType struct {
		S string
		R rune
		C childType
	}
	err := coll.Put(ctx, "the key",
		someCustomType{"something", 'x', childType{9999, complex(11, 22)}})
	if err != nil {
		t.Fatal(err)
	}

	got := sbtree.AssembleCollectionTree(
		ctx,
		serverName,
		db.Id().Blessing,
		"the_db",
		coll.Id().Blessing,
		"the_collection",
		"",
		100,
	)

	if got.RowCount != 1 {
		t.Fatalf("got %d rows, want 1", got.RowCount)
	}
	if len(got.KeysPage.KeyVals) != 1 {
		t.Errorf("Wanted 1 keys, got %v (length %d)",
			got.KeysPage.KeyVals, len(got.KeysPage.KeyVals))
	}
	value := got.KeysPage.KeyVals[0].Value.(*vdl.Value)
	if value.Type() != vdl.TypeOf(someCustomType{}) {
		t.Fatalf("Got %v of type %T, want of type someCustomType",
			value, value.Type)
	}
	want := vdl.ValueOf(someCustomType{"something", 'x', childType{9999, complex(11, 22)}})
	if !reflect.DeepEqual(value, want) {
		t.Errorf("Got %v, want %v", value, want)
	}
}