package tencentNlu

import (
	"net"
	"speech-nlu-parse/dao"
	"speech-nlu-parse/global"
	"speech-nlu-parse/model"
	"speech-nlu-parse/pkg/errCode"
	"speech-nlu-parse/pkg/logger"

	_ "github.com/go-sql-driver/mysql"
	"github.com/tidwall/gjson"
)

func init() {
	// 注册
	register()
	registerV2()
	registerWs()
}

// 解析腾讯资源
func ParseTencentJson(jsonData []byte, mac string, tokenSearchResponse *model.TokenSearchResponse, query, mid string) []byte {
	//fmt.Println(string(jsonData))
	domain := gjson.GetBytes(jsonData, "header.semantic.domain")
	//isOtherDomain := false
	//items := ""
	var jsonByte []byte
	reply_when_tencent_empty = replyMessage[getRandom(len(replyMessage))]
	// 音乐
	// 新闻
	// 天气
	// 唐诗
	// 故事
	// 体育
	// 笑话
	// 星座
	// 节日
	// 股市
	// 翻译
	// 黄历
	// 财经
	// 食物
	// 一般问答
	// 百科
	// 成语
	// 科学
	// 菜谱
	// 历史
	// 聊天
	// 地理
	// 其他

	domainStr := domain.String()
	params := &model.DomainParams{JsonData: jsonData, TokenSearchResponse: tokenSearchResponse, Mac: mac, Domain: domainStr, Mid: mid, Query: query}

	// fmt.Println(global.GetLimitedSetting("6400").ShieldedDomainList)
	// 根据mid屏蔽部分domain, 并返回
	if IsContain(domainStr, global.GetLimitedSetting(mid).ShieldedDomainList) {
		jsonByte = shieldedDomain(params)
		return jsonByte
	}

	// 校验jsonData
	if !KeyValueCheck(jsonData) {
		// 异常时进行兜底
		return replyWithChat(error_reply, "doudi")
	}

	if value, ok := getHandler(domainStr); ok {
		jsonByte = value(params)
	} else {
		// 其他domain进行兜底
		jsonByte = otherDomain(params)
	}

	return jsonByte
}

// 增加兜底 zww 2018-11-23
func newModuleTest(jsonData []byte, query string) []byte {
	header := gjson.GetBytes(jsonData, "header")
	response_text := gjson.GetBytes(jsonData, "response_text")
	listItems := gjson.GetBytes(jsonData, "listItems")
	outputContextService := gjson.GetBytes(jsonData, "semantic.outputContext.service")
	jsonStr := ""
	if outputContextService.Exists() && outputContextService.Str == "TENCENT-NLU" {
		// 进行的协议转换, 直接返回
		return jsonData
	} else if !header.Exists() {
		//fmt.Println("json data header/payload dose not exists!")
		// items := `{"code":501,"errorType":"result header dose not exists!"}`
		return replyWithChat(error_reply, "doudi")
		// return []byte(items)
	} else if len(listItems.Array()) > 0 {
		jsonStr = `{"header":` + header.Raw + `,"response_text":` + response_text.Raw + `,"asr_recongize":"` +
			query + `","listItems":` + listItems.Raw + `}`
		return []byte(jsonStr)
		//} else if response_text.Str == "" && len(listItems.Array()) == 0 {
	} else if response_text.Str == "" {
		if len(listItems.Array()) == 0 && gjson.GetBytes(jsonData, "header.semantic.domain").String() != "news" {
			jsonStr = `{"header":` + header.Raw + `,"response_text":"` + reply_when_tencent_empty + `","asr_recongize":"` + query + `"}`

		} else {
			// response_text 为空字符串时回复不应该为"不支持此功能", 已修改
			// jsonStr = `{"header":` + header.Raw + `,"response_text":"` + reply_when_tencent_empty + `","asr_recongize":"` + query + `"}`
			jsonStr = `{"header":` + header.Raw + `,"response_text":"` + response_text.String() + `","asr_recongize":"` + query + `"}`

		}

		return []byte(jsonStr)
	} else if listItems.Exists() && len(listItems.Array()) == 0 {
		jsonStr = `{"header":` + header.Raw + `,"response_text":` + response_text.Raw + `,"asr_recongize":"` +
			query + `","listItems":[]}`
		return []byte(jsonStr)
	} else if response_text.Str == reply_when_tencent_empty {
		//utils.LogErrorToFile(logfileError, tencent_response_error + " errorquery:" + query)
		jsonStr = `{"header":` + header.Raw + `,"response_text":` + response_text.Raw + `,"asr_recongize":"` + query + `"}`
		return []byte(jsonStr)
	} else {
		jsonStr = `{"header":` + header.Raw + `,"response_text":` + response_text.Raw + `,"asr_recongize":"` + query + `"}`
		return []byte(jsonStr)
	}
}

func TencentNlu(reqStruct *model.SemanticReq) (string, *errCode.Error) {
	if reqStruct == nil {
		return string(replyWithChat(error_reply, "doudi")), errCode.RequestFormatError
	}

	// 结果
	var channelStr string

	//ts := time.Now()
	err, content, url := dao.GetTestContent(reqStruct.MacWifi, reqStruct.Query)
	//tc := time.Since(ts)
	//fmt.Println(time.Now().String()[:19], err, reqStruct.MacWifi, reqStruct.Query, tc)
	if err == nil {
		channelStr = string(getTencentSongReply(url, content, reqStruct.Query))
	} else {
		if reqStruct.Query == "声道测试" || reqStruct.Query == "音响音质测试" || reqStruct.Query == "音箱音质测试" {
			// channelStr = string(getTencentSongReply("", reqStruct.Query))
			// err, content, url := dao.GetAnyTestContent(reqStruct.MacWifi, reqStruct.Query)
			url = global.OthersSetting.SoundTestUrl
			content = ""
			channelStr = string(getTencentSongReply(url, content, reqStruct.Query))

		} else if reqStruct.Query == "重定向测试" {
			url = "http://nlu.gree.com/temp/music"
			content = ""
			channelStr = string(getTencentSongReply(url, content, reqStruct.Query))

		} else if reqStruct.Query == "编号七零六八一" && reqStruct.MacWifi == "f4911e594443" {
			channelStr = string(getGreeNluChatReply("好的，计时五分钟马上开始，五，四，三，二，一", "countdown", reqStruct.Query))
		} else {
			// 判断mid和MidType, 请求新接口
			var dingDangBot *model.DingDangBot
			var ok bool
			// 通过 mid 和 midType 去查找bot
			dingDangBot, ok = global.DingDangBot.Get(reqStruct.Mid, reqStruct.Vender)
			if ok {
				// if dingDangBot.UrlType == 1 { // 采用新接口
				// 	//GetTNluDataAndParse()
				// 	tencentNluV2 := TencentNluV2{
				// 		SemanticReq: reqStruct,
				// 	}
				// 	// tencentV2
				// 	// TODO: 新方案接口都采用流式接口, 不会有流量到该接口
				// 	return string(tencentNluV2.GetTNluDataAndParse(reqStruct, dingDangBot)), errCode.Success
				// }
			} else {
				global.Logger.WithFields(logger.Fields{"data": map[string]interface{}{
					"reqStruct": reqStruct,
				}, "requestId": reqStruct.RequestId, "mac": reqStruct.MacWifi, "mid": reqStruct.Mid, "vender": reqStruct.Vender}).Warnf("global.DingDangBot.Get error. mid vender is not exist.")

				// 未找到对应的bot, 采用默认的bot
				dingDangBot = &model.DingDangBot{
					Key:    "8d3b6076-3bb4-4c26-89c3-011447996044",
					Secret: "31b62495be9b4ff389ee952a4c4bd2cf",
				}
			}
			// 旧版tencent, 语音空调
			tencentRespByteData, tokenSearchResponse, err := GetTencentNLUData(reqStruct, dingDangBot)
			//tencent_test
			// fmt.Println("tencentRespByteData")
			// fmt.Println(string(tencentRespByteData))
			global.Logger.WithFields(logger.Fields{
				"data":      map[string]interface{}{"tencentRespStrData": string(tencentRespByteData)},
				"requestId": reqStruct.RequestId,
				"mac":       reqStruct.MacWifi,
				"mid":       reqStruct.Mid,
				"vender":    reqStruct.Vender,
			}).Debug("GetTencentNLUData.")
			if nil != err {
				if netErr, ok := err.(net.Error); ok && netErr.Timeout() { // 请求腾讯叮当超时
					global.Logger.WithFields(logger.Fields{"data": map[string]interface{}{"reqStruct": reqStruct},
						"requestId": reqStruct.RequestId,
						"mac":       reqStruct.MacWifi,
						"mid":       reqStruct.Mid,
						"vender":    reqStruct.Vender,
					}).Warn("request tencent nlu timeout. " + err.Error())
					return string(replyWithChat(error_reply, "tencent_timeout")), errCode.DingdangInterfaceTimeout
				}
				global.Logger.WithFields(logger.Fields{"data": map[string]interface{}{"reqStruct": reqStruct},
					"requestId": reqStruct.RequestId,
					"mac":       reqStruct.MacWifi,
					"mid":       reqStruct.Mid,
					"vender":    reqStruct.Vender,
				}).Error("Get Tencent API data error." + err.Error())
				// return `{"code":501,"errorType":"source api data error, check it and try again!"}`
				return string(replyWithChat(error_reply, "doudi")), errCode.InternalServiceError
			} else if string(tencentRespByteData) == "Frequency Beyond Limit" {
				global.Logger.WithFields(logger.Fields{"data": map[string]interface{}{"reqStruct": reqStruct},
					"requestId": reqStruct.RequestId,
					"mac":       reqStruct.MacWifi,
					"mid":       reqStruct.Mid,
					"vender":    reqStruct.Vender,
				}).Info("HandleService: Too many request." + err.Error())
				// return `{"code":501,"errorType":"source api error, check it and try again!"}`
				return string(replyWithChat(frequency_request_reply, "doudi")), errCode.DingdangInterfaceRequestFrequency
			}

			semanticRespByteData := ParseTencentJson(tencentRespByteData, reqStruct.MacWifi, tokenSearchResponse, reqStruct.OriginQuery, reqStruct.Mid)
			global.Logger.WithFields(logger.Fields{"data": map[string]interface{}{"semanticRespStrData": string(semanticRespByteData)},
				"requestId": reqStruct.RequestId,
				"mac":       reqStruct.MacWifi,
				"mid":       reqStruct.Mid,
				"vender":    reqStruct.Vender,
			}).Debug("ParseTencentJson.")

			semanticRespByteData = newModuleTest(semanticRespByteData, reqStruct.OriginQuery)
			//domain := gjson.GetBytes(semanticRespByteData, "header.semantic.domain")
			channelStr = string(semanticRespByteData)

		}
	}

	return channelStr, errCode.Success
}