package speechNlu

import (
	"encoding/json"
	"fmt"
	"github.com/gorilla/websocket"
	"speech-nlu-parse/dao"
	"speech-nlu-parse/global"
	"speech-nlu-parse/model"
	"speech-nlu-parse/pkg/errCode"
	"sync"
	"time"
)

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

var SpeechWg = &sync.WaitGroup{}

func SpeechNlu(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 {
			fmt.Println("---------------------待解析---------------------")

			data := SpeechNlpWsReq(reqStruct)

			speechNluWs := SpeechNlpWs{}
			var nlpWsConn *websocket.Conn

			nlpWsConn, err = speechNluWs.SpeechWs()
			if err != nil {
				global.Logger.Errorf("speechWs.SpeechWs error. %v", err)
				return string(replyWithChat(error_reply, "doudi")), errCode.InternalServiceError
			}
			speechNluWs.NlpWsConn = nlpWsConn
			defer nlpWsConn.Close()

			done := make(chan struct{})
			dataChan := make(chan []model.SpeechWsResp, 1) // 缓冲通道避免阻塞

			go receiveMessage(nlpWsConn, done, dataChan)

			if err := sendRunTaskMsg(nlpWsConn, data); err != nil {
				fmt.Println("发送run-task指令失败：", err)
				return string(replyWithChat(error_reply, "doudi")), errCode.InternalServiceError
			}

			var responses []model.SpeechWsResp
			select {
			case <-done:
				responses = <-dataChan
				fmt.Println("任务成功完成，接收数据如下：")

				for _, resp := range responses {
					semanticRespByteData := ParseSpeechJson(resp, reqStruct.MacWifi, reqStruct.OriginQuery, reqStruct.Mid)
					return string(semanticRespByteData), errCode.Success
					//fmt.Printf("%+v\n", resp)
				}
			case <-time.After(5 * time.Minute):
				fmt.Println("任务超时，尝试获取已接收数据...")
				select {
				case responses = <-dataChan:
					fmt.Println("部分接收数据如下：")
					for _, resp := range responses {
						fmt.Printf("%+v\n", resp)
					}
				default:
					fmt.Println("未接收到任何数据")
					return string(replyWithChat(error_reply, "doudi")), errCode.InternalServiceError
				}
			}

			return string(replyWithChat(error_reply, "doudi")), errCode.InternalServiceError
		}
	}

	return channelStr, errCode.Success
}

func sendRunTaskMsg(conn *websocket.Conn, v interface{}) error {
	msgJSON, err := json.Marshal(v)
	if err != nil {
		return err
	}
	return conn.WriteMessage(websocket.TextMessage, msgJSON)
}

func receiveMessage(conn *websocket.Conn, done chan struct{}, dataChan chan<- []model.SpeechWsResp) {
	var responses []model.SpeechWsResp
	defer func() {
		dataChan <- responses
		close(done)
	}()

	for {
		_, message, err := conn.ReadMessage()
		if err != nil {
			fmt.Println("\n消息接收终止：", err)
			return
		}
		//思必驰nlu回复
		fmt.Println("原始消息")
		fmt.Println(string(message))

		var resp model.SpeechWsResp
		if err := json.Unmarshal(message, &resp); err != nil {
			fmt.Println("消息解析失败：", err)
			continue
		}

		fmt.Printf("\n收到新消息：%+v\n", string(message))
		responses = append(responses, resp)

		//resp.Dm.ShouldEndSession不能判定是否结束
		//if resp.Dm.ShouldEndSession {
		//	fmt.Println("\n收到会话结束标志，终止接收")
		//	return
		//}
		if resp.Dm != nil {
			return
		}

		//r := resp.SpeechWsResponse(p.RequestId)
		//
		//if resp.Topic == "tts.error" {
		//	global.Logger.WithFields(logger.Fields{
		//		"RequestId":         p.RequestId,
		//		"Code":              resp.Error.ErrId,
		//		"Message":           resp.Error.Error,
		//		"Time":              time.Since(st),
		//		"SpeechWsRequestId": resp.RecordId,
		//	}).Error("[SpeechWs] 返回message错误")
		//	r.Status.Code = int32(YXWConvertErrorCode(YXWRespCode(r.Status.Code)))
		//	p.Send(r)
		//	return
		//}
		//p.Send(r)
		//
		//fmt.Println("1111111")
		//fmt.Println(resp)
		//
		//if resp.Topic == "tts.stream.end" {
		//	global.Logger.WithFields(logger.Fields{
		//		"RequestId":         p.RequestId,
		//		"Topic":             resp.Topic,
		//		"Time":              time.Since(st).Seconds(),
		//		"SpeechWsRequestId": resp.RecordId,
		//	}).Info("[SpeechWs] 读取结束")
		//
		//	close(audioChan)
		//	break
		//}
	}
}

func ParseSpeechJson(speechJson model.SpeechWsResp, mac string, query, mid string) []byte {
	//思必驰返回的domain是中文,待改
	domain := speechJson.Skill

	var jsonByte []byte
	//reply_when_tencent_empty = replyMessage[util.GetRandom(len(replyMessage))]

	params := &model.SpeechDomainParams{
		SpeechWsResp: &speechJson,
		Query:        query,
		RequestId:    "",
		Mac:          mac,
		Domain:       domain,
		Mid:          mid,
		MidType:      "",
		SessionId:    "",
		HomeId:       "",
		AppKey:       "",
	}

	// 根据mid屏蔽部分domain, 并返回
	//if util.IsContain(domain, global.GetLimitedSetting(mid).ShieldedDomainList) {
	//	jsonByte = shieldedDomain()
	//	return jsonByte
	//}

	//jsonByte = jokeDomain(speechJson)

	fmt.Println("domain:", domain)

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

	return jsonByte
}