package resource

import (
	"bytes"
	"encoding/json"
	"fmt"
	"gitee.com/beijingxiugo/GolandAuto/assert"
	"gitee.com/beijingxiugo/GolandAuto/process"
	"gitee.com/beijingxiugo/GolandAuto/utils/jsonutil"
	"github.com/bitly/go-simplejson"
)

type CaseProperties struct {
	Name           string                 `json:"name"`
	Desc           string                 `json:"desc"`
	Level          string                 `json:"level"`
	Option         CaseOption             `json:"option"`
	Extra          map[string]interface{} `json:"extra"`
	DataPathPreFix string                 `json:"data_path_pre_fix"`
}

type CaseOption struct {
	Parallel   *bool
	Skip       *bool
	PathPreFix string
}

func (opt *CaseOption) Merge(targetOpt CaseOption) {
	opt.Skip = process.MergeBoolPtr(targetOpt.Skip, opt.Skip)
	opt.Parallel = process.MergeBoolPtr(targetOpt.Parallel, opt.Parallel)
}

func (opt *CaseOption) IsSkip() bool {
	return opt.Skip != nil && *opt.Skip
}

func (opt *CaseOption) IsParallel() bool {
	return opt.Parallel != nil && *opt.Parallel
}

func (p *CaseProperties) marshalExtra() []byte {
	b, e := json.Marshal(p.Extra)
	if e != nil {
		return nil
	}

	return b
}

func (p *CaseProperties) ConvertMap() map[string]interface{} {
	m := map[string]interface{}{}
	b, _ := json.Marshal(p)
	json.Unmarshal(b, &m)
	return m
}

func (p *CaseProperties) Unmarshal(m map[string]interface{}) {
	jsonutil.JsonMarshal2interface(m, &p)
}

func (p *CaseProperties) Merge(target map[string]interface{}) {
	if target["properties"] == nil {
		return
	}
	ret := process.MergeMap(p.ConvertMap(), target["properties"].(map[string]interface{}))
	p.Unmarshal(ret)
}

func (p *CaseProperties) ExtraProperties() *simplejson.Json {
	extra, e := simplejson.NewJson(p.marshalExtra())
	if e != nil {
		return simplejson.New()
	}

	return extra
}

type CaseData struct {
	// Properties include the basic properties of single case
	Properties CaseProperties `json:"properties"`
	// The Specific Input of case
	Input map[string]interface{} `json:"input" yaml:"input"`

	Actions map[string]interface{} `json:"actions"`

	// The expects of test method result
	Expects []assert.Expect `json:"expects" yaml:"expects"`

	SchemaFile string `json:"schema_file"`
}

type Action struct {
	Name    string          `json:"name"`
	Params  interface{}     `json:"params"`
	Expects []assert.Expect `json:"expects"`
}

func (cd *CaseData) InputJson() *simplejson.Json {
	b, e := json.Marshal(cd.Input)
	if e != nil {
		return nil
	}

	input, e := simplejson.NewJson(b)
	if e != nil {
		return simplejson.New()
	}

	return input
}

func (cd *CaseData) InputMarshal(target interface{}) error {
	b, e := json.Marshal(cd.Input)
	if e != nil {
		return nil
	}
	//return json.Unmarshal(b, target)
	d := json.NewDecoder(bytes.NewReader(b))
	d.UseNumber()
	return d.Decode(target)
}

func (cd *CaseData) CaseActionMarshal(target interface{}) error {
	b, e := json.Marshal(cd)
	if e != nil {
		return nil
	}
	d := json.NewDecoder(bytes.NewReader(b))
	d.UseNumber()

	return d.Decode(target)
	//return json.Unmarshal(b, target)
}

// CaseDataSet is the basic definition of data set file
type CaseDataSet struct {
	// GlobalOption takes effect when the option of single case is nil
	GlobalOption CaseOption `json:"global_option"`
	// CommonInput will be merged into the input of each single case
	CommonInput map[string]interface{} `json:"common_input"`

	CommonActions map[string]interface{} `json:"common_actions"`

	// Set is the actual case data definition
	Set []CaseData `json:"set"`
}

type CaseDataExpects struct {
	CaseName      string                     `json:"case_name"`
	ActionExpects map[string][]assert.Expect `json:"action_expects"`
	Expects       []assert.Expect            `json:"expects" yaml:"expects"`
}

func (dataSet *CaseDataSet) mergeCommon(dir string, common *CaseDataSet) {
	// merge common input and actions
	for i := 0; i < len(dataSet.Set); i++ {
		dataSet.Set[i].Input = process.MergeMap(dataSet.Set[i].Input, dataSet.CommonInput)
		dataSet.Set[i].Actions = process.MergeMap(dataSet.Set[i].Actions, dataSet.CommonActions)
	}

	// merge common case option
	globalOption := dataSet.GlobalOption
	for i := 0; i < len(dataSet.Set); i++ {
		dataSet.Set[i].Properties.Option.Merge(globalOption)
		dataSet.Set[i].Properties.DataPathPreFix = dir
	}

	// merge common case properties and actions
	if common != nil {
		for i := 0; i < len(dataSet.Set); i++ {
			dataSet.Set[i].Properties.Merge(common.CommonInput)
			dataSet.Set[i].Actions = process.MergeMap(dataSet.Set[i].Actions, common.CommonActions)
		}
	}
}

func (dataSet *CaseDataSet) FillDataFields(fieldsMap map[string][]map[string]interface{}) {
	newSet := []CaseData{}
	for i := 0; i < len(dataSet.Set); i++ {
		acIndex := 0
		for name, action := range dataSet.Set[i].Actions {
			k := fmt.Sprintf("%v:%v", dataSet.Set[i].Properties.Name, name)
			if fm, ok := fieldsMap[k]; ok {
				newSet = dataSet.genDataSet(i, name, newSet, action, fm)
			} else if acIndex == 0 {
				newSet = append(newSet, CaseData{
					Actions:    dataSet.Set[i].Actions,
					Properties: dataSet.Set[i].Properties,
					Input:      dataSet.Set[i].Input,
					Expects:    dataSet.Set[i].Expects,
				})
			}
			acIndex++
		}
	}

	dataSet.Set = newSet
}

func (dataSet *CaseDataSet) genDataSet(index int, name string, newSet []CaseData, action interface{},
	fieldsMap []map[string]interface{}) []CaseData {
	p := process.FindTargetFromMap(action, "params")
	originP := DeepCopy(p)

	for _, item := range fieldsMap {
		pp := process.ReplaceVariable(p, item)
		cd := CaseData{
			Actions:    DeepCopy(dataSet.Set[index].Actions).(map[string]interface{}),
			Properties: dataSet.Set[index].Properties,
			Input:      dataSet.Set[index].Input,
			Expects:    dataSet.Set[index].Expects,
		}

		cd.Actions[name] = process.MergeMergeParamsMap(
			cd.Actions[name].(map[string]interface{}),
			DeepCopy(pp).(map[string]interface{}), "params")

		newSet = append(newSet, cd)

		p = DeepCopy(originP)
	}
	return newSet
}

func DeepCopy(value interface{}) interface{} {
	if valueMap, ok := value.(map[string]interface{}); ok {
		newMap := make(map[string]interface{})
		for k, v := range valueMap {
			newMap[k] = DeepCopy(v)
		}

		return newMap
	}

	return value
}