package storage

import (
	"bytes"
	"io/ioutil"
	"net"
	"os"
	"path"
	"testing"
)

type mock struct {
	m map[string][]byte
}

func (mock *mock) Get(key string) ([]byte, error) {
	v, ok := mock.m[key]
	if ok {
		return v, nil
	}
	return nil, ErrNotFound
}

func (mock *mock) Set(key string, value []byte) error {
	mock.m[key] = value
	return nil
}

func (mock *mock) Close() error {
	return nil
}

func TestImplementations(t *testing.T) {
	dir, err := ioutil.TempDir("", "storage_tests_")
	if err != nil {
		t.Fatalf("cannot create temp dir: %v", err)
		return
	}
	defer os.RemoveAll(dir)

	cases := make([]DB, 0)
	cases = append(cases, &mock{m: make(map[string][]byte)})
	cases = append(cases, NewMap())

	if cacheMem, err := NewCache(); err != nil {
		t.Errorf("cannot make cache/mem: %v", err)
	} else {
		cases = append(cases, cacheMem)
	}

	if cacheFile, err := NewCache(path.Join(dir, "cache")); err != nil {
		t.Errorf("cannot make cache/file: %v", err)
	} else {
		cases = append(cases, cacheFile)
	}

	if bolt, err := NewBolt(path.Join(dir, "bolt")); err != nil {
		t.Errorf("cannot make bolt: %v", err)
	} else {
		cases = append(cases, bolt)
	}

	if leveldb, err := NewLevelDB(path.Join(dir, "leveldb")); err != nil {
		t.Errorf("cannot make leveldb: %v", err)
	} else {
		cases = append(cases, leveldb)
	}

	riakLN, err := net.Listen("tcp", "localhost:8087")
	if err == nil {
		defer riakLN.Close()
		go func() {
			for {
				conn, err := riakLN.Accept()
				if err == nil {
					conn.Close()
				}
			}
		}()
	}
	if riak, err := NewRiak("localhost:8087"); err != nil {
		t.Errorf("cannot make riak: %v", err)
	} else {
		cases = append(cases, riak)
	}

	mongoLN, err := net.Listen("tcp", "localhost:27017")
	if err == nil {
		defer mongoLN.Close()
		go func() {
			for {
				conn, err := mongoLN.Accept()
				if err == nil {
					conn.Close()
				}
			}
		}()
	}
	if mongo1, err := NewMongo("localhost:27017"); err == nil {
		cases = append(cases, mongo1)
	} else if mongo2, err := NewMongo("localhost:27017", "root", "pass"); err == nil {
		cases = append(cases, mongo2)
	} else {
		t.Errorf("cannot make mongo: %v", err)
	}

	if memcache, err := NewMemcache("localhost:11211"); err != nil {
		t.Errorf("cannot make memcache: %v", err)
	} else {
		cases = append(cases, memcache)
	}

	validKey := "key"
	validValue := []byte("value")

	for _, db := range cases {
		if err := db.Set(validKey, validValue); err != nil {
			t.Errorf("cannot set %T: %v", db, err)
		}
		if v, err := db.Get(validKey); err != nil {
			t.Errorf("cannot get %T: %v", db, err)
		} else if !bytes.Equal(v, validValue) {
			t.Errorf("wrong get %T: %q vs %q", db, v, validValue)
		} else {
			t.Logf("%18T GET: %s", db, v)
		}
		if err := db.Close(); err != nil {
			t.Errorf("cannot close %T: %v", db, err)
		}
	}
}