package sec

import (
	// stdlib
	"os"
	"strconv"
	"testing"

	// other
	"github.com/stretchr/testify/require"
)

func TestParseString(t *testing.T) {
	type testStruct struct {
		StringData string
	}

	os.Setenv("STRINGDATA", "test")

	s := &testStruct{}
	err := Parse(s, nil)
	if err != nil {
		t.Log(err.Error())
	}
	require.Nil(t, err)
}

func TestParseBoolean(t *testing.T) {
	testCases := []struct {
		TestData  string
		ValidData bool
	}{
		{"1", true},
		{"t", true},
		{"T", true},
		{"TRUE", true},
		{"true", true},
		{"True", true},
		{"0", false},
		{"f", false},
		{"F", false},
		{"FALSE", false},
		{"false", false},
		{"False", false},
		{"not a boolean", false},
	}

	type testStruct struct {
		BoolData bool
	}

	for _, testCase := range testCases {
		t.Logf("Testing: %+v", testCase)
		os.Setenv("BOOLDATA", testCase.TestData)

		// If ErrorsAreCritical == false, then we should check only
		// equality of parsed data and valid data.
		s := &testStruct{}
		err := Parse(s, nil)
		if err != nil {
			t.Log(err.Error())
		}
		require.Nil(t, err)
		require.Equal(t, testCase.ValidData, s.BoolData)

		// If errors are critical - we should check if test data is within
		// int8 range and check for error if it isn't.
		s1 := &testStruct{}
		err1 := Parse(s1, &Options{ErrorsAreCritical: true})

		var checkNotBoolError bool
		_, err2 := strconv.ParseBool(testCase.TestData)
		if err2 != nil {
			checkNotBoolError = true
		}

		if checkNotBoolError {
			if err1 == nil {
				t.Log("No error returned!")
			}
			require.NotNil(t, err1)
			require.Equal(t, errNotBool, err1)
		}

		os.Unsetenv("BOOLDATA")
	}
}

func TestParseInt8(t *testing.T) {
	testCases := []struct {
		TestData  string
		ValidData int8
	}{
		{"0", 0},
		{"1", 1},
		{"2", 2},
		{"-128", -128},
		{"127", 127},
		{"-129", 0},
		{"128", 0},
		{"not an integer", 0},
	}

	type testStruct struct {
		IntData int8
	}

	for _, testCase := range testCases {
		t.Logf("Testing: %+v", testCase)
		os.Setenv("INTDATA", testCase.TestData)

		// If ErrorsAreCritical == false, then we should check only
		// equality of parsed data and valid data.
		s := &testStruct{}
		err := Parse(s, nil)
		if err != nil {
			t.Log(err.Error())
		}
		require.Nil(t, err)
		require.Equal(t, testCase.ValidData, s.IntData)

		// If errors are critical - we should check if test data is within
		// int8 range and check for error if it isn't.
		s1 := &testStruct{}
		err1 := Parse(s1, &Options{ErrorsAreCritical: true})

		var checkNotIntError bool
		var checkRangeError bool
		passedData, err2 := strconv.ParseInt(testCase.TestData, 10, 64)
		if err2 != nil {
			checkNotIntError = true
		}
		if passedData != int64(testCase.ValidData) {
			checkRangeError = true
		}

		if checkNotIntError || checkRangeError {
			if err1 == nil {
				t.Log("No error returned!")
			}
			require.NotNil(t, err1)

			if checkNotIntError {
				require.Equal(t, errNotInt, err1)
			}
			if checkRangeError {
				require.Equal(t, errNotInt8, err1)
			}
		}

		os.Unsetenv("INTDATA")
	}
}

func TestParseInt16(t *testing.T) {
	testCases := []struct {
		TestData  string
		ValidData int16
	}{
		{"0", 0},
		{"1", 1},
		{"2", 2},
		{"-32768", -32768},
		{"32767", 32767},
		{"-32770", 0},
		{"32770", 0},
		{"not an integer", 0},
	}

	type testStruct struct {
		IntData int16
	}

	for _, testCase := range testCases {
		t.Logf("Testing: %+v", testCase)
		os.Setenv("INTDATA", testCase.TestData)

		// If ErrorsAreCritical == false, then we should check only
		// equality of parsed data and valid data.
		s := &testStruct{}
		err := Parse(s, nil)
		if err != nil {
			t.Log(err.Error())
		}
		require.Nil(t, err)
		require.Equal(t, testCase.ValidData, s.IntData)

		// If errors are critical - we should check if test data is within
		// int8 range and check for error if it isn't.
		s1 := &testStruct{}
		err1 := Parse(s1, &Options{ErrorsAreCritical: true})

		var checkNotIntError bool
		var checkRangeError bool
		passedData, err2 := strconv.ParseInt(testCase.TestData, 10, 64)
		if err2 != nil {
			checkNotIntError = true
		}
		if passedData != int64(testCase.ValidData) {
			checkRangeError = true
		}

		if checkNotIntError || checkRangeError {
			if err1 == nil {
				t.Log("No error returned!")
			}
			require.NotNil(t, err1)

			if checkNotIntError {
				require.Equal(t, errNotInt, err1)
			}
			if checkRangeError {
				require.Equal(t, errNotInt16, err1)
			}
		}

		os.Unsetenv("INTDATA")
	}
}

func TestParseInt32(t *testing.T) {
	testCases := []struct {
		TestData  string
		ValidData int32
	}{
		{"0", 0},
		{"1", 1},
		{"2", 2},
		{"-2147483648", -2147483648},
		{"2147483647", 2147483647},
		{"-2147483650", 0},
		{"2147483650", 0},
		{"not an integer", 0},
	}

	type testStruct struct {
		IntData int32
	}

	for _, testCase := range testCases {
		t.Logf("Testing: %+v", testCase)
		os.Setenv("INTDATA", testCase.TestData)

		// If ErrorsAreCritical == false, then we should check only
		// equality of parsed data and valid data.
		s := &testStruct{}
		err := Parse(s, nil)
		if err != nil {
			t.Log(err.Error())
		}
		require.Nil(t, err)
		require.Equal(t, testCase.ValidData, s.IntData)

		// If errors are critical - we should check if test data is within
		// int8 range and check for error if it isn't.
		s1 := &testStruct{}
		err1 := Parse(s1, &Options{ErrorsAreCritical: true})

		var checkNotIntError bool
		var checkRangeError bool
		passedData, err2 := strconv.ParseInt(testCase.TestData, 10, 64)
		if err2 != nil {
			checkNotIntError = true
		}
		if passedData != int64(testCase.ValidData) {
			checkRangeError = true
		}

		if checkNotIntError || checkRangeError {
			if err1 == nil {
				t.Log("No error returned!")
			}
			require.NotNil(t, err1)

			if checkNotIntError {
				require.Equal(t, errNotInt, err1)
			}
			if checkRangeError {
				require.Equal(t, errNotInt32, err1)
			}
		}

		os.Unsetenv("INTDATA")
	}
}

func TestParseInt64(t *testing.T) {
	testCases := []struct {
		TestData  string
		ValidData int64
	}{
		{"0", 0},
		{"1", 1},
		{"2", 2},
		{"-9223372036854775808", -9223372036854775808},
		{"9223372036854775807", 9223372036854775807},
		{"-9223372036854775810", -9223372036854775808},
		{"9223372036854775810", 9223372036854775807},
		{"not an integer", 0},
	}

	type testStruct struct {
		IntData int64
	}

	for _, testCase := range testCases {
		t.Logf("Testing: %+v", testCase)
		os.Setenv("INTDATA", testCase.TestData)

		// If ErrorsAreCritical == false, then we should check only
		// equality of parsed data and valid data.
		s := &testStruct{}
		err := Parse(s, nil)
		if err != nil {
			t.Log(err.Error())
		}
		require.Nil(t, err)
		require.Equal(t, testCase.ValidData, s.IntData)

		// If errors are critical - we should check if test data is within
		// int8 range and check for error if it isn't.
		s1 := &testStruct{}
		err1 := Parse(s1, &Options{ErrorsAreCritical: true})

		var checkNotIntError bool
		var checkRangeError bool
		passedData, err2 := strconv.ParseInt(testCase.TestData, 10, 64)
		if err2 != nil {
			checkNotIntError = true
		}
		if passedData != testCase.ValidData {
			checkRangeError = true
		}

		if checkNotIntError || checkRangeError {
			if err1 == nil {
				t.Log("No error returned!")
			}
			require.NotNil(t, err1)

			if checkNotIntError {
				require.Equal(t, errNotInt, err1)
			}
			if checkRangeError {
				require.Equal(t, errNotInt64, err1)
			}
		}

		os.Unsetenv("INTDATA")
	}
}

func TestParseUint8(t *testing.T) {
	testCases := []struct {
		TestData  string
		ValidData uint8
	}{
		{"0", 0},
		{"1", 1},
		{"2", 2},
		{"255", 255},
		{"256", 0},
		{"-1", 0},
		{"not an integer", 0},
	}

	type testStruct struct {
		UintData uint8
	}

	for _, testCase := range testCases {
		t.Logf("Testing: %+v", testCase)
		os.Setenv("UINTDATA", testCase.TestData)

		// If ErrorsAreCritical == false, then we should check only
		// equality of parsed data and valid data.
		s := &testStruct{}
		err := Parse(s, nil)
		if err != nil {
			t.Log(err.Error())
		}
		require.Nil(t, err)
		require.Equal(t, testCase.ValidData, s.UintData)

		// If errors are critical - we should check if test data is within
		// int8 range and check for error if it isn't.
		s1 := &testStruct{}
		err1 := Parse(s1, &Options{ErrorsAreCritical: true})

		var checkNotIntError bool
		var checkRangeError bool
		passedData, err2 := strconv.ParseUint(testCase.TestData, 10, 64)
		if err2 != nil {
			checkNotIntError = true
		}
		if passedData != uint64(testCase.ValidData) {
			checkRangeError = true
		}

		if checkNotIntError || checkRangeError {
			if err1 == nil {
				t.Log("No error returned!")
			}
			require.NotNil(t, err1)

			if checkNotIntError {
				require.Equal(t, errNotUint, err1)
			}
			if checkRangeError {
				require.Equal(t, errNotUint8, err1)
			}
		}

		os.Unsetenv("UINTDATA")
	}
}

func TestParseUint16(t *testing.T) {
	testCases := []struct {
		TestData  string
		ValidData uint16
	}{
		{"0", 0},
		{"1", 1},
		{"2", 2},
		{"65535", 65535},
		{"65536", 0},
		{"-1", 0},
		{"not an integer", 0},
	}

	type testStruct struct {
		UintData uint16
	}

	for _, testCase := range testCases {
		t.Logf("Testing: %+v", testCase)
		os.Setenv("UINTDATA", testCase.TestData)

		// If ErrorsAreCritical == false, then we should check only
		// equality of parsed data and valid data.
		s := &testStruct{}
		err := Parse(s, nil)
		if err != nil {
			t.Log(err.Error())
		}
		require.Nil(t, err)
		require.Equal(t, testCase.ValidData, s.UintData)

		// If errors are critical - we should check if test data is within
		// int8 range and check for error if it isn't.
		s1 := &testStruct{}
		err1 := Parse(s1, &Options{ErrorsAreCritical: true})

		var checkNotIntError bool
		var checkRangeError bool
		passedData, err2 := strconv.ParseUint(testCase.TestData, 10, 64)
		if err2 != nil {
			checkNotIntError = true
		}
		if passedData != uint64(testCase.ValidData) {
			checkRangeError = true
		}

		if checkNotIntError || checkRangeError {
			if err1 == nil {
				t.Log("No error returned!")
			}
			require.NotNil(t, err1)

			if checkNotIntError {
				require.Equal(t, errNotUint, err1)
			}
			if checkRangeError {
				require.Equal(t, errNotUint16, err1)
			}
		}

		os.Unsetenv("UINTDATA")
	}
}

func TestParseUint32(t *testing.T) {
	testCases := []struct {
		TestData  string
		ValidData uint32
	}{
		{"0", 0},
		{"1", 1},
		{"2", 2},
		{"4294967295", 4294967295},
		{"4294967296", 0},
		{"-1", 0},
		{"not an integer", 0},
	}

	type testStruct struct {
		UintData uint32
	}

	for _, testCase := range testCases {
		t.Logf("Testing: %+v", testCase)
		os.Setenv("UINTDATA", testCase.TestData)

		// If ErrorsAreCritical == false, then we should check only
		// equality of parsed data and valid data.
		s := &testStruct{}
		err := Parse(s, nil)
		if err != nil {
			t.Log(err.Error())
		}
		require.Nil(t, err)
		require.Equal(t, testCase.ValidData, s.UintData)

		// If errors are critical - we should check if test data is within
		// int8 range and check for error if it isn't.
		s1 := &testStruct{}
		err1 := Parse(s1, &Options{ErrorsAreCritical: true})

		var checkNotIntError bool
		var checkRangeError bool
		passedData, err2 := strconv.ParseUint(testCase.TestData, 10, 64)
		if err2 != nil {
			checkNotIntError = true
		}
		if passedData != uint64(testCase.ValidData) {
			checkRangeError = true
		}

		if checkNotIntError || checkRangeError {
			if err1 == nil {
				t.Log("No error returned!")
			}
			require.NotNil(t, err1)

			if checkNotIntError {
				require.Equal(t, errNotUint, err1)
			}
			if checkRangeError {
				require.Equal(t, errNotUint32, err1)
			}
		}

		os.Unsetenv("UINTDATA")
	}
}

func TestParseUint64(t *testing.T) {
	testCases := []struct {
		TestData  string
		ValidData uint64
	}{
		{"0", 0},
		{"1", 1},
		{"2", 2},
		{"18446744073709551615", 18446744073709551615},
		{"18446744073709551616", 18446744073709551615},
		{"-1", 0},
		{"not an integer", 0},
	}

	type testStruct struct {
		UintData uint64
	}

	for _, testCase := range testCases {
		t.Logf("Testing: %+v", testCase)
		os.Setenv("UINTDATA", testCase.TestData)

		// If ErrorsAreCritical == false, then we should check only
		// equality of parsed data and valid data.
		s := &testStruct{}
		err := Parse(s, nil)
		if err != nil {
			t.Log(err.Error())
		}
		require.Nil(t, err)
		require.Equal(t, testCase.ValidData, s.UintData)

		// If errors are critical - we should check if test data is within
		// int8 range and check for error if it isn't.
		s1 := &testStruct{}
		err1 := Parse(s1, &Options{ErrorsAreCritical: true})

		var checkNotIntError bool
		var checkRangeError bool
		passedData, err2 := strconv.ParseUint(testCase.TestData, 10, 64)
		if err2 != nil {
			checkNotIntError = true
		}
		if passedData != testCase.ValidData {
			checkRangeError = true
		}

		if checkNotIntError || checkRangeError {
			if err1 == nil {
				t.Log("No error returned!")
			}
			require.NotNil(t, err1)

			if checkNotIntError {
				require.Equal(t, errNotUint, err1)
			}
			if checkRangeError {
				require.Equal(t, errNotUint64, err1)
			}
		}

		os.Unsetenv("UINTDATA")
	}
}

// Next tests should be improved.
func TestParseFloat32(t *testing.T) {
	testCases := []struct {
		TestData  string
		ValidData float32
	}{
		{"0.00", 0.00},
		{"1.00", 1.00},
		{"2.00", 2.00},
		{"-1", -1},
		{"not a float", 0.00},
	}

	type testStruct struct {
		FloatData float32
	}

	for _, testCase := range testCases {
		t.Logf("Testing: %+v", testCase)
		os.Setenv("FLOATDATA", testCase.TestData)

		// If ErrorsAreCritical == false, then we should check only
		// equality of parsed data and valid data.
		s := &testStruct{}
		err := Parse(s, nil)
		if err != nil {
			t.Log(err.Error())
		}
		require.Nil(t, err)
		require.Equal(t, testCase.ValidData, s.FloatData)

		// If errors are critical - we should check if test data is within
		// int8 range and check for error if it isn't.
		s1 := &testStruct{}
		err1 := Parse(s1, &Options{ErrorsAreCritical: true})

		var checkNotIntError bool
		var checkRangeError bool
		passedData, err2 := strconv.ParseFloat(testCase.TestData, 64)
		if err2 != nil {
			checkNotIntError = true
		}
		if passedData != float64(testCase.ValidData) {
			checkRangeError = true
		}

		if checkNotIntError || checkRangeError {
			if err1 == nil {
				t.Log("No error returned!")
			}
			require.NotNil(t, err1)

			if checkNotIntError {
				require.Equal(t, errNotFloat, err1)
			}
			if checkRangeError {
				require.Equal(t, errNotFloat32, err1)
			}
		}

		os.Unsetenv("FLOATDATA")
	}
}

func TestParseFloat64(t *testing.T) {
	testCases := []struct {
		TestData  string
		ValidData float64
	}{
		{"0.00", 0.00},
		{"1.00", 1.00},
		{"2.00", 2.00},
		{"-1", -1},
		{"not a float", 0.00},
	}

	type testStruct struct {
		FloatData float64
	}

	for _, testCase := range testCases {
		t.Logf("Testing: %+v", testCase)
		os.Setenv("FLOATDATA", testCase.TestData)

		// If ErrorsAreCritical == false, then we should check only
		// equality of parsed data and valid data.
		s := &testStruct{}
		err := Parse(s, nil)
		if err != nil {
			t.Log(err.Error())
		}
		require.Nil(t, err)
		require.Equal(t, testCase.ValidData, s.FloatData)

		// If errors are critical - we should check if test data is within
		// int8 range and check for error if it isn't.
		s1 := &testStruct{}
		err1 := Parse(s1, &Options{ErrorsAreCritical: true})

		var checkNotIntError bool
		var checkRangeError bool
		passedData, err2 := strconv.ParseFloat(testCase.TestData, 64)
		if err2 != nil {
			checkNotIntError = true
		}
		if passedData != testCase.ValidData {
			checkRangeError = true
		}

		if checkNotIntError || checkRangeError {
			if err1 == nil {
				t.Log("No error returned!")
			}
			require.NotNil(t, err1)

			if checkNotIntError {
				require.Equal(t, errNotFloat, err1)
			}
			if checkRangeError {
				require.Equal(t, errNotFloat64, err1)
			}
		}

		os.Unsetenv("FLOATDATA")
	}
}

func TestParseStructWithInterfaceFields(t *testing.T) {
	type testStruct struct {
		Data interface{}
	}

	os.Setenv(debugFlagEnvName, "true")

	testCase := &testStruct{}
	testCase.Data = 0

	os.Setenv("DATA", "64")

	err := Parse(testCase, nil)
	require.Nil(t, err)
	require.NotEqual(t, 64, testCase.Data)

	testCase1 := &testStruct{}
	d := 0
	shouldBeRaw := 64
	shouldBe := &shouldBeRaw
	testCase1.Data = &d

	err1 := Parse(testCase1, nil)
	require.Nil(t, err1)
	require.Equal(t, (*shouldBe), (*testCase1.Data.(*int)))

	os.Unsetenv("DATA")
	os.Unsetenv(debugFlagEnvName)
}

func TestParseStructWitStructAsInterface(t *testing.T) {
	type testStruct struct {
		Data interface{}
		Int  int
	}
	type testUnderlyingStruct struct {
		Data string
	}

	os.Setenv(debugFlagEnvName, "true")
	os.Setenv("INT", "64")
	os.Setenv("DATA_DATA", "Test data")

	testCase := &testStruct{}
	testUnderlyingCase := &testUnderlyingStruct{}
	testCase.Data = testUnderlyingCase
	err := Parse(testCase, nil)

	require.Nil(t, err)
	require.Equal(t, testCase.Int, 64)
	require.Equal(t, testCase.Data.(*testUnderlyingStruct).Data, "Test data")

	os.Unsetenv("INT")
	os.Unsetenv("DATA_DATA")
	os.Unsetenv(debugFlagEnvName)
}