/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package dubbo

import (
	"bytes"
	"context"
	"net/http"
	"testing"
)

import (
	"github.com/dubbogo/dubbo-go-pixiu-filter/pkg/api/config"
	"github.com/stretchr/testify/assert"
)

import (
	"github.com/apache/dubbo-go-pixiu/pkg/client"
	"github.com/apache/dubbo-go-pixiu/pkg/common/mock"
)

func TestQueryStringsMapper(t *testing.T) {
	r, _ := http.NewRequest("GET", "/mock/test?id=12345&age=19", bytes.NewReader([]byte("")))
	api := mock.GetMockAPI(config.MethodGet, "/mock/test")
	api.IntegrationRequest.MappingParams = []config.MappingParam{
		{
			Name:    "queryStrings.id",
			MapTo:   "0",
			MapType: "string",
		},
		{
			Name:    "queryStrings.name",
			MapTo:   "1",
			MapType: "string",
		},
		{
			Name:    "queryStrings.age",
			MapTo:   "jk",
			MapType: "int",
		},
	}

	req := client.NewReq(context.TODO(), r, api)

	params := newDubboTarget(api.IntegrationRequest.MappingParams)
	qs := queryStringsMapper{}
	// Giving valid mapping params
	err := qs.Map(api.IntegrationRequest.MappingParams[0], req, params, nil)
	// it should not return error
	assert.Nil(t, err)
	// it should update the target value in target position from corresponding query value in request.
	assert.Equal(t, params.Values[0], "12345")
	assert.Equal(t, params.Types[0], "string")
	// Giving valid mapping params and same target
	err = qs.Map(api.IntegrationRequest.MappingParams[1], req, params, nil)
	// it should return error when request does not contain the source parameter
	assert.EqualError(t, err, "Query parameter [name] does not exist")
	// Giving invalid mapping params that is not a number and same target
	err = qs.Map(api.IntegrationRequest.MappingParams[2], req, params, nil)
	// it should return error that points out the mapping param
	assert.EqualError(t, err, "Parameter mapping {queryStrings.age jk int} incorrect")

	r, _ = http.NewRequest("GET", "/mock/test?id=12345&age=19", bytes.NewReader([]byte("")))
	api = mock.GetMockAPI(config.MethodGet, "/mock/test")
	api.IntegrationRequest.MappingParams = []config.MappingParam{
		{
			Name:    "queryStrings.id",
			MapTo:   "1",
			MapType: "string",
		},
		{
			Name:    "queryStrings.age",
			MapTo:   "0",
			MapType: "int",
		},
	}

	req = client.NewReq(context.TODO(), r, api)
	params = newDubboTarget(api.IntegrationRequest.MappingParams)
	err = qs.Map(api.IntegrationRequest.MappingParams[0], req, params, nil)
	assert.Nil(t, err)
	assert.Equal(t, params.Values[1], "12345")
	assert.Equal(t, params.Types[1], "string")
	assert.Nil(t, params.Values[0])
	err = qs.Map(api.IntegrationRequest.MappingParams[1], req, params, nil)
	assert.Nil(t, err)
	assert.Equal(t, params.Types[0], "int")
	assert.Equal(t, params.Values[0], 19)
}

func TestHeaderMapper(t *testing.T) {
	r, _ := http.NewRequest("GET", "/mock/test?id=12345&age=19", bytes.NewReader([]byte("")))
	r.Header.Set("Auth", "1234567")
	api := mock.GetMockAPI(config.MethodGet, "/mock/test")
	api.IntegrationRequest.MappingParams = []config.MappingParam{
		{
			Name:    "headers.Auth",
			MapTo:   "0",
			MapType: "string",
		},
	}
	hm := headerMapper{}
	target := newDubboTarget(api.IntegrationRequest.MappingParams)
	req := client.NewReq(context.TODO(), r, api)

	err := hm.Map(api.IntegrationRequest.MappingParams[0], req, target, nil)
	assert.Nil(t, err)
	assert.Equal(t, target.Values[0], "1234567")
	assert.Equal(t, target.Types[0], "string")

	err = hm.Map(config.MappingParam{Name: "headers.Test", MapTo: "0"}, req, target, nil)
	assert.EqualError(t, err, "Header Test not found")
}

func TestBodyMapper(t *testing.T) {
	r, _ := http.NewRequest("POST", "/mock/test?id=12345&age=19", bytes.NewReader([]byte(`{"sex": "male", "name":{"firstName": "Joe", "lastName": "Biden"}}`)))
	r.Header.Set("Auth", "1234567")
	api := mock.GetMockAPI(config.MethodGet, "/mock/test")
	api.IntegrationRequest.MappingParams = []config.MappingParam{
		{
			Name:    "requestBody.sex",
			MapTo:   "0",
			MapType: "string",
		},
		{
			Name:    "requestBody.name.lastName",
			MapTo:   "1",
			MapType: "string",
		},
		{
			Name:    "requestBody.name",
			MapTo:   "2",
			MapType: "object",
		},
	}
	bm := bodyMapper{}
	target := newDubboTarget(api.IntegrationRequest.MappingParams)
	req := client.NewReq(context.TODO(), r, api)

	err := bm.Map(api.IntegrationRequest.MappingParams[0], req, target, nil)
	assert.Nil(t, err)
	assert.Equal(t, target.Values[0], "male")
	assert.Equal(t, target.Types[0], "string")

	err = bm.Map(api.IntegrationRequest.MappingParams[1], req, target, nil)
	assert.Nil(t, err)
	assert.Equal(t, target.Values[1], "Biden")
	assert.Equal(t, target.Types[1], "string")

	err = bm.Map(api.IntegrationRequest.MappingParams[2], req, target, nil)
	assert.Nil(t, err)
	assert.Equal(t, target.Types[2], "object")
	assert.Equal(t, target.Values[2], map[string]interface{}(map[string]interface{}{
		"firstName": "Joe", "lastName": "Biden",
	}))
}

func TestURIMapper(t *testing.T) {
	r, _ := http.NewRequest("POST", "/mock/12345/joe?age=19", bytes.NewReader([]byte(
		`{"sex": "male", "name":{"firstName": "Joe", "lastName": "Biden"}}`)))
	r.Header.Set("Auth", "1234567")
	api := mock.GetMockAPI(config.MethodGet, "/mock/:id/:name")
	api.IntegrationRequest.MappingParams = []config.MappingParam{
		{
			Name:    "requestBody.sex",
			MapTo:   "0",
			MapType: "string",
		},
		{
			Name:    "requestBody.name.lastName",
			MapTo:   "1",
			MapType: "string",
		},
		{
			Name:    "uri.name",
			MapTo:   "2",
			MapType: "object",
		},
		{
			Name:    "uri.id",
			MapTo:   "3",
			MapType: "string",
		},
	}

	um := uriMapper{}
	target := newDubboTarget(api.IntegrationRequest.MappingParams)
	req := client.NewReq(context.TODO(), r, api)
	err := um.Map(api.IntegrationRequest.MappingParams[3], req, target, nil)
	assert.Nil(t, err)
	err = um.Map(api.IntegrationRequest.MappingParams[2], req, target, nil)
	assert.Nil(t, err)
	assert.Equal(t, target.Values[2], "joe")
	assert.Equal(t, target.Types[2], "object")
	assert.Equal(t, target.Values[3], "12345")
	assert.Equal(t, target.Types[3], "string")
}

func TestValidateTarget(t *testing.T) {
	target := newDubboTarget([]config.MappingParam{
		{
			Name:    "requestBody.sex",
			MapTo:   "0",
			MapType: "string",
		},
	})
	val, err := validateTarget(target)
	assert.Nil(t, err)
	assert.NotNil(t, val)
	_, err = validateTarget(*target)
	assert.EqualError(t, err, "Target params for dubbo backend must be *dubbogoTarget")
	target2 := ""
	_, err = validateTarget(target2)
	assert.EqualError(t, err, "Target params for dubbo backend must be *dubbogoTarget")
}

func TestMapType(t *testing.T) {
	_, err := mapTypes("strings", 123)
	assert.EqualError(t, err, "Invalid parameter type: strings")

	val, err := mapTypes("string", 123)
	assert.Nil(t, err)
	assert.Equal(t, val, "123")
	_, err = mapTypes("string", []int{123, 222})
	assert.EqualError(t, err, "unable to cast []int{123, 222} of type []int to string")

	val, err = mapTypes("int", "123")
	assert.Nil(t, err)
	assert.Equal(t, val, 123)
	val, err = mapTypes("int", 123.6)
	assert.Nil(t, err)
	assert.Equal(t, val, 123)
	_, err = mapTypes("int", "123a")
	assert.EqualError(t, err, "unable to cast \"123a\" of type string to int")

	val, err = mapTypes("object", map[string]string{"abc": "123"})
	assert.Nil(t, err)
	assert.Equal(t, val, map[string]string{"abc": "123"})
	val, err = mapTypes("object", struct{ Abc string }{Abc: "123"})
	assert.Nil(t, err)
	assert.Equal(t, val, struct{ Abc string }{Abc: "123"})
	val, err = mapTypes("object", 123.6)
	assert.Nil(t, err)
	assert.Equal(t, val, 123.6)
}

func TestNewDubboTarget(t *testing.T) {
	mps := []config.MappingParam{
		{
			Name:  "string1",
			MapTo: "0",
		},
		{
			Name:  "string2",
			MapTo: "opt.values",
		},
	}
	target := newDubboTarget(mps)
	assert.NotNil(t, target)
	assert.Equal(t, len(target.Values), 2)

	mps = []config.MappingParam{
		{
			Name:  "string1",
			MapTo: "opt.interface",
		},
	}
	target = newDubboTarget(mps)
	assert.Nil(t, target)
}

func TestSetCommonTarget(t *testing.T) {
	vals := make([]interface{}, 10)
	types := make([]string, 10)
	target := &dubboTarget{
		Values: vals,
		Types:  types,
	}
	setCommonTarget(target, 1, 123, "int")
	assert.Equal(t, target.Values[1], 123)
	assert.Equal(t, target.Types[1], "int")
	assert.Nil(t, target.Values[0])
	assert.Equal(t, target.Types[0], "")
	setCommonTarget(target, 10, "123", "string")
	assert.Equal(t, target.Values[10], "123")
	assert.Equal(t, target.Types[10], "string")
}

func TestSetGenericTarget(t *testing.T) {
	api := mock.GetMockAPI(config.MethodGet, "/mock/test")
	r, _ := http.NewRequest("GET", "/mock/test?id=12345&age=19", bytes.NewReader([]byte("")))
	req := client.NewReq(context.TODO(), r, api)

	target := &dubboTarget{
		Values: make([]interface{}, 3),
		Types:  make([]string, 3),
	}

	opt := DefaultMapOption[optionKeyValues]
	err := setGenericTarget(req, opt, target, []interface{}{1, "abc", struct{ Name string }{"joe"}}, "int, string, object")
	assert.Nil(t, err)
	assert.Equal(t, target.Values[0], 1)
	assert.Equal(t, target.Values[1], "abc")
	assert.Equal(t, target.Values[2], struct{ Name string }{"joe"})
	assert.Equal(t, target.Types[0], "int")
	assert.Equal(t, target.Types[1], "string")
	assert.Equal(t, target.Types[2], "object")

	opt = DefaultMapOption[optionKeyTypes]
	err = setGenericTarget(req, opt, target, "int, object, object", "")
	assert.Nil(t, err)
	assert.Equal(t, target.Types[0], "int")
	assert.Equal(t, target.Types[1], "object")
	assert.Equal(t, target.Types[2], "object")

	opt = DefaultMapOption[optionKeyInterface]
	err = setGenericTarget(req, opt, target, "testingInterface", "")
	assert.Nil(t, err)
	assert.Equal(t, req.API.IntegrationRequest.Interface, "testingInterface")

	opt = DefaultMapOption[optionKeyApplication]
	err = setGenericTarget(req, opt, target, "testingApplication", "")
	assert.Nil(t, err)
	assert.Equal(t, req.API.IntegrationRequest.ApplicationName, "testingApplication")
}

func TestGetGenericMapTo(t *testing.T) {
	isGeneric, gMapTo := getGenericMapTo("1")
	assert.False(t, isGeneric)
	assert.Equal(t, gMapTo, "")

	isGeneric, gMapTo = getGenericMapTo("opt.interface")
	assert.True(t, isGeneric)
	assert.Equal(t, gMapTo, "interface")

	isGeneric, gMapTo = getGenericMapTo("opt.whatever")
	assert.False(t, isGeneric)
	assert.Equal(t, gMapTo, "")
}