package tencentNlu

import (
	"encoding/json"
	"errors"
	"fmt"
	"speech-nlu-parse/global"
	"speech-nlu-parse/model"
	"speech-nlu-parse/pkg/logger"
	"strings"

	"github.com/tidwall/gjson"
)

func baseParse(params *model.DomainParamsV2) (*model.ResponseBody, error) {
	// 解析code domain intent slots 等
	var res model.ResponseBody
	if !params.TencentNlpResp.CheckHeader() || !params.TencentNlpResp.CheckNlu() || !params.TencentNlpResp.CheckDm() || !params.TencentNlpResp.CheckSkill() {
		// 响应体内容缺少
		return nil, errors.New("TencentNlpResp check error.")
	}
	code := params.TencentNlpResp.GetCode()
	msg := params.TencentNlpResp.GetMessage()
	domain := params.TencentNlpResp.GetDomain()
	intent := params.TencentNlpResp.GetIntent()
	complete := params.TencentNlpResp.GetSessionComplete() // 当前会话是否结束
	slots := params.TencentNlpResp.GetSlots()              // 词槽
	text := params.TencentNlpResp.GetText()                // 回复语

	var resultComplete bool
	if complete == 1 {
		resultComplete = true
	} else {
		resultComplete = false
	}

	res.Header.Semantic.Code = code
	res.Header.Semantic.Domain = domain
	res.Header.Semantic.Intent = intent
	res.Header.Semantic.Msg = msg
	res.Header.Semantic.SessionComplete = resultComplete
	res.Header.Semantic.Slots = make([]map[string]interface{}, 0)
	res.Header.Semantic.Command = params.TencentNlpResp.GetCommand() // Command 透传

	for _, slot := range slots {
		tempSlot := make(map[string]interface{}, len(slot))
		for k, v := range slot {
			key := strings.ToLower(k)
			tempSlot[key] = v
		}
		res.Header.Semantic.Slots = append(res.Header.Semantic.Slots, tempSlot)
	}
	res.ResponseText = text
	res.AsrRecongize = params.Query
	return &res, nil
}

func Marshal(params *model.DomainParamsV2, res *model.ResponseBody) []byte {
	resByte, err := json.Marshal(res)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Errorf("Marshal error. %v", err)
		return replyWithChat(error_reply, "doudi")
	}
	return resByte
}

// tencent weather domain 新接口, 解析新的技能协议
func weatherDomainV2(params *model.DomainParamsV2) []byte {
	fmt.Println(params.TencentNlpResp)
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("weatherDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}

	resultComplete := res.Header.Semantic.SessionComplete

	var text string
	var selfData string
	var textContent string // 回复语

	var listItems []model.ListItem
	if params.TencentNlpResp.CheckWidgetData() {
		listItems = params.TencentNlpResp.GetListItems()
	}
	if len(listItems) > 0 {
		selfData = listItems[0].SelfData
		textContent = listItems[0].TextContent
		weatherIndex := gjson.GetBytes([]byte(selfData), "vecCityWeatherInfo.0.stDobbyCurrentWeather.sDWeaIndex").String()

		tips := ""
		if weatherIndex == "3" || weatherIndex == "4" || weatherIndex == "5" || weatherIndex == "6" {
			tips = weatherReplyMessage[getRandom(len(weatherReplyMessage))]
		}

		if resultComplete == true {
			text = textContent + tips
		} else {
			text = textContent
		}
	}
	if text != "" {
		res.ResponseText = text
	}
	res.ListItems = make([]map[string]interface{}, 0)

	// 增加带屏设备的输出

	// var selfDataMap map[string]interface{}
	// err = json.Unmarshal([]byte(selfData), &selfDataMap)
	// if err != nil {
	// 	global.Logger.WithFields(logger.Fields{
	// 		"requestId": params.RequestId,
	// 	}).Error("weatherDomainV2 Unmarshal error.")
	// 	return replyWithChat(error_reply, "doudi")
	// }

	res.ListItems = append(res.ListItems, map[string]interface{}{
		// "selfData":    selfDataMap,
		"textContent": textContent,
	})
	return Marshal(params, res)
}

// chat
func chatDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("chatDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}
	return Marshal(params, res)
}

// translate 翻译
func translateDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("translateDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}
	if !params.TencentNlpResp.CheckWidgetData() {
		// 响应体内容缺少
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("translateDomainV2 check error, WidgetData is not exist.")
		return replyWithChat(error_reply, "doudi")
	}

	slots := params.TencentNlpResp.GetSlots()
	for i := 0; i < len(slots); i++ {
		if key, ok := slots[i]["Name"]; ok && key == "language" {
			if value, ok := slots[i]["Value"]; ok && !(value == "英语" || value == "日语" || value == "韩语") {
				res.ResponseText = "当前仅支持英语、日语、韩语翻译。"
				return Marshal(params, res)
			}
		}
	}
	res.ListItems = make([]map[string]interface{}, 0)
	listItems := params.TencentNlpResp.GetListItems()
	if len(listItems) > 0 {
		for i := 0; i < len(listItems); i++ {
			res.ListItems = append(res.ListItems, map[string]interface{}{
				"selfData":    listItems[i].SelfData,
				"textContent": listItems[i].TextContent,
			})
		}
		res.ResponseText = listItems[0].TextContent
	}
	return Marshal(params, res)
}

// global_ctrl 全局控制
func globalCtrlDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("globalCtrlDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}

	res.ResponseText = params.TencentNlpResp.GetText()
	return Marshal(params, res)
}

// media_ctrl 媒体控制
func mediaCtrlDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("mediaCtrlDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}

	res.ResponseText = params.TencentNlpResp.GetText()
	return Marshal(params, res)
}

// Alarm 闹钟  Reminder_v2 提醒
func alarmDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("alarmDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}

	res.ResponseText = params.TencentNlpResp.GetText()
	return Marshal(params, res)
}

// music 音乐

// science 科学查询
func scienceDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("scienceDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}
	if !params.TencentNlpResp.CheckWidgetData() {
		// 响应体内容缺少
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("scienceDomainV2 check error, WidgetData is not exist.")
		return replyWithChat(error_reply, "doudi")
	}

	intent := params.TencentNlpResp.GetIntent()
	if intent == "calculator" {
		listItems := params.TencentNlpResp.GetListItems()
		calResult := gjson.GetBytes([]byte(listItems[0].SelfData), "sResult").String()
		if calResult == "" {
			res.ResponseText = params.TencentNlpResp.GetText()
		} else {
			res.ResponseText = "等于" + calResult
		}
	} else {
		res.ResponseText = params.TencentNlpResp.GetText()
	}
	return Marshal(params, res)
}

// chengyu 成语
func chengyuDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("chengyuDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}
	if !params.TencentNlpResp.CheckWidgetData() {
		// 响应体内容缺少
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("chengyuDomainV2 check error, WidgetData is not exist.")
		return replyWithChat(error_reply, "doudi")
	}

	listItems := params.TencentNlpResp.GetListItems()
	if len(listItems) > 0 {
		res.ResponseText = listItems[0].TextContent
	}
	return Marshal(params, res)
}

// baike 百科
func baikeDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("scienceDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}

	res.ListItems = make([]map[string]interface{}, 0)

	responseText := params.TencentNlpResp.GetText()
	if params.TencentNlpResp.CheckWidgetData() {
		listItems := params.TencentNlpResp.GetListItems()
		if len(listItems) > 0 {
			for i := 0; i < len(listItems); i++ {
				res.ListItems = append(res.ListItems, map[string]interface{}{
					"textContent": listItems[i].TextContent,
					"selfData":    listItems[i].SelfData,
					"title":       listItems[i].Title,
					"mediaId":     listItems[i].MediaId,
				})
			}
		}
	}
	res.ResponseText = responseText
	return Marshal(params, res)
}

// holiday
func holidayDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("holidayDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}

	var resultContent string
	resultContent = params.TencentNlpResp.GetText()
	var listItems []model.ListItem
	if params.TencentNlpResp.CheckWidgetData() {
		// 响应体内容缺少
		listItems = params.TencentNlpResp.GetListItems()

	}
	if len(listItems) > 0 {
		resultContent = listItems[0].TextContent
	}
	res.ListItems = make([]map[string]interface{}, 0)
	res.ResponseText = resultContent

	return Marshal(params, res)
}

// news
func newsDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("newsDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}

	intent := params.TencentNlpResp.GetIntent()
	switch intent {
	case "play", "playmore", "search", "":
		if params.TencentNlpResp.CheckWidgetData() {
			// 响应体内容缺少
			listItems := params.TencentNlpResp.GetListItems()
			if len(listItems) > 0 {
				res.ListItems = make([]map[string]interface{}, 0, len(listItems))
				for i := 0; i < len(listItems); i++ {
					res.ListItems = append(res.ListItems, map[string]interface{}{
						"url":      listItems[i].Audio.Stream.Url,
						"title":    listItems[i].Title,
						"newsFrom": gjson.Get(listItems[i].SelfData, "newsFrom").String(),
						"type":     gjson.Get(listItems[i].SelfData, "type").String(),
						// "content":  listItems[i].TextContent,
					})
				}
				res.ResponseText = "为你找到以下新闻:"
			}
		}
		return Marshal(params, res)
	default:
		// 其他intent
		// global.Logger.WithFields(logger.Fields{
		// 	"requestId": params.RequestId,
		// }).Error("newsDomainV2 unknow intent.")
		return Marshal(params, res)
	}
}

// ancientpoem
func ancientpoemDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("ancientpoemDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}
	// if !params.TencentNlpResp.CheckControlInfo() {
	// 	// 响应体内容缺少
	// 	global.Logger.WithFields(logger.Fields{
	// 		"requestId": params.RequestId,
	// 	}).Error("ancientpoemDomainV2 check error, ControlInfo is not exist.")
	// 	return replyWithChat(error_reply, "doudi")
	// }
	// resType := params.TencentNlpResp.GetType()
	res.ListItems = make([]map[string]interface{}, 0)

	if params.TencentNlpResp.CheckWidgetData() {
		// 响应体内容缺少
		listItems := params.TencentNlpResp.GetListItems()
		if len(listItems) > 0 {
			for i := 0; i < len(listItems); i++ {
				res.ListItems = append(res.ListItems, map[string]interface{}{
					// "type":    resType,
					"url":     listItems[i].Audio.Stream.Url,
					"title":   listItems[i].Title,
					"content": listItems[i].TextContent,
					"author":  gjson.Get(listItems[i].SelfData, "author").String(),
					"dynasty": gjson.Get(listItems[i].SelfData, "dynasty").String(),
					"mediaId": listItems[i].MediaId,
				})
			}
		}
	}
	// 因 流式语音服务业务逻辑问题, 需要将textContent拼接进Text中返回
	intent := res.Header.Semantic.Intent
	switch intent {
	case "search_ancientpoem_meaning", "search_ancientpoem_appreciation":
		// 查询古诗含义, 查询古诗鉴赏
		// 拼接textContent 和 Text
		var textContent string
		if len(res.ListItems) >= 1 {
			if temp, ok := res.ListItems[0]["content"]; ok {
				textContent = temp.(string)
			}
		}
		res.ResponseText = res.ResponseText + ":" + textContent
	}
	return Marshal(params, res)
}

// fmDomain
func fmDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("fmDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}
	text := params.TencentNlpResp.GetText()
	res.ResponseText = text

	res.ListItems = make([]map[string]interface{}, 0)
	if params.TencentNlpResp.CheckWidgetData() {
		// 响应体内容缺少
		listItems := params.TencentNlpResp.GetListItems()
		if len(listItems) > 0 {
			for i := 0; i < len(listItems); i++ {
				res.ListItems = append(res.ListItems, map[string]interface{}{
					"url":     listItems[i].Audio.Stream.Url,
					"title":   listItems[i].Title,
					"content": listItems[i].TextContent,
					"mediaId": listItems[i].MediaId,
				})
			}
		}
	}

	// intent := res.Header.Semantic.Intent
	// switch intent {
	// case "next3":
	// 	return transformGreeProtocolReply(params.Query, global.DOMAIN_PLAYCONTROL, global.INTENT_CONTROL_NEXT, nil)
	// case "prev":
	// 	return transformGreeProtocolReply(params.Query, global.DOMAIN_PLAYCONTROL, global.INTENT_CONTROL_PREVIOUS, nil)
	// // 禅道 #71
	// case "pause":
	// 	return transformGreeProtocolReply(params.Query, global.DOMAIN_PLAYCONTROL, global.INTENT_CONTROL_PAUSE, nil)
	// case "exit":
	// 	return transformGreeProtocolReply(params.Query, global.DOMAIN_PLAYCONTROL, global.INTENT_CONTROL_EXIT, nil)
	// case "stop":
	// 	return transformGreeProtocolReply(params.Query, global.DOMAIN_PLAYCONTROL, global.INTENT_CONTROL_STOP, nil)
	// case "palymore":
	// 	res.Header.Semantic.Intent = "play"
	// 	return Marshal(params, res)
	// }

	return Marshal(params, res)
}

// sport
func sportsDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("sportsDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}
	text := params.TencentNlpResp.GetText()

	if params.TencentNlpResp.CheckWidgetData() {
		listItems := params.TencentNlpResp.GetListItems()
		if len(listItems) > 0 {
			text = listItems[0].TextContent
		}
	}
	res.ResponseText = text
	return Marshal(params, res)
}

func jokeDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("jokeDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}
	res.ListItems = make([]map[string]interface{}, 0)

	text := params.TencentNlpResp.GetText()
	if params.TencentNlpResp.CheckWidgetData() {
		listItems := params.TencentNlpResp.GetListItems()
		if len(listItems) > 0 {
			for i := 0; i < len(listItems); i++ {
				res.ListItems = append(res.ListItems, map[string]interface{}{
					"url":     listItems[i].Audio.Stream.Url,
					"content": listItems[i].TextContent,
				})
			}
		}
	}
	res.ResponseText = text
	return Marshal(params, res)
}

func astroDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("astroDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}
	text := params.TencentNlpResp.GetText()
	res.ListItems = make([]map[string]interface{}, 0)
	if params.TencentNlpResp.CheckWidgetData() {
		listItems := params.TencentNlpResp.GetListItems()
		if len(listItems) > 0 {
			text = listItems[0].TextContent
		}
	}
	res.ResponseText = text
	return Marshal(params, res)
}

func stockDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("stockDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}
	text := params.TencentNlpResp.GetText()
	res.ListItems = make([]map[string]interface{}, 0)
	if params.TencentNlpResp.CheckWidgetData() {
		listItems := params.TencentNlpResp.GetListItems()
		if len(listItems) > 0 {
			text = listItems[0].TextContent
		}
	}
	res.ResponseText = text
	return Marshal(params, res)
}

func defaultDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("defaultDomain baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}
	return Marshal(params, res)
}

func musicDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("musicDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}
	res.ListItems = make([]map[string]interface{}, 0)

	if params.TencentNlpResp.CheckWidgetData() {
		// 响应体内容缺少
		listItems := params.TencentNlpResp.GetListItems()
		if len(listItems) > 0 {
			for i := 0; i < len(listItems); i++ {
				res.ListItems = append(res.ListItems, map[string]interface{}{
					"url":     listItems[i].Audio.Stream.Url,
					"singer":  gjson.Get(listItems[i].SelfData, "singer").String(),
					"song":    gjson.Get(listItems[i].SelfData, "song").String(),
					"mediaId": listItems[i].MediaId,
					"songId":  gjson.Get(listItems[i].SelfData, "songId").String(),
				})
			}
		}
	}

	return Marshal(params, res)
}

// volumectrl3
func volumeCtrl3DomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("volumeCtrl3Domain baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}
	return Marshal(params, res)
}

// screen_control
func screenCtrlDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("screenCtrlDomain baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}
	return Marshal(params, res)
}

// world_records_qa_pairs 世界之最
func worldRecordsQaPairsDomainV2(params *model.DomainParamsV2) []byte {
	res, err := baseParse(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
		}).Error("worldRecordsQaPairsDomainV2 baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}

	res.ResponseText = params.TencentNlpResp.GetText()
	return Marshal(params, res)
}