/*
@Time : 2020/4/23 17:44
@Author : gaoshiyao
@File : field
@Software: GoLand
@Des:
*/
package service

import (
	"encoding/json"
	"errors"
	"fmt"
	"gitlab.wodcloud.com/apaas/apaas-meshproxy/src/client"
	"gitlab.wodcloud.com/apaas/apaas-meshproxy/src/model"
	"strconv"
	"time"
)

// 判断是否设置了敏感字段，并有敏感词
func CheckSensitiveField() bool {
	return true
}

//获取当日调用次数  返回是否到达当日访问量，是否到达敏感字段访问量
func QueryCallsCount(applyId string, filter model.ProxyData) (call bool, sensitiveCall bool, err error) {
	//连接redis
	redis, err := client.GetRedisClient()
	if err != nil {
		return
	}
	countStr, err := redis.Get(applyId)
	if err != nil && err.Error() != `redis: nil` {
		return
	}
	////  更新调用次数
	//err = UpdateCallsCount(applyId)
	//if err != nil {
	//	return false, err
	//}
	var count int
	call = true
	sensitiveCall = true
	if countStr == "" {
		expire := GetExpire()
		err = redis.Set(applyId, 1, expire)
		count = 1
	} else {
		count, err = strconv.Atoi(countStr)
		if err != nil {
			return
		}
		if count+1 > filter.Count {
			call = false
			return
		}
		//超过允许访问敏感字段次数
		if count+1 > filter.Sensitive_count && filter.Sensituve_word != "" {
			sensitiveCall = false
		}
		expire := GetExpire()
		err = redis.Set(applyId, count+1, expire)
	}
	return
}

//获取过期时间
func GetExpire() time.Duration {
	now := time.Now()
	timeStr := time.Now().AddDate(0, 0, 1).Format("2006-01-02")
	fmt.Println("timeStr:", timeStr)
	zero, _ := time.Parse("2006-01-02", timeStr)
	timeNumber := zero
	fmt.Println("timeNumber:", timeNumber)
	subMin := now.Sub(zero)
	fmt.Println(subMin.Minutes(), "分钟")
	return subMin
}

//过滤返回字段
func FiledFilter(proxyData model.ProxyData, respbody []byte) interface{} {
	model := make(map[string]interface{})
	realData := make(map[string]interface{})
	json.Unmarshal([]byte(proxyData.ResFields), &model)
	json.Unmarshal(respbody, &realData)
	return Change(model, realData)
}

//返回申请字段
func Change(model interface{}, returnData interface{}) interface{} {
	switch t := model.(type) {
	case map[string]interface{}:
		// TODO 判定值是否相等
		for k, v := range returnData.(map[string]interface{}) {
			flag := false
			for k1, v1 := range model.(map[string]interface{}) {
				if k == k1 {
					flag = true
					Change(v, v1)
				}
			}
			// 删除属性
			if !flag {
				fmt.Println("删除属性：", k)
				delete(returnData.(map[string]interface{}), k)
			}
		}
		break
	case []interface{}:
		for k, v := range returnData.([]interface{}) {
			switch v.(type) {
			case map[string]interface{}:
				for _, a2 := range model.([]interface{}) {
					for k1, v1 := range v.(map[string]interface{}) {
						flag := false
						for k2, v2 := range a2.(map[string]interface{}) {
							if k1 == k2 {
								flag = true
								Change(v1, v2)
							}
						}
						// 删除属性
						if !flag {
							fmt.Println("删除属性：", k)
							delete(v.(map[string]interface{}), k1)
						}
					}
				}
				break
			case []interface{}:
				for _, v2 := range model.([]interface{}) {
					fmt.Println(v2)
					Change(v2, v)
				}
				break
			default:
				// TODO 判断old是否有这个值
				fmt.Println("数组类型 |||||||||||||||||||||||||||||||| old=====new=====>: ", model, returnData)
			}
		}
		break
	default:
		fmt.Println("old=====new=====>: ", model, returnData)
		fmt.Println("类型是*******>：", t)
	}
	return returnData
}

//更新调用次数
func UpdateCallsCount(applyId string) (err error) {
	db, err := client.GetConnect()
	if err != nil {
		return
	}
	sql := `update service_apply set request_count = request_count+1  where service_apply.service_id = '?'`
	db.SQL(sql, applyId)

	return
}

//返回过滤后的敏感字段
func SensitiveFilter(proxyData model.ProxyData, res interface{}) interface{} {
	Sensituve_word := make(map[string]interface{})
	json.Unmarshal([]byte(proxyData.Sensituve_word), &Sensituve_word)
	return FilterSensituveField(Sensituve_word, res)
}

// 过滤敏感字段
func FilterSensituveField(model interface{}, returnData interface{}) (body interface{}) {
	switch t := model.(type) {
	case map[string]interface{}:
		// TODO 判定值是否相等
		for k, v := range returnData.(map[string]interface{}) {
			//flag := false
			for k1, v1 := range model.(map[string]interface{}) {
				if k == k1 {
					//flag = true
					switch v.(type) {
					case string:
						returnData.(map[string]interface{})[k] = `xxx`
					}
					FilterSensituveField(v, v1)
				}
			}
		}
		break
	case []interface{}:
		for _, v := range returnData.([]interface{}) {
			switch v.(type) {
			case map[string]interface{}:
				for _, a2 := range model.([]interface{}) {
					for k1, v1 := range v.(map[string]interface{}) {
						//flag := false
						for k2, v2 := range a2.(map[string]interface{}) {
							if k1 == k2 {
								//flag = true
								switch v.(map[string]interface{})[k1].(type) {
								case string:
									v.(map[string]interface{})[k1] = `xxx`
								}
								FilterSensituveField(v1, v2)
							}
						}
					}
				}
				break
			case []interface{}:
				for _, v2 := range model.([]interface{}) {
					fmt.Println(v2)
					FilterSensituveField(v2, v)
				}
				break
			default:
				// TODO 判断old是否有这个值
				fmt.Println("数组类型 |||||||||||||||||||||||||||||||| old=====new=====>: ", model, returnData)
			}
		}
		break
	default:
		fmt.Println("old=====new=====>: ", model, returnData)
		fmt.Println("类型是*******>：", t)
	}
	return returnData
}

// 获取真实地址和返回结构、调用限定次数
func GetRealPath(appId string) (res model.ProxyData, err error) {
	db, err := client.GetConnect()
	if err != nil {
		return
	}
	has, err := db.
		Select(`service_apply.res_fields as res_fields,service.req_url as req_url,service_request_spcs.count as count,service_safe_config.sensituve_word as sensituve_word
,service_request_spcs.sensitive_count as sensitive_count`).
		Table(`service`).
		Join(`left`, `service_apply`, `service_apply.service_id = service.id`).
		Join(`left`, `service_request_spcs`, `service_request_spcs.id = service_apply.request_spcs_id`).
		Join(`left`, `service_safe_config`, `service_apply.service_id = service_safe_config.service_id`).
		Where(`service_apply.id=?`, appId).Get(&res)
	if !has {
		err = errors.New(`未找到申请服务！`)
	}
	return
}