package storage

import (
	"fmt"
	"strings"
)

type DB interface {
	Get(string) ([]byte, error)
	Set(string, []byte) error
	Close() error
}

var DefaultNamespace = "namespace"

type Type int

const (
	MAP             = Type(iota)
	BOLT            = Type(iota)
	CACHE           = Type(iota)
	LEVELDB         = Type(iota)
	MEMCACHE        = Type(iota)
	MEMCACHECLUSTER = Type(iota)
	MONGO           = Type(iota)
)

func (t Type) String() string {
	switch t {
	case MAP:
		return "map"
	case BOLT:
		return "bolt"
	case CACHE:
		return "cache"
	case LEVELDB:
		return "leveldb"
	case MEMCACHE:
		return "memcache"
	case MEMCACHECLUSTER:
		return "memcachecluster"
	case MONGO:
		return "mongo"
	}
	return "<unknown>"
}

func TypeFromString(key string) Type {
	key = strings.ToLower(key)
	for i := 0; i < 30; i++ {
		t := Type(i)
		if t.String() == key {
			return t
		}
	}
	return Type(-1)
}

func New(key Type, params ...string) (db DB, err error) {
	defer func() {
		if i := recover(); i != nil {
			err = fmt.Errorf("panic making %s: %v", key, i)
		}
	}()
	err = ErrNotImpl
	switch key {
	case MAP:
		db = NewMap()
	case BOLT:
		db, err = NewBolt(params[0])
	case CACHE:
		db, err = NewCache(params...)
	case LEVELDB:
		db, err = NewLevelDB(params[0])
	case MEMCACHE:
		db, err = NewMemcache(params[0], params[1:]...)
	case MEMCACHECLUSTER:
		db, err = NewMemcacheCluster(params[0], params[1:]...)
	case MONGO:
		db, err = NewMongo(params[0], params[1:]...)
	}
	return
}