package api

import (
	"encoding/json"
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/redis/go-redis/v9"
	"gorm.io/gorm"
	"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"
)

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 {
		// 校验企业社会统一信用代码
		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
	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,
			"id_card": encodeID,
		}
		reqCode = "G22BJ03"
	} else {
		encodeID, err := utils.WestDexEncrypt(reqBody.CardNo, "121a1e41fc1690dd6b90afbcacd80cf4")
		if err != nil {
			log.Printf("【司法涉诉】加密错误：%v", err)
			response.FailWithMessage(err.Error(), c)
			return
		}
		lawsuitReq = map[string]interface{}{
			"ent_name": encodeID,
		}
		reqCode = "Q03BJ03"
	}

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

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

	if resp.Data.ErrCode != "200" {
		handleErrorAndRefund(order, userid, fmt.Sprintf("司法诉讼响应错误：%s", resp.Data.ErrMsg), 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
	}

	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, respData)
	// 更新订单状态并返回成功响应
	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
	}

	//userid := utils.GetUserID(c)
	//record, err := lawsuitQueryService.QueryLawsuitByOrder(req.ID, userid)
	//if err != nil {
	//	log.Printf("【司法涉诉】获取司法涉诉记录错误：%v", err)
	//	notifyService.SendNotification("系统错误，获取司法涉诉记录错误，请及时处理", "司法涉诉", userid, record.OrderID)
	//	response.FailRefund(c)
	//	return
	//}
	//var resp any
	//err = json.Unmarshal([]byte(record.Resp), &resp)
	//if err != nil {
	//	log.Printf("【司法涉诉】获取司法涉诉解析错误：%v", err)
	//	notifyService.SendNotification("系统错误，获取司法涉诉解析错误，请及时处理", "司法涉诉", userid, record.OrderID)
	//	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
		}
	}
	response.OkWithData(data, c)
}