package api

import (
	"encoding/json"
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/redis/go-redis/v9"
	"gorm.io/gorm"
	"io/ioutil"
	"log"
	"net/http"
	"qnc-server/config"
	"qnc-server/db"
	"qnc-server/model/model"
	"qnc-server/model/request"
	"qnc-server/model/response"
	"qnc-server/model/types"
	"qnc-server/service"
	"qnc-server/utils"
	"time"
)

type LawsuitQuery struct {
}

// 注册路由
func InitLawsuitQuery(group *gin.RouterGroup) {
	var l LawsuitQuery
	lawsuitQueryPrivateGroup := group.Group("lawsuitQuery")
	lawsuitQueryPrivateGroup.Use(JWTAuth())
	lawsuitQueryPrivateGroup.POST("query_v2", l.queryListV2)
	lawsuitQueryPrivateGroup.GET("get_record", l.GetRecord)
}

var lawsuitQueryService service.LawsuitQueryService
var orderService service.OrderService

func (l *LawsuitQuery) queryListV2(c *gin.Context) {
	ctx := c.Request.Context()
	var reqBody request.LawsuitQueryV2Req
	if err := c.ShouldBindJSON(&reqBody); err != nil {
		response.FailWithMessage("Failed to read request body", c)
		return
	}
	if *reqBody.Type == types.Individual {
		if config.ConfigData.Verify.Three {
			// 三要素校验
			westName, err := utils.WestDexEncrypt(reqBody.Name, "121a1e41fc1690dd6b90afbcacd80cf4")
			if err != nil {
				log.Printf("西部加密错误：%v", err)
				response.FailWithMessage("系统错误，请稍后再试", c)
				return
			}
			westIDCard, err := utils.WestDexEncrypt(reqBody.CardNo, "121a1e41fc1690dd6b90afbcacd80cf4")
			if err != nil {
				log.Printf("西部加密错误：%v", err)
				response.FailWithMessage("系统错误，请稍后再试", c)
				return
			}
			westPhone, err := utils.WestDexEncrypt(reqBody.Mobile, "121a1e41fc1690dd6b90afbcacd80cf4")
			if err != nil {
				log.Printf("西部加密错误：%v", err)
				response.FailWithMessage("系统错误，请稍后再试", c)
				return
			}
			threeElementsReq := map[string]interface{}{
				"name":  westName,
				"idNo":  westIDCard,
				"phone": westPhone,
			}

			threeElements, err := requestService.WestDexRequest("G15BJ02", threeElementsReq)
			var data response.Wrapper[response.ThreeElementsResponse]
			err = json.Unmarshal([]byte(threeElements), &data)
			if err != nil {
				log.Printf("响应解析失败：%v", err)
				response.FailWithMessage("系统错误，请稍后再试", c)
				return
			}

			switch data.Data.Code {
			case 1000:
			case 1001:
				response.FailWithMessage("姓名、证件号、手机号信息不一致", c)
				return
			case 1003:
				response.FailWithMessage("姓名、证件号、手机号信息不一致", c)
				return
			case 1004:
				response.FailWithMessage("姓名不正确", c)
				return
			case 1005:
				response.FailWithMessage("证件号码不正确", c)
				return
			default:
				log.Printf("三要素检测错误%v", data.Data.Msg)
				response.FailWithMessage("服务器错误请稍后再试", c)
				return
			}
		} else {

			// 二要素核验
			twoElementsParams := map[string]any{
				"name":   reqBody.Name,
				"idcard": reqBody.CardNo,
			}
			twoElementsRespStr, err := requestService.AliYunRequest(http.MethodPost, "https://kzidcardv1.market.alicloudapi.com/api-mall/api/id_card/check", nil, twoElementsParams)
			var twoElementsResp response.TwoElementsResp
			err = json.Unmarshal([]byte(twoElementsRespStr), &twoElementsResp)
			if err != nil {
				log.Printf("【二要素】解析错误：%v", err)
				response.FailWithMessage("系统错误，请稍后再试", c)
				return
			}

			if twoElementsResp.Success == false {
				fmt.Printf("【二要素】身份证无效")
				response.FailWithMessage("请输入有效的身份证号码", c)
				return
			}
			if twoElementsResp.Code != 200 {
				response.FailWithMessage(twoElementsResp.Msg, c)
				return
			}
			if twoElementsResp.Data.Result == 1 {
				fmt.Printf("【二要素】姓名与身份证不一致")
				response.FailWithMessage("姓名与身份证不一致", c)
				return
			}
		}

	} else {
		response.FailWithMessage("暂不支持企业涉诉查询", c)
		return
		// 校验企业社会统一信用代码
		//isCreditCode := utils.ValidateUnifiedSocialCreditCode(reqBody.CardNo)
		//if isCreditCode == false {
		//	response.FailWithMessage("请输入企业社会统一信用代码", c)
		//	return
		//}
	}

	// 校验验证码
	isRight, err := utils.VerifyCode(reqBody.Mobile, reqBody.VerifyCode)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	} else if !isRight {
		response.FailWithMessage("验证码错误", c)
		return
	}

	userid := utils.GetUserID(c)
	// 查找是否有 未消费 已付费 的订单
	order, err := orderService.QueryConsumedOrder(userid, "justiceLawsuit")
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			// 为空就没有消费资格
			response.OkNeedPay(c)
			return
		} else {
			log.Printf("QueryConsumedOrder err:%s", err.Error())
			response.FailWithMessage("服务器错误请稍后再试", c)
			return
		}
	}
	//================================================西部=============================================
	var lawsuitReq map[string]interface{}
	var reqCode string

	authDate := GenerateDateString()
	if *reqBody.Type == types.Individual {
		encodeName, err := utils.WestDexEncrypt(reqBody.Name, "121a1e41fc1690dd6b90afbcacd80cf4")
		if err != nil {
			log.Printf("【司法涉诉】加密错误：%v", err)
			response.FailWithMessage(err.Error(), c)
			return
		}
		encodeID, err := utils.WestDexEncrypt(reqBody.CardNo, "121a1e41fc1690dd6b90afbcacd80cf4")
		if err != nil {
			log.Printf("【司法涉诉】加密错误：%v", err)
			response.FailWithMessage(err.Error(), c)
			return
		}
		lawsuitReq = map[string]interface{}{
			"name":          encodeName,
			"idcard":        encodeID,
			"inquired_auth": authDate,
		}
		reqCode = "G35SC01"
	} else {
		encodeID, err := utils.WestDexEncrypt(reqBody.CardNo, "121a1e41fc1690dd6b90afbcacd80cf4")
		if err != nil {
			log.Printf("【司法涉诉】加密错误：%v", err)
			response.FailWithMessage(err.Error(), c)
			return
		}
		encodeName, err := utils.WestDexEncrypt(reqBody.Name, "121a1e41fc1690dd6b90afbcacd80cf4")
		if err != nil {
			log.Printf("【司法涉诉】加密错误：%v", err)
			response.FailWithMessage(err.Error(), c)
			return
		}

		lawsuitReq = map[string]interface{}{
			"org_name":      encodeName,
			"uscc":          encodeID,
			"inquired_auth": authDate,
		}
		reqCode = "Q23SC01"
	}

	// 发起请求并处理响应
	plainText, err := requestService.WestDexRequest(reqCode, lawsuitReq)
	if err != nil {
		handleErrorAndRefund(order, userid, "接口系统错误，将自动退款", c)
		return
	}

	var resp model.LawsuitPersonResponse
	err = json.Unmarshal([]byte(plainText), &resp)
	if err != nil {
		handleErrorAndRefund(order, userid, "司法诉讼记录解析错误", c)
		return
	}

	if resp.ResultCode != "200" {
		handleErrorAndRefund(order, userid, fmt.Sprintf("司法诉讼响应错误：%s", resp.Message), c)
		return
	}

	var respData model.LawsuitPersonData
	err = json.Unmarshal([]byte(resp.Data), &respData)
	if err != nil {
		handleErrorAndRefund(order, userid, "司法诉讼记录解析错误", c)
		return
	}
	var respDataData interface{}
	err = json.Unmarshal([]byte(respData.Data), &respDataData)
	if err != nil {
		handleErrorAndRefund(order, userid, "司法诉讼记录解析错误", c)
		return
	}

	//if checkIfEmpty(respDataData) || respData.Msg == "没有找到" {
	//	handleErrorAndRefund(order, userid, "司法诉讼查询为空", c)
	//	return
	//}

	//根据类型判断是个人信息还是公司信息

	//var respData json.RawMessage
	//
	//if *reqBody.Type == types.Individual {
	//	if resp.Data.Data.PersonInfo == nil || resp.Data.Data.PersonInfo.Code == "-1000" {
	//		handleErrorAndRefund(order, userid, fmt.Sprintf("司法诉讼查询失败：%s", resp.Data.Data.PersonInfo.Msg), c)
	//		return
	//	}
	//	respData = resp.Data.Data.PersonInfo.Data
	//} else {
	//	if resp.Data.Data.CompanyInfo == nil || resp.Data.Data.CompanyInfo.Code == "-1000" {
	//		handleErrorAndRefund(order, userid, fmt.Sprintf("司法诉讼查询失败：%s", resp.Data.Data.CompanyInfo.Msg), c)
	//		return
	//	}
	//	respData = resp.Data.Data.CompanyInfo.Data
	//}
	//===========================================================================================================================
	//reqData := map[string]interface{}{
	//	"cardNo": reqBody.CardNo,
	//	"name":   reqBody.Name,
	//}
	//plainText, err := carService.CarReqYuShan("JUD009", &reqData)
	//log.Println(string(plainText))
	//if err != nil {
	//	log.Printf("YuShan request at %s error： %s", "JUD009", err.Error())
	//	handleErrorAndRefund(order, userid, "接口系统错误，将自动退款", c)
	//	return
	//}
	//analysis, err := lawsuitQueryService.LawsuitDataAnalysis(string(plainText))
	//if err != nil {
	//	if errors.Is(err, utils.ErrNoRecord) {
	//		handleErrorAndRefund(order, userid, "综合涉诉查询为空，将自动退款", c)
	//	} else {
	//		handleErrorAndRefund(order, userid, "综合涉诉解析错误，将自动退款", c)
	//	}
	//	return
	//}

	var query model.Query
	query.OrderID = order.ID
	query.Code, _ = utils.EncryptCode(reqBody.Mobile, "776d538f1265a814437d2e12ac10b45b85045bc208a1eb129ef301f4157aa82f")
	query.Userid = userid
	query.ProductID = order.ProductID
	db.DB.Create(&query)
	uniqueID := utils.SetCacheData(ctx, []interface{}{respDataData})
	// 更新订单状态并返回成功响应
	orderService.OrderConsumed(order)
	response.OkWithData(gin.H{
		"record_id": uniqueID,
	}, c)
}

// 错误处理和退款函数
func handleErrorAndRefund(order model.PayOrder, userid uint, msg string, c *gin.Context) {
	log.Printf("【司法诉讼】%s", msg)
	notifyService.SendNotification(msg, "司法诉讼", userid, order.ID)
	if order.PaymentMethod == model.PaymentMethod_ALIPAY {
		err := orderService.AliRefund(ctx, order)
		if err != nil {
			notifyService.SendNotification("【支付宝】"+msg+"，自动退款失败", "司法诉讼", userid, order.ID)
		} else {
			notifyService.SendNotification("【支付宝】自动退款成功", order.Product.ProductName, order.Userid, order.ID)
		}
	} else {
		err := orderService.WeChatRefund(order)
		if err != nil {
			notifyService.SendNotification(msg+"，自动退款失败", "司法诉讼", userid, order.ID)
		}
	}
	response.FailRefund(c)
}
func (l *LawsuitQuery) GetRecord(c *gin.Context) {
	var req request.GetLawsuitRecordReq
	if err := c.ShouldBindQuery(&req); err != nil {
		response.FailWithMessage("Failed to read request", c)
		return
	}

	data, err := utils.GetCacheData(ctx, req.ID)
	if err != nil {
		if errors.Is(err, redis.Nil) {
			response.Ok(c)
			return
		} else {
			response.FailWithMessage("系统错误", c)
			return
		}
	}

	if checkIfEmpty(data) {
		// 判断data是否是string类型并且等于"查询成功无结果"
		//if strData, ok := data.(string); ok && strData == "查询成功无结果" {

		// 读取empty.json文件
		emptyData, readErr := ioutil.ReadFile("empty.json")
		if readErr != nil {
			log.Printf("系统错误: 无法读取empty.json：%v", readErr)
			response.FailWithMessage("系统错误", c)
			return
		}

		// 将empty.json的内容反序列化为map或者结构体
		var jsonData []map[string]interface{}
		if jsonErr := json.Unmarshal(emptyData, &jsonData); jsonErr != nil {
			log.Printf("系统错误: 无法解析empty.json：%v", readErr)
			response.FailWithMessage("系统错误", c)
			return
		}

		// 返回反序列化后的JSON数据
		response.OkWithData(jsonData, c)
		return
	}
	response.OkWithData(data, c)
}
func GenerateDateString() string {
	// 获取当前时间
	now := time.Now()
	// 格式化当前日期为YYYYMMDD
	today := now.Format("20060102")
	// 获取明天的日期
	tomorrow := now.AddDate(0, 0, 1).Format("20060102")
	// 拼接成所需格式
	return today + "-" + tomorrow
}

// 判断函数
func checkIfEmpty(data interface{}) bool {
	// 判断是否为 nil
	if data == nil {
		return true
	}

	// 判断是否为空数组
	if arr, ok := data.([]interface{}); ok {
		return len(arr) == 0
	}

	// 判断是否为空对象（空 map）
	if obj, ok := data.(map[string]interface{}); ok {
		return len(obj) == 0
	}

	// 如果不是上述情况，表示不为空
	return false
}