package tencentNlu

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

	"github.com/tidwall/gjson"
)

func baseParseWs(params *model.DomainParamsWs) (*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() // 当前会话是否结束, wss 不再下发该字段
	slots := params.TencentNlpResp.GetSlots() // 词槽
	text := params.TencentNlpResp.GetText()   // 回复语
	sessionStatus := params.TencentNlpResp.GetSessionStatus()

	var resultComplete bool
	if sessionStatus == 0 || sessionStatus == 3 {
		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 MarshalWs(params *model.DomainParamsWs, 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,
			"sessionId": params.SessionId,
		}).Errorf("Marshal error. %v", err)
		return replyWithChat(error_reply, "doudi")
	}
	return resByte
}

// tencent weather domain 新接口, 解析新的技能协议
func weatherDomainWs(params *model.DomainParamsWs) []byte {
	res, err := baseParseWs(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
			"sessionId": params.SessionId,
		}).Error("weatherDomainWs 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 MarshalWs(params, res)
}

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

// translate 翻译
func translateDomainWs(params *model.DomainParamsWs) []byte {
	res, err := baseParseWs(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
			"sessionId": params.SessionId,
		}).Error("translateDomainWs 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,
			"sessionId": params.SessionId,
		}).Error("translateDomainWs 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 MarshalWs(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 MarshalWs(params, res)
}

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

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

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

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

func alarmDevFilter(params *model.DomainParamsWs) bool {
	if params.Mid == "10f05" && params.MidType == "87654321" {
		return true
	} else if params.Mid == "10f05" && params.MidType == "7e000024" && params.AppKey == "a8814080829e11eda5c8e38bb1008e50" {
		return true
	}
	return false
}

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

	if !alarmDevFilter(params) {
		return MarshalWs(params, res)
	}

	command := params.TencentNlpResp.GetCommand()
	cmdName := command.Name

	switch cmdName {
	case "Command://Tencent.Alarm.Create", "Command://Tencent.Alarm.Open",
		"Command://Tencent.Alarm.Close", "Command://Tencent.Alarm.Check",
		"Command://Tencent.Alarm.Delete", "Command://Tencent.Alarm.Modify",
		"Command://Tencent.GlobalCtrl.TurnPage", "Command://Tencent.GlobalCtrl.SelectPage",
		"Command://Tencent.Reminder.Create", "Command://Tencent.Reminder.Check",
		"Command://Tencent.Reminder.GrantPermissions", "Command://Tencent.Reminder.DeleteById",
		"Command://Tencent.Reminder.Delete", "Command://Tencent.Reminder.Modify",
		"Command://Tencent.Semantic.Specific":
		tencentNlpSkill := TencentNlpSkill{}
		reqBody, err := tencentNlpSkill.GetCommandReq(params.Mac, params.HomeId, params.RequestId, params.TencentNlpResp)
		if err != nil {
			global.Logger.WithFields(logger.Fields{
				"requestId": params.RequestId,
				"mac":       params.Mac,
				"mid":       params.Mid,
				"vender":    params.MidType,
				"sessionId": params.SessionId,
			}).Error("tencentNlpSkill.GetReq error.")
			return replyWithChat(error_reply, "doudi")
		}
		resp, err := tencentNlpSkill.Req(params, reqBody)
		if err != nil {
			global.Logger.WithFields(logger.Fields{
				"requestId": params.RequestId,
				"mac":       params.Mac,
				"mid":       params.Mid,
				"vender":    params.MidType,
				"sessionId": params.SessionId,
			}).Errorf("tencentNlpSkill.Req error. %v", err)
			return replyWithChat(error_reply, "doudi")
		}
		if !CheckStatusCode(resp) {
			global.Logger.WithFields(logger.Fields{
				"data": map[string]interface{}{
					"tencentNlpSkillRespBody": resp,
					// "query":                     data.Query,
				},
				"requestId": params.RequestId,
				"mac":       params.Mac,
				"mid":       params.Mid,
				"vender":    params.MidType,
				"sessionId": params.SessionId,
			}).Info("tencentNlpSkill.Req code error.")
		}

		responseText := resp.GetResponse().GetText()

		res.ResponseText = responseText
		return MarshalWs(params, res)

	}

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

// music 音乐

// science 科学查询
func scienceDomainWs(params *model.DomainParamsWs) []byte {
	res, err := baseParseWs(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
			"sessionId": params.SessionId,
		}).Error("scienceDomainWs 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,
			"sessionId": params.SessionId,
		}).Error("scienceDomainWs 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 MarshalWs(params, res)
}

// chengyu 成语
func chengyuDomainWs(params *model.DomainParamsWs) []byte {
	res, err := baseParseWs(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
			"sessionId": params.SessionId,
		}).Error("chengyuDomainWs 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,
			"sessionId": params.SessionId,
		}).Error("chengyuDomainWs 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 MarshalWs(params, res)
}

// baike 百科
func baikeDomainWs(params *model.DomainParamsWs) []byte {
	res, err := baseParseWs(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
			"sessionId": params.SessionId,
		}).Error("scienceDomainWs 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 MarshalWs(params, res)
}

// holiday
func holidayDomainWs(params *model.DomainParamsWs) []byte {
	res, err := baseParseWs(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
			"sessionId": params.SessionId,
		}).Error("holidayDomainWs 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 MarshalWs(params, res)
}

// news
func newsDomainWs(params *model.DomainParamsWs) []byte {
	res, err := baseParseWs(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
			"sessionId": params.SessionId,
		}).Error("newsDomainWs 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(),
						"newsType": gjson.Get(listItems[i].SelfData, "type").String(),
						// "content":  listItems[i].TextContent,
					})
				}
				res.ResponseText = "为你找到以下新闻:"
			}
		}
		return MarshalWs(params, res)
	default:
		// 其他intent
		// global.Logger.WithFields(logger.Fields{
		// 	"requestId": params.RequestId,
		// }).Error("newsDomainWs unknow intent.")
		return MarshalWs(params, res)
	}
}

// ancientpoem
func ancientpoemDomainWs(params *model.DomainParamsWs) []byte {
	res, err := baseParseWs(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
			"sessionId": params.SessionId,
		}).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++ {
				var title string
				if listItems[i].Title == "" {
					title = gjson.Get(listItems[i].SelfData, "title").String()
				} else {
					title = listItems[i].Title
				}
				res.ListItems = append(res.ListItems, map[string]interface{}{
					// "type":    resType,
					"url":     listItems[i].Audio.Stream.Url,
					"title":   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 MarshalWs(params, res)
}

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

	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++ {
				if gjson.Get(listItems[i].SelfData, "eShowType").Int() == 1 {
					// 过滤直播类型的链接
					if params.Mid == "10f05" && params.MidType == "7e000024" && params.AppKey == "a8814080829e11eda5c8e38bb1008e50" {
						// 固定机型进行此类处理
						liveUrlFlag = true
						continue
					}
				}
				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,
				})
			}
		}
	}

	if liveUrlFlag && len(res.ListItems) == 0 {
		res.ResponseText = "小格没有找到相关的资源哦"
	}

	// 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 MarshalWs(params, res)
}

// sport
func sportsDomainWs(params *model.DomainParamsWs) []byte {
	res, err := baseParseWs(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
			"sessionId": params.SessionId,
		}).Error("sportsDomainWs 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 MarshalWs(params, res)
}

func jokeDomainWs(params *model.DomainParamsWs) []byte {
	res, err := baseParseWs(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
			"sessionId": params.SessionId,
		}).Error("jokeDomainWs 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,
				})
			}
		}
	}
	if text == "" {
		text = "好的"
	}
	res.ResponseText = text
	return MarshalWs(params, res)
}

func astroDomainWs(params *model.DomainParamsWs) []byte {
	res, err := baseParseWs(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
			"sessionId": params.SessionId,
		}).Error("astroDomainWs 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 MarshalWs(params, res)
}

func stockDomainWs(params *model.DomainParamsWs) []byte {
	res, err := baseParseWs(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
			"sessionId": params.SessionId,
		}).Error("stockDomainWs 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 MarshalWs(params, res)
}

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

func musicDomainWs(params *model.DomainParamsWs) []byte {
	res, err := baseParseWs(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
			"sessionId": params.SessionId,
		}).Error("musicDomainWs 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 MarshalWs(params, res)
}

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

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

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

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

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

// sound
func soundDomainWs(params *model.DomainParamsWs) []byte {
	res, err := baseParseWs(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
			"sessionId": params.SessionId,
		}).Error("soundDomainWs 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,
					"title":   listItems[i].Title,
					"content": listItems[i].TextContent,
					"mediaId": listItems[i].MediaId,
				})
			}
		}
	}

	return MarshalWs(params, res)
}

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

	return MarshalWs(params, res)
}

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

	return MarshalWs(params, res)
}

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

	return MarshalWs(params, res)
}

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

	return MarshalWs(params, res)
}

// 通用的解析
func universalDomainWs(params *model.DomainParamsWs) []byte {
	res, err := baseParseWs(params)
	if err != nil {
		global.Logger.WithFields(logger.Fields{
			"requestId": params.RequestId,
			"mac":       params.Mac,
			"mid":       params.Mid,
			"vender":    params.MidType,
			"sessionId": params.SessionId,
		}).Error("universalDomainWs baseParse error.")
		return replyWithChat(error_reply, "doudi")
	}

	return MarshalWs(params, res)
}