package validationmdl

import (
	"testing"

	"github.com/tidwall/gjson"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/loggermdl"
	requestValidator "corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/validationmdl/validationcore"
)

type RequestBodyData struct {
	Email    string `json:"email"`
	Password string `json:"password"`
}

//Validation rules
var validationRules = requestValidator.MapData{
	"email":    []string{"required", "min:7", "max:20", "email"},
	"password": []string{"required"},
}

//Validation messages
var validationMessages = requestValidator.MapData{
	// "email":    []string{"required:Email required", "min:Email min len", "max:Email max len", "email:Invalid email"},
	// "password": []string{"required:Password required"},
}

// func TestValidateRequest(t *testing.T) {

// 	//Cases for sending raw data in request
// 	//Case 1: Http request for sunny day scenario
// 	sunnyDayData := RequestBodyData{Email: "test@mkcl.org", Password: "test"}
// 	sunnyDayByteArray, _ := ffjson.Marshal(&sunnyDayData)
// 	sunnyDayHTTPRequest, _ := http.NewRequest("POST", "test.com", bytes.NewBufferString(string(sunnyDayByteArray)))
// 	sunnyDayHTTPRequest.Header.Set("Content-Type", "application/json")

// 	//Case 2 : Http request for blank email
// 	blankEmailData := RequestBodyData{Email: "", Password: "test"}
// 	blankEmailByteArray, _ := ffjson.Marshal(&blankEmailData)
// 	blankEmailHTTPRequest, _ := http.NewRequest("POST", "test.com", bytes.NewBufferString(string(blankEmailByteArray)))
// 	blankEmailHTTPRequest.Header.Set("Content-Type", "application/json")
// 	blankEmailExpectedResult := map[string]interface{}{
// 		"validationErrors": url.Values{
// 			"email": []string{"Email required", "Email min len", "Invalid email"},
// 		},
// 	}

// 	//Case 3 : Http request for blank password
// 	blankPasswordData := RequestBodyData{Email: "test@mkcl.org", Password: ""}
// 	blankPasswordByteArray, _ := ffjson.Marshal(&blankPasswordData)
// 	blankPasswordHTTPRequest, _ := http.NewRequest("POST", "test.com", bytes.NewBufferString(string(blankPasswordByteArray)))
// 	blankPasswordHTTPRequest.Header.Set("Content-Type", "application/json")
// 	blankPasswordExpectedResult := map[string]interface{}{
// 		"validationErrors": url.Values{
// 			"password": []string{"Password required"},
// 		},
// 	}

// 	//Case 4 : Http request for email with shorter length than required
// 	shortEmailLengthData := RequestBodyData{Email: "a@c.v", Password: "test"}
// 	shortEmailLengthByteArray, _ := ffjson.Marshal(&shortEmailLengthData)
// 	shortEmailLengthHTTPRequest, _ := http.NewRequest("POST", "test.com", bytes.NewBufferString(string(shortEmailLengthByteArray)))
// 	shortEmailLengthHTTPRequest.Header.Set("Content-Type", "application/json")
// 	shortEmailLengthExpectedResult := map[string]interface{}{
// 		"validationErrors": url.Values{
// 			"email": []string{"Email min len"},
// 		},
// 	}

// 	//Case 5 : Http request for email with longer length than required
// 	longEmailLengthData := RequestBodyData{Email: "testEmail@Testcompany.testdomain", Password: "test"}
// 	longEmailLengthByteArray, _ := ffjson.Marshal(&longEmailLengthData)
// 	longEmailLengthHTTPRequest, _ := http.NewRequest("POST", "test.com", bytes.NewBufferString(string(longEmailLengthByteArray)))
// 	longEmailLengthHTTPRequest.Header.Set("Content-Type", "application/json")
// 	longEmailLengthExpectedResult := map[string]interface{}{
// 		"validationErrors": url.Values{
// 			"email": []string{"Email max len"},
// 		},
// 	}

// 	//Case 6 : Http request for invalid email id
// 	invalidEmailData := RequestBodyData{Email: "testemail", Password: "test"}
// 	invalidEmailByteArray, _ := ffjson.Marshal(&invalidEmailData)
// 	invalidEmailHTTPRequest, _ := http.NewRequest("POST", "test.com", bytes.NewBufferString(string(invalidEmailByteArray)))
// 	invalidEmailHTTPRequest.Header.Set("Content-Type", "application/json")
// 	invalidEmailExpectedResult := map[string]interface{}{
// 		"validationErrors": url.Values{
// 			"email": []string{"Invalid email"},
// 		},
// 	}

// 	//Case 7 : Http request for blank email using form encoding
// 	sunnyDayForm := url.Values{}
// 	sunnyDayForm.Add("email", "")
// 	sunnyDayForm.Add("password", "password")
// 	sunnyDayHTTPRequestFormEnc, _ := http.NewRequest("POST", "test.com", strings.NewReader(sunnyDayForm.Encode()))
// 	sunnyDayHTTPRequestFormEnc.PostForm = sunnyDayForm
// 	sunnyDayHTTPRequestFormEnc.Header.Set("Content-Type", "application/x-www-form-urlencoded")
// 	sunnyDayExpectedResultFormEnc := map[string]interface{}{
// 		"validationErrors": url.Values{
// 			"email": []string{"Email required", "Email min len", "Invalid email"},
// 		},
// 	}

// 	//Case 8 : Http request for blank email using form encoding
// 	blankEmailForm := url.Values{}
// 	blankEmailForm.Add("email", "")
// 	blankEmailForm.Add("password", "password")
// 	blankEmailHTTPRequestFormEnc, _ := http.NewRequest("POST", "test.com", strings.NewReader(blankEmailForm.Encode()))
// 	blankEmailHTTPRequestFormEnc.PostForm = blankEmailForm
// 	blankEmailHTTPRequestFormEnc.Header.Set("Content-Type", "application/x-www-form-urlencoded")
// 	blankEmailExpectedResultFormEnc := map[string]interface{}{
// 		"validationErrors": url.Values{
// 			"email": []string{"Email required", "Email min len", "Invalid email"},
// 		},
// 	}

// 	//Case 9 : Http request for blank password using form encoding
// 	blankPasswordForm := url.Values{}
// 	blankPasswordForm.Add("email", "test@mkcl.org")
// 	blankPasswordForm.Add("password", "")
// 	blankPasswordHTTPRequestFormEnc, _ := http.NewRequest("POST", "test.com", strings.NewReader(blankPasswordForm.Encode()))
// 	blankPasswordHTTPRequestFormEnc.PostForm = blankPasswordForm
// 	blankPasswordHTTPRequestFormEnc.Header.Set("Content-Type", "application/x-www-form-urlencoded")
// 	blankPasswordExpectedResultFormEnc := map[string]interface{}{
// 		"validationErrors": url.Values{
// 			"password": []string{"Password required"},
// 		},
// 	}

// 	//Case 10 : Http request for email with shorter length than required using form encoding
// 	shortEmailLengthForm := url.Values{}
// 	shortEmailLengthForm.Add("email", "a@v.c")
// 	shortEmailLengthForm.Add("password", "testPass")
// 	shortEmailLengthHTTPRequestFormEnc, _ := http.NewRequest("POST", "test.com", strings.NewReader(shortEmailLengthForm.Encode()))
// 	shortEmailLengthHTTPRequestFormEnc.PostForm = shortEmailLengthForm
// 	shortEmailLengthHTTPRequestFormEnc.Header.Set("Content-Type", "application/x-www-form-urlencoded")
// 	shortEmailLengthExpectedResultFormEnc := map[string]interface{}{
// 		"validationErrors": url.Values{
// 			"email": []string{"Email min len"},
// 		},
// 	}

// 	//Case 11 : Http request for email with longer length than required using form encoding
// 	longEmailLengthForm := url.Values{}
// 	longEmailLengthForm.Add("email", "testEmail@Testcompany.testdomain")
// 	longEmailLengthForm.Add("password", "testPass")
// 	longEmailLengthHTTPRequestFormEnc, _ := http.NewRequest("POST", "test.com", strings.NewReader(longEmailLengthForm.Encode()))
// 	longEmailLengthHTTPRequestFormEnc.PostForm = longEmailLengthForm
// 	longEmailLengthHTTPRequestFormEnc.Header.Set("Content-Type", "application/x-www-form-urlencoded")
// 	longEmailLengthExpectedResultFormEnc := map[string]interface{}{
// 		"validationErrors": url.Values{
// 			"email": []string{"Email max len"},
// 		},
// 	}

// 	//Case 12 : Http request for invalid email using form encoding
// 	invalidEmailLengthForm := url.Values{}
// 	invalidEmailLengthForm.Add("email", "testasdfasdf")
// 	invalidEmailLengthForm.Add("password", "test")
// 	invalidEmailLengthHTTPRequestFormEnc, _ := http.NewRequest("POST", "test.com", strings.NewReader(invalidEmailLengthForm.Encode()))
// 	invalidEmailLengthHTTPRequestFormEnc.PostForm = invalidEmailLengthForm
// 	invalidEmailLengthHTTPRequestFormEnc.Header.Set("Content-Type", "application/x-www-form-urlencoded")
// 	invalidEmailLengthExpectedResultFormEnc := map[string]interface{}{
// 		"validationErrors": url.Values{
// 			"email": []string{"Invalid email"},
// 		},
// 	}

// 	type args struct {
// 		httpRequest        *http.Request
// 		validationRules    requestValidator.MapData
// 		validationMessages requestValidator.MapData
// 	}
// 	tests := []struct {
// 		name string
// 		args args
// 		want map[string]interface{}
// 	}{
// 		{"TestSunnyDay", args{sunnyDayHTTPRequest, validationRules, validationMessages}, nil},
// 		{"BlankEmailValidation", args{blankEmailHTTPRequest, validationRules, validationMessages}, blankEmailExpectedResult},
// 		{"BlankPasswordValidation", args{blankPasswordHTTPRequest, validationRules, validationMessages}, blankPasswordExpectedResult},
// 		{"ShortEmailLengthValidation", args{shortEmailLengthHTTPRequest, validationRules, validationMessages}, shortEmailLengthExpectedResult},
// 		{"LongEmailLengthValidation", args{longEmailLengthHTTPRequest, validationRules, validationMessages}, longEmailLengthExpectedResult},
// 		{"InvalidEmailValidation", args{invalidEmailHTTPRequest, validationRules, validationMessages}, invalidEmailExpectedResult},
// 		{"SunnyDayFormEnc", args{sunnyDayHTTPRequestFormEnc, validationRules, validationMessages}, sunnyDayExpectedResultFormEnc},
// 		{"BlankEmailValidationFormEnc", args{blankEmailHTTPRequestFormEnc, validationRules, validationMessages}, blankEmailExpectedResultFormEnc},
// 		{"BlankPasswordValidationFormEnc", args{blankPasswordHTTPRequestFormEnc, validationRules, validationMessages}, blankPasswordExpectedResultFormEnc},
// 		{"ShortEmailLengthValidationFormEnc", args{shortEmailLengthHTTPRequestFormEnc, validationRules, validationMessages}, shortEmailLengthExpectedResultFormEnc},
// 		{"LongEmailLengthValidationFormEnc", args{longEmailLengthHTTPRequestFormEnc, validationRules, validationMessages}, longEmailLengthExpectedResultFormEnc},
// 		{"InvalidEmailLengthValidationFormEnc", args{invalidEmailLengthHTTPRequestFormEnc, validationRules, validationMessages}, invalidEmailLengthExpectedResultFormEnc},
// 	}
// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			if got := ValidateRequest(tt.args.httpRequest, tt.args.validationRules, tt.args.validationMessages); !reflect.DeepEqual(got, tt.want) {
// 				t.Errorf("ValidateRequest() = %v, want %v", got, tt.want)
// 			}
// 		})
// 	}

// }

// func BenchmarkValidateRequest(b *testing.B) {

// 	//Validation rules
// 	validationRules := requestValidator.MapData{
// 		"email":    []string{"required", "min:5", "max:20", "email"},
// 		"password": []string{"required"},
// 	}
// 	//Validation messages
// 	validationMessages := requestValidator.MapData{
// 		"email":    []string{"required:Email Id is required", "min:Min length 5 required", "max:Max length 20 allowed", "email:Enter a valid email"},
// 		"password": []string{"required:Password is required"},
// 	}

// 	sunnyDayData := RequestBodyData{Email: "test@mkcl.org", Password: "test"}
// 	sunnyDayByteArray, _ := ffjson.Marshal(&sunnyDayData)
// 	sunnyDayHTTPRequest, _ := http.NewRequest("POST", "test.com", bytes.NewBufferString(string(sunnyDayByteArray)))
// 	sunnyDayHTTPRequest.Header.Set("Content-Type", "application/json")

// 	for i := 0; i < b.N; i++ {

// 		ValidateRequest(sunnyDayHTTPRequest, validationRules, validationMessages)

// 	}
// }

// func BenchmarkYQLTestAgainstValidator(b *testing.B) {

// 	for i := 0; i < b.N; i++ {

// 		rawYQL := `age>=23`
// 		yql.Match(rawYQL, map[string]interface{}{
// 			"age": int64(24),
// 		})
// 	}
// }

// func BenchmarkValidationTestAgainstYQL(b *testing.B) {

// 	type TestData struct {
// 		Age int64 `json:"age"`
// 	}

// 	validationRules := requestValidator.MapData{
// 		"age": []string{"required", "min:23"},
// 	}

// 	sunnyDayData := TestData{Age: 24}
// 	sunnyDayByteArray, _ := ffjson.Marshal(&sunnyDayData)
// 	sunnyDayHTTPRequest, _ := http.NewRequest("POST", "test.com", bytes.NewBufferString(string(sunnyDayByteArray)))
// 	sunnyDayHTTPRequest.Header.Set("Content-Type", "application/json")

// 	for i := 0; i < b.N; i++ {
// 		ValidateRequest(sunnyDayHTTPRequest, validationRules, nil)
// 	}
// }

type StructToValidate struct {
	Name   string `json:"name" valid:"required,alpha,length(4|8)"`
	Email  string `json:"email" valid:"required,email"`
	Age    int    `json:"age" valid:"required,range(18|50)"`
	Mobile string `json:"mobile" valid:"required"`
}

func GetProperStruct() StructToValidate {
	structToValidate := StructToValidate{}
	structToValidate.Name = "testmkcl"
	structToValidate.Email = "test@mkcl.org"
	structToValidate.Age = 40
	structToValidate.Mobile = "1234567890"
	return structToValidate
}

func GetErrorStruct() StructToValidate {
	structToValidate := StructToValidate{}
	structToValidate.Name = ""
	structToValidate.Email = "testmkcl.org"
	structToValidate.Age = 40
	structToValidate.Mobile = "1234567890"
	return structToValidate
}
func GetEmptyStruct() StructToValidate {
	structToValidate := StructToValidate{}
	return structToValidate
}

// func TestValidateStruct(t *testing.T) {
// 	structToValidate := GetProperStruct()
// 	err := ValidateStruct(structToValidate)
// 	assert.NoError(t, err, "This should not return error")
// }
// func TestValidateStructEmptyStruct(t *testing.T) {
// 	errormdl.IsTestingNegetiveCaseOnCheckBool = true
// 	structToValidate := GetEmptyStruct()
// 	err := ValidateStruct(structToValidate)
// 	errormdl.IsTestingNegetiveCaseOnCheckBool = false
// 	assert.Error(t, err, "This should return error")
// }

// func TestValidateStructInvalidStruct(t *testing.T) {
// 	errormdl.IsTestingNegetiveCaseOnCheckBool = true
// 	structToValidate := GetErrorStruct()
// 	err := ValidateStruct(structToValidate)
// 	errormdl.IsTestingNegetiveCaseOnCheckBool = false
// 	assert.Error(t, err, "This should return error")
// }
// func TestValidateStructTypeCheck(t *testing.T) {
// 	errormdl.IsTestingNegetiveCaseOnCheckBool = true
// 	structToValidate := GetProperStruct()
// 	err := ValidateStruct(structToValidate)
// 	errormdl.IsTestingNegetiveCaseOnCheckBool = false
// 	assert.Error(t, err, "This should return error")
// }

// func BenchmarkValidateStruct(b *testing.B) {
// 	structToValidate := GetProperStruct()
// 	for i := 0; i < b.N; i++ {
// 		ValidateStruct(structToValidate)
// 	}
// }

// func TestNewJsonValidation(t *testing.T) {

// 	// json.NewDecoder(v.Opts.Request.Body).Decode(v.Opts.Data)

// 	requestBodyData := RequestBodyData{Email: "test@mkcl.org", Password: "test"}

// 	dataByteArray, _ := ffjson.Marshal(&requestBodyData)

// 	opts := requestValidator.Options{
// 		Rules:    validationRules,
// 		JSONData: dataByteArray,
// 	}

// 	validator := requestValidator.New(opts)
// 	validationErrors := validator.ValidateJSONData()

// 	loggermdl.LogSpot("Validation error : ", validationErrors)
// }

// func TestNewJsonValidationMDL(t *testing.T) {

// 	// json.NewDecoder(v.Opts.Request.Body).Decode(v.Opts.Data)

// 	// jsonData := RequestBodyData{Email: "test@mkcl.org", Password: "test"}
// 	// dataByteArray, _ := ffjson.Marshal(&jsonData)

// 	jsonString := `{"email":"test@mkcl.org","password":"test"}`

// 	// fmt.Println("json string : ", string(dataByteArray))

// 	validationErrors := ValidateJSONString(jsonString, validationRules, validationMessages)

// 	loggermdl.LogSpot("Validation error : ", validationErrors)
// }

//Benchmarking method to test JSON validation without using http request
// func BenchmarkValidateJSON(b *testing.B) {

// 	jsonData := RequestBodyData{Email: "test@mkcl.org", Password: "test"}
// 	dataByteArray, _ := ffjson.Marshal(&jsonData)

// 	for i := 0; i < b.N; i++ {
// 		ValidateJSONData(dataByteArray, validationRules, validationMessages)
// 	}

// 	// loggermdl.LogError("Count : ", requestValidator)
// }

//Benchmarking method to test JSON validtion using http request
// func BenchmarkValidateJSONRequest(b *testing.B) {

// 	sunnyDayData := RequestBodyData{Email: "test@mkcl.org", Password: "test"}
// 	sunnyDayByteArray, _ := ffjson.Marshal(&sunnyDayData)
// 	sunnyDayHTTPRequest, _ := http.NewRequest("POST", "test.com", bytes.NewBufferString(string(sunnyDayByteArray)))
// 	sunnyDayHTTPRequest.Header.Set("Content-Type", "application/json")

// 	for i := 0; i < b.N; i++ {
// 		ValidateRequest(sunnyDayHTTPRequest, validationRules, validationMessages)
// 	}
// 	// loggermdl.LogError("Count : ", requestValidator.Cnt)
// }

// //Benckmarking method to testing JSON string validation

func BenchmarkValidateJSONString(b *testing.B) {

	jsonString := `{"email":"tessdcet@mkcl.org"}`
	// jsonString := `{"email":"test@mkcl.org","password":"test"}`

	var validationRules = requestValidator.MapData{
		"email": []string{"required", "email"},
		// "password": []string{"required"},
	}

	for i := 0; i < b.N; i++ {
		ValidateJSONString(jsonString, validationRules, validationMessages)
	}
}

func TestValidateJSONString(t *testing.T) {
	jsonString := `{"email": "xcvbnm,./dfghjkl"}`
	// jsonString1 := `{"password":"testrfew@mkcl.org"}`
	// jsonString := `{"email":"test@mkcl.org","password":"test"}`

	var validationRules1 = requestValidator.MapData{
		"email": []string{"required"},
		// "name": []string{"required"},
	}

	// var validationRules2 = requestValidator.MapData{
	// 	"password": []string{"required"},
	// 	"email":    []string{"required"},
	// }

	mapErr := ValidateJSONString(jsonString, validationRules1, validationMessages)
	if mapErr != nil {
		loggermdl.LogError(mapErr)
	}
	// mapErr = ValidateJSONString(jsonString1, validationRules2, validationMessages)
	// if mapErr != nil {
	// 	loggermdl.LogError(mapErr)
	// }
}

func Test1(t *testing.T) {
	data := `{
		"email":""
	}`
	rs := gjson.Parse(data)
	validationRules := requestValidator.MapData{
		"email": []string{"required"},
	}
	err := ValidateGJSONResult(&rs, validationRules, validationMessages)
	if err != nil {
		loggermdl.LogError(err)
	}
}