package api

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

type Verify struct {
}

var verifisService service.VerifyService

// 注册路由
func InitVerif(group *gin.RouterGroup) {
	var c Verify
	{
		verifPrivateGroup := group.Group("verify")
		verifPrivateGroup.Use(JWTAuth())
		verifPrivateGroup.POST("phone", c.VerifyNamePhone)
		verifPrivateGroup.GET("get_query", c.GetQueryRecord)
		verifPrivateGroup.POST("card_no", c.VerifyNameCard)
		verifPrivateGroup.POST("bank_card", c.VerifyBankCard)
		verifPrivateGroup.POST("skill_cert", c.VerifySkillCert)
	}
}

// 姓名手机二要素核验
func (verify *Verify) VerifyNamePhone(c *gin.Context) {
	var reqBody request.VerifyNamePhoneReq
	if err := c.ShouldBindJSON(&reqBody); err != nil {
		response.FailWithMessage("Failed to read request body", c)
		return
	}

	userid := utils.GetUserID(c)
	// 查找是否有 未消费 已付费 的订单
	order, err := orderService.QueryConsumedOrder(userid, "shoujiheyan")
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			// 为空就没有消费资格
			response.OkNeedPay(c)
			return
		} else {
			log.Printf("【手机号核验】查询订单错误:%s", err.Error())
			response.FailWithMessage("服务器错误请稍后再试", c)
			return
		}
	}
	// 二要素核验
	body := map[string]any{
		"mobile": reqBody.Phone,
		"name":   reqBody.Name,
	}
	respStr, err := requestService.AliYunRequest(http.MethodPost, "http://yyseys.qianshutong.com/web/interface/yyseysyz", nil, body)
	if err != nil {
		log.Printf("【手机号核验】阿里响应错误： %s", err.Error())
		notifyService.SendNotification("阿里响应错误请及时处理", "手机号核验", userid, order.ID)
		response.FailRefund(c)
		return
	}
	var verifyPhoneName = model.VerifyPhoneName{}
	verifyPhoneName.Resp = respStr
	verifyPhoneName.Code, _ = utils.EncryptCode(reqBody.Phone, "776d538f1265a814437d2e12ac10b45b85045bc208a1eb129ef301f4157aa82f")
	verifyPhoneName.OrderID = order.ID
	verifyPhoneName.UserID = userid
	err = db.DB.Create(&verifyPhoneName).Error
	if err != nil {
		log.Printf("【手机号核验】记录失败：%v", err)
		notifyService.SendNotification("【手机号核验】数据保存错误，请及时处理", "手机号核验", userid, order.ID)
		response.FailRefund(c)
		return
	}
	orderService.OrderConsumed(order)

	response.OkWithData(gin.H{
		"record_id": verifyPhoneName.OrderID,
	}, c)

}

// 姓名身份证二要素核验
func (verify *Verify) VerifyNameCard(c *gin.Context) {
	var reqBody request.VerifyNameCardReq
	if err := c.ShouldBindJSON(&reqBody); err != nil {
		response.FailWithMessage("Failed to read request body", c)
		return
	}

	userid := utils.GetUserID(c)
	// 查找是否有 未消费 已付费 的订单
	order, err := orderService.QueryConsumedOrder(userid, "shenfenzhengheyan")
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			// 为空就没有消费资格
			response.OkNeedPay(c)
			return
		} else {
			log.Printf("【身份证核验】查询订单错误:%s", err.Error())
			response.FailWithMessage("服务器错误请稍后再试", c)
			return
		}
	}
	// 二要素核验
	body := map[string]any{
		"idcard": reqBody.Card,
		"name":   reqBody.Name,
	}
	respStr, err := requestService.AliYunRequest(http.MethodPost, "https://kzidcardv1.market.alicloudapi.com/api-mall/api/id_card/check", nil, body)
	if err != nil {
		log.Printf("【身份证核验】阿里响应错误： %s", err.Error())
		notifyService.SendNotification("阿里响应错误请及时处理", "身份证核验", userid, order.ID)
		response.FailRefund(c)
		return
	}
	var verifyCardName = model.VerifyCardName{}
	verifyCardName.Resp = respStr
	verifyCardName.OrderID = order.ID
	verifyCardName.UserID = userid

	err = db.DB.Create(&verifyCardName).Error
	if err != nil {
		log.Printf("【身份证核验】记录失败：%v", err)
		notifyService.SendNotification("【身份证核验】数据保存错误，请及时处理", "身份证核验", userid, order.ID)
		response.FailRefund(c)
		return
	}
	orderService.OrderConsumed(order)
	response.OkWithData(gin.H{
		"record_id": verifyCardName.OrderID,
	}, c)
}

// 银行卡黑名单
func (verify *Verify) VerifyBankCard(c *gin.Context) {
	var reqBody request.VerifyBankCardReq
	if err := c.ShouldBindJSON(&reqBody); err != nil {
		response.FailWithMessage("Failed to read request body", c)
		return
	}

	userid := utils.GetUserID(c)

	// 查找是否有 未消费 已付费 的订单
	order, err := orderService.QueryConsumedOrder(userid, "yinhangkaheimingdan")
	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 verifModel model.VerifyBankCard
	reqData := map[string]interface{}{
		"cardNo": reqBody.CardNo,
		"cardld": reqBody.CardID,
		"mobile": reqBody.Phone,
		"name":   reqBody.Name,
	}
	plainText, err := verifisService.VerifReqYuShan("FIN019", &reqData)
	if err != nil {
		log.Printf("【羽山接口请求错误】 %s error： %s", "FIN019", err.Error())
		notifyService.SendNotification("羽山接口请求错误，请及时处理", "银行卡黑名单查询V1", userid, order.ID)
		response.FailRefund(c)
		return
	}
	_, err = verifisService.VerifyDataAnalysis(string(plainText))
	if err != nil {
		if errors.Is(err, utils.ErrNoRecord) {
			notifyService.SendNotification("用户查询数据为空，请及时处理", "银行卡黑名单查询V1", userid, order.ID)
		} else {
			notifyService.SendNotification("接口系统响应错误，请及时处理", "银行卡黑名单查询V1", userid, order.ID)
		}
		response.FailRefund(c)
		return
	}
	verifModel.Resp = string(plainText)
	verifModel.Code, _ = utils.EncryptCode(reqBody.Phone, "776d538f1265a814437d2e12ac10b45b85045bc208a1eb129ef301f4157aa82f")
	verifModel.UserID = userid
	err = db.DB.Create(&verifModel).Error
	if err != nil {
		log.Printf("银行卡黑名单查询V1保存错误：%v", err)
		notifyService.SendNotification("银行卡黑名单查询V1保存错误，请及时处理", "银行卡黑名单查询V1", userid, order.ID)
		response.FailRefund(c)
		return
	}
	orderService.OrderConsumed(order)
	response.OkWithData(gin.H{
		"record_id": verifModel.OrderID,
	}, c)

}

// 技能资格证书查询 HRD004
func (verify *Verify) VerifySkillCert(c *gin.Context) {
	var reqBody request.VerifyNameCardReq
	if err := c.ShouldBindJSON(&reqBody); err != nil {
		response.FailWithMessage("Failed to read request body", c)
		return
	}
	// 二要素核验
	twoElementsParams := map[string]any{
		"name":   reqBody.Name,
		"idcard": reqBody.Card,
	}
	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 {
		response.FailWithMessage("请输入有效的身份证号码", c)
		return
	}

	if twoElementsResp.Data.Result == 1 {
		response.FailWithMessage("姓名与身份证不一致", c)
		return
	}
	userid := utils.GetUserID(c)

	// 查找是否有 未消费 已付费 的订单
	order, err := orderService.QueryConsumedOrder(userid, "jinengzigezhengshu")
	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 verifModel model.VerifySkillCert
	reqData := map[string]interface{}{
		"cardNo": reqBody.Card,
		"name":   reqBody.Name,
	}
	plainText, err := verifisService.VerifReqYuShan("HRD004", &reqData)
	if err != nil {
		log.Printf("【羽山接口请求错误】 %s error： %s", "HRD004", err.Error())
		var isNoRecord = "羽山接口请求错误"
		if order.PaymentMethod == model.PaymentMethod_ALIPAY {
			err := orderService.AliRefund(ctx, order)
			if err != nil {
				notifyService.SendNotification(fmt.Sprintf("【支付宝】%s，自动退款失败", isNoRecord), "技能资格证书查询", userid, order.ID)
			} else {
				notifyService.SendNotification("【支付宝】自动退款成功", order.Product.ProductName, order.Userid, order.ID)
			}
		} else {
			err := orderService.WeChatRefund(order)
			if err != nil {
				notifyService.SendNotification(fmt.Sprintf("%s，自动退款失败", isNoRecord), "技能资格证书查询", userid, order.ID)
			}
		}
		response.FailRefund(c)
		return
	}
	_, err = verifisService.VerifyCertDataAnalysis(string(plainText))
	if err != nil {
		var isNoRecord string
		if errors.Is(err, utils.ErrNoRecord) {
			isNoRecord = "用户查询为空"
		} else {
			isNoRecord = "接口系统错误"
		}
		if order.PaymentMethod == model.PaymentMethod_ALIPAY {
			err := orderService.AliRefund(ctx, order)
			if err != nil {
				notifyService.SendNotification(fmt.Sprintf("【支付宝】%s，自动退款失败", isNoRecord), "技能资格证书查询", userid, order.ID)
			} else {
				notifyService.SendNotification("【支付宝】自动退款成功", order.Product.ProductName, order.Userid, order.ID)
			}
		} else {
			err := orderService.WeChatRefund(order)
			if err != nil {
				notifyService.SendNotification(fmt.Sprintf("%s，自动退款失败", isNoRecord), "技能资格证书查询", userid, order.ID)
			}
		}
		response.FailRefund(c)
		return
	}
	verifModel.Resp = string(plainText)
	verifModel.UserID = userid
	err = db.DB.Create(&verifModel).Error
	if err != nil {
		log.Printf("技能资格证书查询保存错误：%v", err)
		notifyService.SendNotification("技能资格证书查询保存错误，请及时处理", "技能资格证书查询", userid, order.ID)
		response.FailRefund(c)
		return
	}
	orderService.OrderConsumed(order)
	response.OkWithData(gin.H{
		"record_id": verifModel.OrderID,
	}, c)
}

func (verify *Verify) GetQueryRecord(c *gin.Context) {
	var req request.GetQueryRecordReq

	if err := c.ShouldBindQuery(&req); err != nil {
		response.FailWithMessage("Failed to read request", c)
		return
	}

	userid := utils.GetUserID(c)
	var record interface{}
	var err error
	if req.IsCase {
		record, err = verifisService.GetRecordCaseByFeature(req.Feature)
		if err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				log.Printf("无相关示例记录：%v", err)
				response.FailWithMessage("无相关示例记录", c)
				return
			} else {
				log.Printf("查询示例记录错误：%v", err)
				response.FailWithMessage(err.Error(), c)
				return
			}
		}
	} else {
		record, err = verifisService.GetRecordByFeature(req.Feature, req.ID, userid)
		if err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				log.Printf("无相关记录：%v", err)
				response.FailWithMessage("无相关记录", c)
				return
			} else {
				log.Printf("查询记录错误：%v", err)
				response.FailWithMessage(err.Error(), c)
				return
			}
		}
	}

	response.OkWithData(record, c)
}