package orm

import (
	"fmt"
	"net/http"
	"path"
	"reflect"
	"strings"

	"git.andreafazzi.eu/andrea/oef/config"
	"github.com/jinzhu/gorm"
	"github.com/jinzhu/inflection"

	_ "github.com/jinzhu/gorm/dialects/mysql"
)

type IDer interface {
	GetID() uint
}

type GetFn func(map[string]string, http.ResponseWriter, *http.Request) (interface{}, error)

type Database struct {
	Config *config.ConfigT

	_db *gorm.DB	
	fns map[string]func(map[string]string, http.ResponseWriter, *http.Request) (interface{}, error)
}

func NewDatabase(config *config.ConfigT) (*Database, error) {
	db := new(Database)

	db.fns = make(db*gorm.DB, map[string]func(map[string]string, http.ResponseWriter, *http.Request) (interface{}, error), 0)
	db._db, err := gorm.Open("mysql", fmt.Sprintf("%s?%s", config.Config.Orm.Connection, config.Config.Orm.Options))
	if err != nil {
		return nil, err
	}
	return db
}

func (db *Database) AutoMigrate(models ...interface{}) {
	if err := db._db.AutoMigrate(models...).Error; err != nil {
		panic(err)
	}

}

func CreateCategories() {
	for _, name := range categories {
		var category Category
		if err := currDB.FirstOrCreate(&category, Category{Name: name}).Error; err != nil {
			panic(err)
		}
	}
}

func Use(db *gorm.DB) {
	currDB = db
}

func DB() *gorm.DB {
	return currDB
}

func MapHandlers(models []interface{}) error {
	for _, model := range models {
		name := inflection.Plural(strings.ToLower(ModelName(model)))
		for p, action := range map[string]string{
			"":            "ReadAll",
			"create/":     "Create",
			"{id}":        "Read",
			"{id}/update": "Update",
			"{id}/delete": "Delete",
		} {
			method := reflect.ValueOf(model).MethodByName(action)
			if !method.IsValid() {
				return fmt.Errorf("Action %s is not defined for model %s", action, name)
			}
			joinedPath := path.Join("/", name, p)
			if strings.HasSuffix(p, "/") {
				joinedPath += "/"
			}
			fns[joinedPath] = method.Interface().(func(map[string]string, http.ResponseWriter, *http.Request) (interface{}, error))
		}

	}

	return nil
}

func GetFunc(path string) (GetFn, error) {
	fn, ok := fns[path]
	if !ok {
		return nil, fmt.Errorf("Can't map path %s to any model methods.", path)
	}
	return fn, nil
}

func GetNothing(args map[string]string) (interface{}, error) {
	return nil, nil
}

func PostNothing(args map[string]string, w http.ResponseWriter, r *http.Request) (IDer, error) {
	return nil, nil
}

func ModelName(s interface{}) string {
	t := reflect.TypeOf(s)
	switch t.Kind() {
	case reflect.Ptr:
		elem := t.Elem()
		if strings.Contains(elem.String(), "[]") {
			return strings.Replace(elem.String(), "[]*orm.", "", -1)
		}
		return elem.Name()
	case reflect.Slice:
		return strings.Replace(t.Elem().String(), "*orm.", "", -1)
	default:
		return t.Name()
	}
}