package mdb

import (
	"fmt"
	"reflect"
	"testing"
)

func TestFullMapIndex(t *testing.T) {

	// Test against the emailMap index.
	run := func(name string, inner func(t *testing.T, db *DB) map[string]*User) {
		testWithDB(t, name, func(t *testing.T, db *DB) {
			expected := inner(t, db)

			if err := db.Users.emailMap.EqualsMap(expected); err != nil {
				t.Fatal(err)
			}

			db.Close()
			db = OpenDB(db.root, true)

			if err := db.Users.emailMap.EqualsMap(expected); err != nil {
				t.Fatal(err)
			}
		})
	}

	run("insert", func(t *testing.T, db *DB) map[string]*User {
		users := map[string]*User{}

		for i := uint64(1); i < 10; i++ {
			user := &User{
				ID:    db.Users.c.NextID(),
				Email: fmt.Sprintf("a.%d@c.com", i),
				Name:  fmt.Sprintf("name.%d", i),
				ExtID: fmt.Sprintf("EXTID.%d", i),
			}

			user2, err := db.Users.c.Insert(*user)
			if err != nil {
				t.Fatal(err)
			}
			if !reflect.DeepEqual(*user, user2) {
				t.Fatal(*user, user2)
			}
			users[user.Email] = user
		}

		return users
	})

	// TODO: insert duplicate

	run("delete", func(t *testing.T, db *DB) map[string]*User {
		users := map[string]*User{}

		for i := uint64(1); i < 10; i++ {
			user := &User{
				ID:    db.Users.c.NextID(),
				Email: fmt.Sprintf("a.%d@c.com", i),
				Name:  fmt.Sprintf("name.%d", i),
				ExtID: fmt.Sprintf("EXTID.%d", i),
			}

			user2, err := db.Users.c.Insert(*user)
			if err != nil {
				t.Fatal(err)
			}
			if !reflect.DeepEqual(*user, user2) {
				t.Fatal(*user, user2)
			}
			users[user.Email] = user
		}

		var id string
		for key := range users {
			id = key
			break
		}

		delete(users, id)
		db.Users.emailMap.Delete(id)

		return users
	})

	run("update non-indexed field", func(t *testing.T, db *DB) map[string]*User {
		users := map[string]*User{}

		for i := uint64(1); i < 10; i++ {
			user := &User{
				ID:    db.Users.c.NextID(),
				Email: fmt.Sprintf("a.%d@c.com", i),
				Name:  fmt.Sprintf("name.%d", i),
				ExtID: fmt.Sprintf("EXTID.%d", i),
			}

			user2, err := db.Users.c.Insert(*user)
			if err != nil {
				t.Fatal(err)
			}
			if !reflect.DeepEqual(*user, user2) {
				t.Fatal(*user, user2)
			}
			users[user.Email] = user
		}

		var id string
		for key := range users {
			id = key
			break
		}

		err := db.Users.emailMap.Update(id, func(u User) (User, error) {
			u.Name = "UPDATED"
			return u, nil
		})
		if err != nil {
			t.Fatal(err)
		}

		users[id].Name = "UPDATED"

		return users
	})

	run("update indexed field", func(t *testing.T, db *DB) map[string]*User {
		users := map[string]*User{}

		for i := uint64(1); i < 10; i++ {
			user := &User{
				ID:    db.Users.c.NextID(),
				Email: fmt.Sprintf("a.%d@c.com", i),
				Name:  fmt.Sprintf("name.%d", i),
				ExtID: fmt.Sprintf("EXTID.%d", i),
			}

			user2, err := db.Users.c.Insert(*user)
			if err != nil {
				t.Fatal(err)
			}
			if !reflect.DeepEqual(*user, user2) {
				t.Fatal(*user, user2)
			}
			users[user.Email] = user
		}

		var id uint64
		var email string
		for key := range users {
			email = key
			id = users[key].ID
			break
		}

		err := db.Users.c.Update(id, func(u User) (User, error) {
			u.Email = "test@x.com"
			return u, nil
		})
		if err != nil {
			t.Fatal(err)
		}

		user := users[email]
		user.Email = "test@x.com"
		delete(users, email)
		users[user.Email] = user

		return users
	})

	// update index field change key error

	// update error from func
	// update w/ ErrAbortUpdate
	// update not found.
	// update conflict.
}

func TestPartialMapIndex(t *testing.T) {
	// insert into index
	// insert into index conflict
	// insert outside index
	// insert and delete in index
	// insert and delete outside index
	// insert withing index
	// update out of index
	// update into index
	// update error from func
	// udpate ErrAbortUpdate
	// update not found
	// update conflict in to in
	// update conflict out to in
}