package service

import (
	"WorldEpcho/src/config"
	"WorldEpcho/src/models"
	"encoding/json"
	"fmt"
	//"github.com/gin-gonic/gin"
	"io/ioutil"
	"net/http"
	"net/url"
	"strconv"
	"strings"
)

//创建世界API接口时候返回的响应体
type WorldEchoResponse struct {
	Code              int                    `from:"code" json:"code"`
	WObj              map[string]interface{} `json:"WObj"`
	ISLIU             string                 `from:"ISLIU" json:"ISLIU"`
	MuseValue         int                    `json:"muse"`
	WorldName         string                 `json:"worldName" `
	IsLIUId           *string                `json:"IsLIUId,omitempty"`           // 使用指针类型，并添加 omitempty 标签,可选字段
	MessageStatusType string                 `json:"messageStatusType,omitempty"` // Optional field to indicate message type
}

//世界推演结局
type OutcomeContent struct {
	WObj  map[string]interface{} `json:"WObj"`
	ISLIU string                 `from:"ISLIU" json:"ISLIU"`
}

// WorldClient
func (client *WorldClient) WorldEchoAPI(msg *WorldSendMsg) (*WorldEchoResponse, error) {
	/*
	   创建一个请求参数对象
	*/
	EchoReustParam := models.WorldEchoChatParm{
		Auth:    config.Conf.SoulAuth, //配置文件读取服务商认证码
		Type:    msg.Type,
		IsliuId: client.WorldConversations.IsLiuId,
		Content: msg.Content,
	}

	fmt.Println("EchoRequestParam: ", EchoReustParam)
	request_url := config.Conf.SoulUrl + "/world/echo"
	fmt.Println("Echo request_url", request_url)

	// 准备POST请求的body数据

	postData := url.Values{}
	postData.Add("auth", EchoReustParam.Auth)
	postData.Add("type", strconv.Itoa(EchoReustParam.Type))
	postData.Add("ISLIUid", EchoReustParam.IsliuId)
	postData.Add("content", EchoReustParam.Content)

	// 发送POST请求
	resp, err := http.Post(request_url, "application/x-www-form-urlencoded", strings.NewReader(postData.Encode()))
	if err != nil {
		fmt.Println("会话响应失败，请稍后重试:", err)
		return nil, err
	}

	defer resp.Body.Close()

	fmt.Println("Response status:", resp.Status)

	// 读取响应的body数据
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("读取会话响应数据失败，请稍后重试:", err)
		return nil, err
	}
	// 解析JSON
	var response WorldEchoResponse

	err = json.Unmarshal(body, &response)
	// 将JSON打印为字符串
	fmt.Println("收到的响应:", string(body))
	if err != nil {
		fmt.Println("世界调用会话接口失败，无法获取意识流:", err)
		return nil, fmt.Errorf("调用会话接口失败无法获取意识流")
	}

	// 检查 WObj 中是否包含 EndStr，表示推演到了结局
	/*
		if endStr, ok := response.WObj["EndStr"]; ok {
			if endStr != "" {

				fmt.Println("推演到结局，保存结局内容...")
				// 创建 OutcomeContent 对象
				outcome := OutcomeContent{
					WObj:  response.WObj,
					ISLIU: response.ISLIU,
				}

				// 将 OutcomeContent 对象转换成 JSON 字符串
				outcomeContentBytes, err := json.Marshal(outcome)
				if err != nil {
					fmt.Println("无法将推演结局内容序列化:", err)
					return nil, fmt.Errorf("无法将推演结局内容序列化: %v", err)
				}

				outcomeContentStr := string(outcomeContentBytes)

				// 创建 WorldDeductionResult 对象
				deductionResult := models.WorldDeductionResult{
					WorldId:        client.WorldConversations.WorldId,
					UserId:         client.WorldConversations.Uid,
					WorldName:      client.WorldName,
					OutcomeTitle:   "推演结局", // 使用 EndStr 作为结局标题
					OutcomeContent: outcomeContentStr,
					CreatedAt:      time.Now().Unix(),
					UpdatedAt:      time.Now().Unix(),
				}

				// 保存到数据库
				_, err = models.AddWorldDeductionResult(&deductionResult)
				if err != nil {
					fmt.Println("保存推演结局内容到数据库失败:", err)
					return nil, fmt.Errorf("保存推演结局内容到数据库失败: %v", err)
				}

				fmt.Println("推演结局内容已成功保存到数据库。")

			}
		}*/

	// 使用解析后的参数
	fmt.Println("Code: ", response.Code)
	fmt.Println("response.WObj: ", response.WObj)
	fmt.Println("response.ISLIU: ", response.ISLIU)
	fmt.Println("response.MuseValue", response.MuseValue)
	//1成功 0服务失效 2凭证无效 3信息格式有误 4非法的服务商
	fmt.Println(config.ColorBlue, "New world API Code: ", response.Code, " code为【 1成功 0服务失效 2凭证无效 3信息格式有误 4非法的服务商 】", config.ColorReset)
	return &response, nil

}

func AddWorldEchoEndStrRecord(worldId, userId int64, response *WorldEchoResponse) {
	// 检查是否存在结束标记 "EndStr"
	if endStr, ok := response.WObj["EndStr"]; ok {

		//var content = OutcomeContent{}
		//content.WObj = response.WObj["WObj"]
		// 创建推演结果记录
		result := &models.WorldDeductionResult{
			WorldId:        worldId,            // 假设的世界ID
			UserId:         userId,             // 假设的用户ID
			WorldName:      response.WorldName, // 从响应中获取世界名称
			OutcomeTitle:   "推演结局",             // 结局标题
			OutcomeContent: endStr.(string),    // 结局内容，类型断言为字符串
			//CreatedAt:      time.Now().Unix(),  // 当前时间戳
			//UpdatedAt:      time.Now().Unix(),  // 当前时间戳
		}

		// 调用 AddWorldDeductionResult 来保存结果
		affected, err := models.AddWorldDeductionResult(result)
		if err != nil {
			fmt.Printf("保存推演结果失败: %v\n", err)
		} else {
			fmt.Printf("成功保存推演结果, 影响行数: %d\n", affected)
		}
	}
}
