package assert

import (

	"fmt"

	"reflect"

)

type CompareType int

const (

	compareLess CompareType = iota - 1

	compareEqual

	compareGreater

)

var (

	intType   = reflect.TypeOf(int(1))

	int8Type  = reflect.TypeOf(int8(1))

	int16Type = reflect.TypeOf(int16(1))

	int32Type = reflect.TypeOf(int32(1))

	int64Type = reflect.TypeOf(int64(1))

	uintType   = reflect.TypeOf(uint(1))

	uint8Type  = reflect.TypeOf(uint8(1))

	uint16Type = reflect.TypeOf(uint16(1))

	uint32Type = reflect.TypeOf(uint32(1))

	uint64Type = reflect.TypeOf(uint64(1))

	float32Type = reflect.TypeOf(float32(1))

	float64Type = reflect.TypeOf(float64(1))

	stringType = reflect.TypeOf("")

)

func compare(obj1, obj2 interface{}, kind reflect.Kind) (CompareType, bool) {

	obj1Value := reflect.ValueOf(obj1)

	obj2Value := reflect.ValueOf(obj2)

	// throughout this switch we try and avoid calling .Convert() if possible,

	// as this has a pretty big performance impact

	switch kind {

	case reflect.Int:

		{

			intobj1, ok := obj1.(int)

			if !ok {

				intobj1 = obj1Value.Convert(intType).Interface().(int)

			}

			intobj2, ok := obj2.(int)

			if !ok {

				intobj2 = obj2Value.Convert(intType).Interface().(int)

			}

			if intobj1 > intobj2 {

				return compareGreater, true

			}

			if intobj1 == intobj2 {

				return compareEqual, true

			}

			if intobj1 < intobj2 {

				return compareLess, true

			}

		}

	case reflect.Int8:

		{

			int8obj1, ok := obj1.(int8)

			if !ok {

				int8obj1 = obj1Value.Convert(int8Type).Interface().(int8)

			}

			int8obj2, ok := obj2.(int8)

			if !ok {

				int8obj2 = obj2Value.Convert(int8Type).Interface().(int8)

			}

			if int8obj1 > int8obj2 {

				return compareGreater, true

			}

			if int8obj1 == int8obj2 {

				return compareEqual, true

			}

			if int8obj1 < int8obj2 {

				return compareLess, true

			}

		}

	case reflect.Int16:

		{

			int16obj1, ok := obj1.(int16)

			if !ok {

				int16obj1 = obj1Value.Convert(int16Type).Interface().(int16)

			}

			int16obj2, ok := obj2.(int16)

			if !ok {

				int16obj2 = obj2Value.Convert(int16Type).Interface().(int16)

			}

			if int16obj1 > int16obj2 {

				return compareGreater, true

			}

			if int16obj1 == int16obj2 {

				return compareEqual, true

			}

			if int16obj1 < int16obj2 {

				return compareLess, true

			}

		}

	case reflect.Int32:

		{

			int32obj1, ok := obj1.(int32)

			if !ok {

				int32obj1 = obj1Value.Convert(int32Type).Interface().(int32)

			}

			int32obj2, ok := obj2.(int32)

			if !ok {

				int32obj2 = obj2Value.Convert(int32Type).Interface().(int32)

			}

			if int32obj1 > int32obj2 {

				return compareGreater, true

			}

			if int32obj1 == int32obj2 {

				return compareEqual, true

			}

			if int32obj1 < int32obj2 {

				return compareLess, true

			}

		}

	case reflect.Int64:

		{

			int64obj1, ok := obj1.(int64)

			if !ok {

				int64obj1 = obj1Value.Convert(int64Type).Interface().(int64)

			}

			int64obj2, ok := obj2.(int64)

			if !ok {

				int64obj2 = obj2Value.Convert(int64Type).Interface().(int64)

			}

			if int64obj1 > int64obj2 {

				return compareGreater, true

			}

			if int64obj1 == int64obj2 {

				return compareEqual, true

			}

			if int64obj1 < int64obj2 {

				return compareLess, true

			}

		}

	case reflect.Uint:

		{

			uintobj1, ok := obj1.(uint)

			if !ok {

				uintobj1 = obj1Value.Convert(uintType).Interface().(uint)

			}

			uintobj2, ok := obj2.(uint)

			if !ok {

				uintobj2 = obj2Value.Convert(uintType).Interface().(uint)

			}

			if uintobj1 > uintobj2 {

				return compareGreater, true

			}

			if uintobj1 == uintobj2 {

				return compareEqual, true

			}

			if uintobj1 < uintobj2 {

				return compareLess, true

			}

		}

	case reflect.Uint8:

		{

			uint8obj1, ok := obj1.(uint8)

			if !ok {

				uint8obj1 = obj1Value.Convert(uint8Type).Interface().(uint8)

			}

			uint8obj2, ok := obj2.(uint8)

			if !ok {

				uint8obj2 = obj2Value.Convert(uint8Type).Interface().(uint8)

			}

			if uint8obj1 > uint8obj2 {

				return compareGreater, true

			}

			if uint8obj1 == uint8obj2 {

				return compareEqual, true

			}

			if uint8obj1 < uint8obj2 {

				return compareLess, true

			}

		}

	case reflect.Uint16:

		{

			uint16obj1, ok := obj1.(uint16)

			if !ok {

				uint16obj1 = obj1Value.Convert(uint16Type).Interface().(uint16)

			}

			uint16obj2, ok := obj2.(uint16)

			if !ok {

				uint16obj2 = obj2Value.Convert(uint16Type).Interface().(uint16)

			}

			if uint16obj1 > uint16obj2 {

				return compareGreater, true

			}

			if uint16obj1 == uint16obj2 {

				return compareEqual, true

			}

			if uint16obj1 < uint16obj2 {

				return compareLess, true

			}

		}

	case reflect.Uint32:

		{

			uint32obj1, ok := obj1.(uint32)

			if !ok {

				uint32obj1 = obj1Value.Convert(uint32Type).Interface().(uint32)

			}

			uint32obj2, ok := obj2.(uint32)

			if !ok {

				uint32obj2 = obj2Value.Convert(uint32Type).Interface().(uint32)

			}

			if uint32obj1 > uint32obj2 {

				return compareGreater, true

			}

			if uint32obj1 == uint32obj2 {

				return compareEqual, true

			}

			if uint32obj1 < uint32obj2 {

				return compareLess, true

			}

		}

	case reflect.Uint64:

		{

			uint64obj1, ok := obj1.(uint64)

			if !ok {

				uint64obj1 = obj1Value.Convert(uint64Type).Interface().(uint64)

			}

			uint64obj2, ok := obj2.(uint64)

			if !ok {

				uint64obj2 = obj2Value.Convert(uint64Type).Interface().(uint64)

			}

			if uint64obj1 > uint64obj2 {

				return compareGreater, true

			}

			if uint64obj1 == uint64obj2 {

				return compareEqual, true

			}

			if uint64obj1 < uint64obj2 {

				return compareLess, true

			}

		}

	case reflect.Float32:

		{

			float32obj1, ok := obj1.(float32)

			if !ok {

				float32obj1 = obj1Value.Convert(float32Type).Interface().(float32)

			}

			float32obj2, ok := obj2.(float32)

			if !ok {

				float32obj2 = obj2Value.Convert(float32Type).Interface().(float32)

			}

			if float32obj1 > float32obj2 {

				return compareGreater, true

			}

			if float32obj1 == float32obj2 {

				return compareEqual, true

			}

			if float32obj1 < float32obj2 {

				return compareLess, true

			}

		}

	case reflect.Float64:

		{

			float64obj1, ok := obj1.(float64)

			if !ok {

				float64obj1 = obj1Value.Convert(float64Type).Interface().(float64)

			}

			float64obj2, ok := obj2.(float64)

			if !ok {

				float64obj2 = obj2Value.Convert(float64Type).Interface().(float64)

			}

			if float64obj1 > float64obj2 {

				return compareGreater, true

			}

			if float64obj1 == float64obj2 {

				return compareEqual, true

			}

			if float64obj1 < float64obj2 {

				return compareLess, true

			}

		}

	case reflect.String:

		{

			stringobj1, ok := obj1.(string)

			if !ok {

				stringobj1 = obj1Value.Convert(stringType).Interface().(string)

			}

			stringobj2, ok := obj2.(string)

			if !ok {

				stringobj2 = obj2Value.Convert(stringType).Interface().(string)

			}

			if stringobj1 > stringobj2 {

				return compareGreater, true

			}

			if stringobj1 == stringobj2 {

				return compareEqual, true

			}

			if stringobj1 < stringobj2 {

				return compareLess, true

			}

		}

	}

	return compareEqual, false

}

// Greater asserts that the first element is greater than the second

//

//    assert.Greater(t, 2, 1)

//    assert.Greater(t, float64(2), float64(1))

//    assert.Greater(t, "b", "a")

func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {

	return compareTwoValues(t, e1, e2, []CompareType{compareGreater}, "\"%v\" is not greater than \"%v\"", msgAndArgs)

}

// GreaterOrEqual asserts that the first element is greater than or equal to the second

//

//    assert.GreaterOrEqual(t, 2, 1)

//    assert.GreaterOrEqual(t, 2, 2)

//    assert.GreaterOrEqual(t, "b", "a")

//    assert.GreaterOrEqual(t, "b", "b")

func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {

	return compareTwoValues(t, e1, e2, []CompareType{compareGreater, compareEqual}, "\"%v\" is not greater than or equal to \"%v\"", msgAndArgs)

}

// Less asserts that the first element is less than the second

//

//    assert.Less(t, 1, 2)

//    assert.Less(t, float64(1), float64(2))

//    assert.Less(t, "a", "b")

func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {

	return compareTwoValues(t, e1, e2, []CompareType{compareLess}, "\"%v\" is not less than \"%v\"", msgAndArgs)

}

// LessOrEqual asserts that the first element is less than or equal to the second

//

//    assert.LessOrEqual(t, 1, 2)

//    assert.LessOrEqual(t, 2, 2)

//    assert.LessOrEqual(t, "a", "b")

//    assert.LessOrEqual(t, "b", "b")

func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool {

	return compareTwoValues(t, e1, e2, []CompareType{compareLess, compareEqual}, "\"%v\" is not less than or equal to \"%v\"", msgAndArgs)

}

// Positive asserts that the specified element is positive

//

//    assert.Positive(t, 1)

//    assert.Positive(t, 1.23)

func Positive(t TestingT, e interface{}, msgAndArgs ...interface{}) bool {

	zero := reflect.Zero(reflect.TypeOf(e))

	return compareTwoValues(t, e, zero.Interface(), []CompareType{compareGreater}, "\"%v\" is not positive", msgAndArgs)

}

// Negative asserts that the specified element is negative

//

//    assert.Negative(t, -1)

//    assert.Negative(t, -1.23)

func Negative(t TestingT, e interface{}, msgAndArgs ...interface{}) bool {

	zero := reflect.Zero(reflect.TypeOf(e))

	return compareTwoValues(t, e, zero.Interface(), []CompareType{compareLess}, "\"%v\" is not negative", msgAndArgs)

}

func compareTwoValues(t TestingT, e1 interface{}, e2 interface{}, allowedComparesResults []CompareType, failMessage string, msgAndArgs ...interface{}) bool {

	if h, ok := t.(tHelper); ok {

		h.Helper()

	}

	e1Kind := reflect.ValueOf(e1).Kind()

	e2Kind := reflect.ValueOf(e2).Kind()

	if e1Kind != e2Kind {

		return Fail(t, "Elements should be the same type", msgAndArgs...)

	}

	compareResult, isComparable := compare(e1, e2, e1Kind)

	if !isComparable {

		return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...)

	}

	if !containsValue(allowedComparesResults, compareResult) {

		return Fail(t, fmt.Sprintf(failMessage, e1, e2), msgAndArgs...)

	}

	return true

}

func containsValue(values []CompareType, value CompareType) bool {

	for _, v := range values {

		if v == value {

			return true

		}

	}

	return false

}