package script

import (
	"fmt"
	lua "github.com/yuin/gopher-lua"
	"log"
	"time"
)

func Catch() {
	if err := recover(); err != nil {
		log.Println(err)
	}
}

// MapToTable converts a Go map to a lua table
func MapToTable(m map[string]interface{}) *lua.LTable {
	// Main table pointer
	resultTable := &lua.LTable{}

	// Loop map
	for key, element := range m {

		switch element.(type) {
		case float64:
			resultTable.RawSetString(key, lua.LNumber(element.(float64)))
		case int64:
			resultTable.RawSetString(key, lua.LNumber(element.(int64)))
		case string:
			resultTable.RawSetString(key, lua.LString(element.(string)))
		case bool:
			resultTable.RawSetString(key, lua.LBool(element.(bool)))
		case []byte:
			resultTable.RawSetString(key, lua.LString(string(element.([]byte))))
		case map[string]interface{}:

			// Get table from map
			tble := MapToTable(element.(map[string]interface{}))

			resultTable.RawSetString(key, tble)

		case time.Time:
			resultTable.RawSetString(key, lua.LNumber(element.(time.Time).Unix()))

		case []map[string]interface{}:

			// Create slice table
			sliceTable := &lua.LTable{}

			// Loop element
			for _, s := range element.([]map[string]interface{}) {

				// Get table from map
				tble := MapToTable(s)

				sliceTable.Append(tble)
			}

			// Set slice table
			resultTable.RawSetString(key, sliceTable)

		case []interface{}:

			// Create slice table
			sliceTable := &lua.LTable{}

			// Loop interface slice
			for _, s := range element.([]interface{}) {

				// Switch interface type
				switch s.(type) {
				case map[string]interface{}:

					// Convert map to table
					t := MapToTable(s.(map[string]interface{}))

					// Append result
					sliceTable.Append(t)

				case float64:

					// Append result as number
					sliceTable.Append(lua.LNumber(s.(float64)))

				case string:

					// Append result as string
					sliceTable.Append(lua.LString(s.(string)))

				case bool:

					// Append result as bool
					sliceTable.Append(lua.LBool(s.(bool)))
				}
			}

			// Append to main table
			resultTable.RawSetString(key, sliceTable)
		}
	}

	return resultTable
}

// TabletoMap converts a lua table to go map
func TableToMap(t *lua.LTable) map[string]interface{} {
	ret := make(map[string]interface{})
	t.ForEach(func(k, v lua.LValue) {
		key := fmt.Sprint(k)
		if val, ok := v.(*lua.LTable); ok {
			ret[key] = TableToMap(val)
		} else {
			if val, ok := v.(lua.LString); ok {
				ret[key] = string(val)
			} else if val, ok := v.(lua.LNumber); ok {
				ret[key] = int64(val)
			} else if val, ok := v.(lua.LBool); ok {
				ret[key] = bool(val)
			} else {
				ret[key] = fmt.Sprint(v)
			}
		}
	})
	return ret
}