package boil

import (
	"fmt"
	"math/rand"
	"reflect"
	"regexp"
	"sort"
	"strconv"
	"time"

	null "gopkg.in/nullbio/null.v4"

	"github.com/satori/go.uuid"
	"github.com/vattle/sqlboiler/strmangle"
)

var (
	typeNullFloat32 = reflect.TypeOf(null.Float32{})
	typeNullFloat64 = reflect.TypeOf(null.Float64{})
	typeNullInt     = reflect.TypeOf(null.Int{})
	typeNullInt8    = reflect.TypeOf(null.Int8{})
	typeNullInt16   = reflect.TypeOf(null.Int16{})
	typeNullInt32   = reflect.TypeOf(null.Int32{})
	typeNullInt64   = reflect.TypeOf(null.Int64{})
	typeNullUint    = reflect.TypeOf(null.Uint{})
	typeNullUint8   = reflect.TypeOf(null.Uint8{})
	typeNullUint16  = reflect.TypeOf(null.Uint16{})
	typeNullUint32  = reflect.TypeOf(null.Uint32{})
	typeNullUint64  = reflect.TypeOf(null.Uint64{})
	typeNullString  = reflect.TypeOf(null.String{})
	typeNullBool    = reflect.TypeOf(null.Bool{})
	typeNullTime    = reflect.TypeOf(null.Time{})
	typeTime        = reflect.TypeOf(time.Time{})

	rgxValidTime = regexp.MustCompile(`[2-9]+`)
)

type seed int

var sd = new(seed)

func (s *seed) nextInt() int {
	nextInt := int(*s)
	*s++
	return nextInt
}

// IsZeroValue checks if the variables with matching columns in obj
// are or are not zero values, depending on whether shouldZero is true or false
func IsZeroValue(obj interface{}, shouldZero bool, columns ...string) []error {
	val := reflect.Indirect(reflect.ValueOf(obj))

	var errs []error
	for _, c := range columns {
		field := val.FieldByName(strmangle.TitleCase(c))
		if !field.IsValid() {
			panic(fmt.Sprintf("Unable to find variable with column name %s", c))
		}

		zv := reflect.Zero(field.Type())
		if shouldZero && !reflect.DeepEqual(field.Interface(), zv.Interface()) {
			errs = append(errs, fmt.Errorf("Column with name %s is not zero value: %#v, %#v", c, field.Interface(), zv.Interface()))
		} else if !shouldZero && reflect.DeepEqual(field.Interface(), zv.Interface()) {
			errs = append(errs, fmt.Errorf("Column with name %s is zero value: %#v, %#v", c, field.Interface(), zv.Interface()))
		}
	}

	return errs
}

// IsValueMatch checks whether the variables in obj with matching column names
// match the values in the values slice.
func IsValueMatch(obj interface{}, columns []string, values []interface{}) []error {
	val := reflect.Indirect(reflect.ValueOf(obj))

	var errs []error
	for i, c := range columns {
		field := val.FieldByName(strmangle.TitleCase(c))
		if !field.IsValid() {
			panic(fmt.Sprintf("Unable to find variable with column name %s", c))
		}

		typ := field.Type().String()
		if typ == "time.Time" || typ == "null.Time" {
			var timeField reflect.Value
			var valTimeStr string
			if typ == "time.Time" {
				valTimeStr = values[i].(time.Time).String()
				timeField = field
			} else {
				valTimeStr = values[i].(null.Time).Time.String()
				timeField = field.FieldByName("Time")
				validField := field.FieldByName("Valid")
				if validField.Interface() != values[i].(null.Time).Valid {
					errs = append(errs, fmt.Errorf("Null.Time column with name %s Valid field does not match: %v ≠ %v", c, values[i].(null.Time).Valid, validField.Interface()))
				}
			}

			if (rgxValidTime.MatchString(valTimeStr) && timeField.Interface() == reflect.Zero(timeField.Type()).Interface()) ||
				(!rgxValidTime.MatchString(valTimeStr) && timeField.Interface() != reflect.Zero(timeField.Type()).Interface()) {
				errs = append(errs, fmt.Errorf("Time column with name %s Time field does not match: %v ≠ %v", c, values[i], timeField.Interface()))
			}

			continue
		}

		if !reflect.DeepEqual(field.Interface(), values[i]) {
			errs = append(errs, fmt.Errorf("Column with name %s does not match value: %#v ≠ %#v", c, values[i], field.Interface()))
		}
	}

	return errs
}

// RandomizeSlice takes a pointer to a slice of pointers to objects
// and fills the pointed to objects with random data.
// It will ignore the fields in the blacklist.
func RandomizeSlice(obj interface{}, colTypes map[string]string, includeInvalid bool, blacklist ...string) error {
	ptrSlice := reflect.ValueOf(obj)
	typ := ptrSlice.Type()
	ptrSlice = ptrSlice.Elem()
	kind := typ.Kind()

	var structTyp reflect.Type

	for i, exp := range []reflect.Kind{reflect.Ptr, reflect.Slice, reflect.Ptr, reflect.Struct} {
		if i != 0 {
			typ = typ.Elem()
			kind = typ.Kind()
		}

		if kind != exp {
			return fmt.Errorf("[%d] RandomizeSlice object type should be *[]*Type but was: %s", i, ptrSlice.Type().String())
		}

		if kind == reflect.Struct {
			structTyp = typ
		}
	}

	for i := 0; i < ptrSlice.Len(); i++ {
		o := ptrSlice.Index(i)
		if o.IsNil() {
			o.Set(reflect.New(structTyp))
		}

		if err := RandomizeStruct(o.Interface(), colTypes, includeInvalid, blacklist...); err != nil {
			return err
		}
	}

	return nil
}

// RandomizeStruct takes an object and fills it with random data.
// It will ignore the fields in the blacklist.
func RandomizeStruct(str interface{}, colTypes map[string]string, includeInvalid bool, blacklist ...string) error {
	// Don't modify blacklist
	copyBlacklist := make([]string, len(blacklist))
	copy(copyBlacklist, blacklist)
	blacklist = copyBlacklist

	sort.Strings(blacklist)

	// Check if it's pointer
	value := reflect.ValueOf(str)
	kind := value.Kind()
	if kind != reflect.Ptr {
		return fmt.Errorf("Outer element should be a pointer, given a non-pointer: %T", str)
	}

	// Check if it's a struct
	value = value.Elem()
	kind = value.Kind()
	if kind != reflect.Struct {
		return fmt.Errorf("Inner element should be a struct, given a non-struct: %T", str)
	}

	typ := value.Type()
	nFields := value.NumField()

	// Iterate through fields, randomizing
	for i := 0; i < nFields; i++ {
		fieldVal := value.Field(i)
		fieldTyp := typ.Field(i)

		var found bool
		for _, v := range blacklist {
			if strmangle.TitleCase(v) == fieldTyp.Name {
				found = true
				break
			}
		}

		if found {
			continue
		}

		fieldDBType := colTypes[fieldTyp.Name]
		if err := randomizeField(fieldVal, fieldDBType, includeInvalid); err != nil {
			return err
		}
	}

	return nil
}

// RandomizeValidatedStruct takes an object fills its validated columns with random data.
func RandomizeValidatedStruct(obj interface{}, validatedCols []string, colTypes map[string]string) error {
	// Check if it's pointer
	value := reflect.ValueOf(obj)
	kind := value.Kind()
	if kind != reflect.Ptr {
		return fmt.Errorf("Outer element should be a pointer, given a non-pointer: %T", obj)
	}

	// Check if it's a struct
	value = value.Elem()
	kind = value.Kind()
	if kind != reflect.Struct {
		return fmt.Errorf("Inner element should be a struct, given a non-struct: %T", obj)
	}

	typ := value.Type()
	nFields := value.NumField()

	// Iterate through fields
	for i := 0; i < nFields; i++ {
		fieldVal := value.Field(i)
		fieldTyp := typ.Field(i)
		for _, v := range validatedCols {
			if strmangle.TitleCase(v) == fieldTyp.Name {
				if err := randomizeField(fieldVal, colTypes[fieldTyp.Name], false); err != nil {
					return err
				}
				break
			}
		}
	}

	return nil
}

// randDate generates a random time.Time between 1850 and 2050.
// Only the Day/Month/Year columns are set so that Dates and DateTimes do
// not cause mismatches in the test data comparisons.
func randDate(sd int) time.Time {
	t := time.Date(
		1850+rand.Intn(sd),
		time.Month(1+rand.Intn(12)),
		1+rand.Intn(25),
		0,
		0,
		0,
		0,
		time.UTC,
	)

	return t
}

func randomizeField(field reflect.Value, fieldType string, includeInvalid bool) error {
	kind := field.Kind()
	typ := field.Type()

	var newVal interface{}

	if kind == reflect.Struct {
		var b bool
		if includeInvalid {
			b = rand.Intn(2) == 1
		} else {
			b = true
		}
		switch typ {
		case typeNullBool:
			if b {
				newVal = null.NewBool(sd.nextInt()%2 == 0, b)
			} else {
				newVal = null.NewBool(false, false)
			}
		case typeNullString:
			if b {
				switch fieldType {
				case "interval":
					newVal = null.NewString(strconv.Itoa((sd.nextInt()%26)+2)+" days", b)
				case "uuid":
					newVal = null.NewString(uuid.NewV4().String(), b)
				default:
					newVal = null.NewString(randStr(1, sd.nextInt()), b)
				}
			} else {
				newVal = null.NewString("", false)
			}
		case typeNullTime:
			if b {
				newVal = null.NewTime(randDate(sd.nextInt()), b)
			} else {
				newVal = null.NewTime(time.Time{}, false)
			}
		case typeTime:
			newVal = randDate(sd.nextInt())
		case typeNullFloat32:
			if b {
				newVal = null.NewFloat32(float32(sd.nextInt()%10)/10.0+float32(sd.nextInt()%10), b)
			} else {
				newVal = null.NewFloat32(0.0, false)
			}
		case typeNullFloat64:
			if b {
				newVal = null.NewFloat64(float64(sd.nextInt()%10)/10.0+float64(sd.nextInt()%10), b)
			} else {
				newVal = null.NewFloat64(0.0, false)
			}
		case typeNullInt:
			if b {
				newVal = null.NewInt(sd.nextInt(), b)
			} else {
				newVal = null.NewInt(0, false)
			}
		case typeNullInt8:
			if b {
				newVal = null.NewInt8(int8(sd.nextInt()), b)
			} else {
				newVal = null.NewInt8(0, false)
			}
		case typeNullInt16:
			if b {
				newVal = null.NewInt16(int16(sd.nextInt()), b)
			} else {
				newVal = null.NewInt16(0, false)
			}
		case typeNullInt32:
			if b {
				newVal = null.NewInt32(int32(sd.nextInt()), b)
			} else {
				newVal = null.NewInt32(0, false)
			}
		case typeNullInt64:
			if b {
				newVal = null.NewInt64(int64(sd.nextInt()), b)
			} else {
				newVal = null.NewInt64(0, false)
			}
		case typeNullUint:
			if b {
				newVal = null.NewUint(uint(sd.nextInt()), b)
			} else {
				newVal = null.NewUint(0, false)
			}
		case typeNullUint8:
			if b {
				newVal = null.NewUint8(uint8(sd.nextInt()), b)
			} else {
				newVal = null.NewUint8(0, false)
			}
		case typeNullUint16:
			if b {
				newVal = null.NewUint16(uint16(sd.nextInt()), b)
			} else {
				newVal = null.NewUint16(0, false)
			}
		case typeNullUint32:
			if b {
				newVal = null.NewUint32(uint32(sd.nextInt()), b)
			} else {
				newVal = null.NewUint32(0, false)
			}
		case typeNullUint64:
			if b {
				newVal = null.NewUint64(uint64(sd.nextInt()), b)
			} else {
				newVal = null.NewUint64(0, false)
			}
		}
	} else {
		switch kind {
		case reflect.Float32:
			newVal = float32(float32(sd.nextInt()%10)/10.0 + float32(sd.nextInt()%10))
		case reflect.Float64:
			newVal = float64(float64(sd.nextInt()%10)/10.0 + float64(sd.nextInt()%10))
		case reflect.Int:
			newVal = sd.nextInt()
		case reflect.Int8:
			newVal = int8(sd.nextInt())
		case reflect.Int16:
			newVal = int16(sd.nextInt())
		case reflect.Int32:
			newVal = int32(sd.nextInt())
		case reflect.Int64:
			newVal = int64(sd.nextInt())
		case reflect.Uint:
			newVal = uint(sd.nextInt())
		case reflect.Uint8:
			newVal = uint8(sd.nextInt())
		case reflect.Uint16:
			newVal = uint16(sd.nextInt())
		case reflect.Uint32:
			newVal = uint32(sd.nextInt())
		case reflect.Uint64:
			newVal = uint64(sd.nextInt())
		case reflect.Bool:
			var b bool
			if includeInvalid {
				b = sd.nextInt()%2 == 0
			} else {
				b = true
			}
			newVal = b
		case reflect.String:
			switch fieldType {
			case "interval":
				newVal = strconv.Itoa((sd.nextInt()%26)+2) + " days"
			case "uuid":
				newVal = uuid.NewV4().String()
			default:
				newVal = randStr(1, sd.nextInt())
			}
		case reflect.Slice:
			sliceVal := typ.Elem()
			if sliceVal.Kind() != reflect.Uint8 {
				return fmt.Errorf("unsupported slice type: %T", typ.String())
			}
			newVal = randByteSlice(5+rand.Intn(20), sd.nextInt())
		default:
			return fmt.Errorf("unsupported type: %T", typ.String())
		}
	}

	field.Set(reflect.ValueOf(newVal))

	return nil
}

const alphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

func randStr(ln int, s int) string {
	str := make([]byte, ln)
	for i := 0; i < ln; i++ {
		str[i] = byte(alphabet[s%len(alphabet)])
	}

	return string(str)
}

func randByteSlice(ln int, s int) []byte {
	str := make([]byte, ln)
	for i := 0; i < ln; i++ {
		str[i] = byte(s % 256)
	}

	return str
}