// Copyright 2015 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 cache

import (
	"fmt"
	"reflect"
	"sync"
	"testing"

	"v.io/v23/context"
	"v.io/v23/security"
	"v.io/x/ref/internal/logger"
	"v.io/x/ref/test/testutil"
)

func createRoots() ([]byte, security.BlessingRoots, *cachedRoots) {
	var mu sync.RWMutex
	ctx, _ := context.RootContext()
	ctx = context.WithLogger(ctx, logger.Global())
	p := testutil.NewPrincipal()
	impl := p.Roots()
	roots, err := newCachedRoots(impl, &mu)
	if err != nil {
		panic(err)
	}
	keybytes, err := p.PublicKey().MarshalBinary()
	if err != nil {
		panic(err)
	}
	return keybytes, impl, roots
}

func TestCreateRoots(t *testing.T) {
	_, impl, cache := createRoots()
	if impl == security.BlessingRoots(cache) {
		t.Fatalf("Same roots")
	}
	if impl == nil || cache == nil {
		t.Fatalf("No roots %v %v", impl, cache)
	}
}

func expectRecognized(roots security.BlessingRoots, key []byte, blessing string) string {
	if err := roots.Recognized(key, blessing); err != nil {
		return fmt.Sprintf("Key (%s, %v) not matched by roots:\n%s, Recognized returns error: %v", key, blessing, roots.DebugString(), err)
	}
	return ""
}

func expectNotRecognized(roots security.BlessingRoots, key []byte, blessing string) string {
	if err := roots.Recognized(key, blessing); err == nil {
		return fmt.Sprintf("Key (%s, %s) should not match roots:\n%s", key, blessing, roots.DebugString())
	}
	return ""
}

func TestAddRoots(t *testing.T) {
	key, impl, cache := createRoots()
	if s := expectNotRecognized(impl, key, "alice"); s != "" {
		t.Error(s)
	}
	if s := expectNotRecognized(cache, key, "alice"); s != "" {
		t.Error(s)
	}

	if err := cache.Add(key, "alice:$"); err != nil {
		t.Fatalf("Add failed: %v", err)
	}
	if err := cache.Add(key, "bob"); err != nil {
		t.Fatalf("Add failed: %v", err)
	}
	if s := expectRecognized(impl, key, "alice"); s != "" {
		t.Error(s)
	}
	if s := expectRecognized(impl, key, "bob"); s != "" {
		t.Error(s)
	}
	if s := expectNotRecognized(impl, key, "alice:friend"); s != "" {
		t.Error(s)
	}
	if s := expectRecognized(impl, key, "bob:friend"); s != "" {
		t.Error(s)
	}
	if s := expectRecognized(cache, key, "alice"); s != "" {
		t.Error(s)
	}
	if s := expectRecognized(cache, key, "bob"); s != "" {
		t.Error(s)
	}
	if s := expectNotRecognized(cache, key, "alice:friend"); s != "" {
		t.Error(s)
	}
	if s := expectRecognized(cache, key, "bob:friend"); s != "" {
		t.Error(s)
	}

	if s := expectNotRecognized(impl, key, "carol"); s != "" {
		t.Error(s)
	}
	if s := expectNotRecognized(cache, key, "carol"); s != "" {
		t.Error(s)
	}
}

func TestNegativeCache(t *testing.T) {
	key, impl, cache := createRoots()

	if s := expectNotRecognized(cache, key, "alice"); s != "" {
		t.Error(s)
	}

	if err := impl.Add(key, "alice"); err != nil {
		t.Fatalf("Add failed: %v", err)
	}

	// Should return the cached error.
	if s := expectNotRecognized(cache, key, "alice"); s != "" {
		t.Error(s)
	}

	// Until we flush...
	cache.flush()
	if s := expectRecognized(cache, key, "alice"); s != "" {
		t.Error(s)
	}
}

func TestRootsDebugString(t *testing.T) {
	key, impl, cache := createRoots()

	if err := impl.Add(key, "alice:friend"); err != nil {
		t.Fatalf("Add failed: %v", err)
	}

	if a, b := impl.DebugString(), cache.DebugString(); a != b {
		t.Errorf("DebugString doesn't match. Expected:\n%s\nGot:\n%s", a, b)
	}
}

func TestRootsDump(t *testing.T) {
	key, impl, cache := createRoots()

	if err := cache.Add(key, "alice:friend"); err != nil {
		t.Fatalf("Add failed: %v", err)
	}

	orig := impl.Dump()
	if got := cache.Dump(); !reflect.DeepEqual(orig, got) {
		t.Errorf("Dump() got %v, want %v", got, orig)
	}

	impl.Add(key, "carol")
	if got := cache.Dump(); !reflect.DeepEqual(orig, got) {
		t.Errorf("Dump() got %v, want %v", got, orig)
	}

	cache.flush()
	if cur, got := impl.Dump(), cache.Dump(); !reflect.DeepEqual(cur, got) {
		t.Errorf("Dump() got %v, want %v", got, cur)
	}
}

func createStore(p security.Principal) (security.BlessingStore, *cachedStore) {
	var mu sync.RWMutex
	impl := p.BlessingStore()
	return impl, &cachedStore{mu: &mu, pubkey: p.PublicKey(), impl: impl}
}

func TestDefaultBlessing(t *testing.T) {
	p := testutil.NewPrincipal("bob")
	store, cache := createStore(p)

	bob, _ := store.Default()
	var notify <-chan struct{}
	var cached security.Blessings
	if cached, notify = cache.Default(); !reflect.DeepEqual(bob, cached) {
		t.Errorf("Default(): got: %v, want: %v", cached, bob)
	}

	alice, err := p.BlessSelf("alice")
	if err != nil {
		t.Fatalf("BlessSelf failed: %v", err)
	}
	err = store.SetDefault(alice)
	if err != nil {
		t.Fatalf("SetDefault failed: %v", err)
	}
	cache.flush()
	// This should trigger a notification (via closure of the channel)
	<-notify
	if cached, notify = cache.Default(); !reflect.DeepEqual(alice, cached) {
		t.Errorf("Default(): got: %v, want: %v", cached, alice)
	}

	carol, err := p.BlessSelf("carol")
	if err != nil {
		t.Fatalf("BlessSelf failed: %v", err)
	}
	err = cache.SetDefault(carol)
	if err != nil {
		t.Fatalf("SetDefault failed: %v", err)
	}
	<-notify

	if cur, _ := store.Default(); !reflect.DeepEqual(carol, cur) {
		t.Errorf("Default(): got: %v, want: %v", cur, carol)
	}
	if cached, notify = cache.Default(); !reflect.DeepEqual(carol, cached) {
		t.Errorf("Default(): got: %v, want: %v", cached, carol)
	}

	john, _ := testutil.NewPrincipal("john").BlessingStore().Default()
	if nil == cache.SetDefault(john) {
		t.Errorf("Expected error setting default with bad key.")
	}
	if cached, _ = cache.Default(); !reflect.DeepEqual(carol, cached) {
		t.Errorf("Default(): got: %v, want: %v", cached, carol)
	}

}

func TestSet(t *testing.T) {
	p := testutil.NewPrincipal("bob")
	store, cache := createStore(p)
	var noBlessings security.Blessings

	bob, _ := store.Default()
	alice, err := p.BlessSelf("alice")
	if err != nil {
		t.Fatalf("BlessSelf failed: %v", err)
	}
	john, _ := testutil.NewPrincipal("john").BlessingStore().Default()

	store.Set(noBlessings, "...")
	if _, err := cache.Set(bob, "bob"); err != nil {
		t.Errorf("Set() failed: %v", err)
	}

	if got := cache.ForPeer("bob:server"); !reflect.DeepEqual(bob, got) {
		t.Errorf("ForPeer(bob:server) got: %v, want: %v", got, bob)
	}

	blessings, err := cache.Set(noBlessings, "bob")
	if err != nil {
		t.Errorf("Set() failed: %v", err)
	}
	if !reflect.DeepEqual(bob, blessings) {
		t.Errorf("Previous blessings %v, wanted %v", blessings, bob)
	}
	if got, want := cache.ForPeer("bob:server"), (security.Blessings{}); !reflect.DeepEqual(want, got) {
		t.Errorf("ForPeer(bob:server) got: %v, want: %v", got, want)
	}

	blessings, err = cache.Set(john, "john")
	if err == nil {
		t.Errorf("No error from set")
	}
	if got := cache.ForPeer("john:server"); got.PublicKey() != nil {
		t.Errorf("ForPeer(john:server) got: %v, want: %v", got, nil)
	}

	blessings, err = cache.Set(bob, "...")
	if err != nil {
		t.Errorf("Set() failed: %v", err)
	}
	blessings, err = cache.Set(alice, "bob")
	if err != nil {
		t.Errorf("Set() failed: %v", err)
	}

	expected, err := security.UnionOfBlessings(bob, alice)
	if err != nil {
		t.Errorf("UnionOfBlessings failed: %v", err)
	}
	if got := cache.ForPeer("bob:server"); !reflect.DeepEqual(expected, got) {
		t.Errorf("ForPeer(bob:server) got: %v, want: %v", got, expected)
	}
}

func TestForPeerCaching(t *testing.T) {
	p := testutil.NewPrincipal("bob")
	store, cache := createStore(p)

	bob, _ := store.Default()
	alice, err := p.BlessSelf("alice")
	if err != nil {
		t.Fatalf("BlessSelf failed: %v", err)
	}

	store.Set(security.Blessings{}, "...")
	store.Set(bob, "bob")

	if got := cache.ForPeer("bob:server"); !reflect.DeepEqual(bob, got) {
		t.Errorf("ForPeer(bob:server) got: %v, want: %v", got, bob)
	}

	store.Set(alice, "bob")
	if got := cache.ForPeer("bob:server"); !reflect.DeepEqual(bob, got) {
		t.Errorf("ForPeer(bob:server) got: %v, want: %v", got, bob)
	}

	cache.flush()
	if got := cache.ForPeer("bob:server"); !reflect.DeepEqual(alice, got) {
		t.Errorf("ForPeer(bob:server) got: %v, want: %v", got, alice)
	}
}

func TestPeerBlessings(t *testing.T) {
	p := testutil.NewPrincipal("bob")
	store, cache := createStore(p)

	alice, err := p.BlessSelf("alice")
	if err != nil {
		t.Fatalf("BlessSelf failed: %v", err)
	}

	if _, err = cache.Set(alice, "alice"); err != nil {
		t.Errorf("Set() failed: %v", err)
	}

	orig := store.PeerBlessings()
	if got := cache.PeerBlessings(); !reflect.DeepEqual(orig, got) {
		t.Errorf("PeerBlessings() got %v, want %v", got, orig)
	}

	store.Set(alice, "carol")
	if got := cache.PeerBlessings(); !reflect.DeepEqual(orig, got) {
		t.Errorf("PeerBlessings() got %v, want %v", got, orig)
	}

	cache.flush()
	if cur, got := store.PeerBlessings(), cache.PeerBlessings(); !reflect.DeepEqual(cur, got) {
		t.Errorf("PeerBlessings() got %v, want %v", got, cur)
	}
}

func TestStoreDebugString(t *testing.T) {
	impl, cache := createStore(testutil.NewPrincipal("bob:friend:alice"))

	if a, b := impl.DebugString(), cache.DebugString(); a != b {
		t.Errorf("DebugString doesn't match. Expected:\n%s\nGot:\n%s", a, b)
	}
}