package api

import (
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
	"io"
	"log"
	"qnc-server/config"
	"qnc-server/db"
	"qnc-server/model/model"
	"qnc-server/model/request"
	"qnc-server/model/response"
	"qnc-server/service"
	"qnc-server/utils"
	"strconv"
	"sync"
)

type Car struct {
}

var carService service.CarService

// 注册路由
func InitCar(group *gin.RouterGroup) {
	var c Car
	{
		carPrivateGroup := group.Group("car")
		carPrivateGroup.Use(JWTAuth())
		carPrivateGroup.POST("insurance", c.Insurance)
		carPrivateGroup.POST("maintenance", c.Maintenance)
		carPrivateGroup.GET("get_query", c.GetQueryRecord)
		carPrivateGroup.POST("person_car_verify", c.PersonCarVerify)
		carPrivateGroup.POST("under_name", c.UnderName)
		carPrivateGroup.POST("insurance_info", c.InsuranceInfo)
		//carPrivateGroup.POST("new_energy_power", c.NewEnergyPower)
		carPrivateGroup.POST("vin_check_info", c.VinCheckInfo)
		carPrivateGroup.POST("vehicle_transfer", c.VehicleTransfer)
		carPrivateGroup.POST("vehicle_valuation", c.VehicleValuation)

		carPrivateGroup.GET("get_maintenance_history", c.QueryHistoryList)

	}

	{
		carPublicGroup := group.Group("car")
		carPublicGroup.POST("callback", c.CarCallback)
	}
}

// 出险综合查询
func (car *Car) Insurance(c *gin.Context) {

	var reqBody request.CarInsuranceReq
	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, "chexian")
	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 carInsurance model.CarInsurance
	reqData := map[string]interface{}{
		"vin": reqBody.Vin,
	}
	plainText, err := carService.CarReqYuShan("CAR074", &reqData)
	if err != nil {
		log.Printf("YuShan request at %s error： %s", "CAR074", err.Error())
		notifyService.SendNotification("羽山接口请求错误，请及时处理", "出险综合查询", userid, order.ID)
		response.FailRefund(c)
		return
	}

	_, err = carService.CarInsuranceDataAnalysis(string(plainText))
	if err != nil {
		if errors.Is(err, utils.ErrNoRecord) {
			notifyService.SendNotification("用户查询数据为空，请及时处理", "出险综合查询", userid, order.ID)
		} else {
			notifyService.SendNotification("接口系统响应错误，请及时处理", "出险综合查询", userid, order.ID)
		}
		response.FailRefund(c)
		return
	}
	carInsurance.Resp = string(plainText)
	carInsurance.Vin = reqBody.Vin
	carInsurance.UserID = userid
	carInsurance.OrderID = order.ID
	err = db.DB.Create(&carInsurance).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": carInsurance.OrderID,
	}, c)

}

// 维保记录
func (car *Car) Maintenance(c *gin.Context) {
	var reqBody request.CarMaintenanceReq
	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, "weibao")
	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
		}
	}
	notifySN, _ := utils.GenerateRandomString()
	var carMaintenance model.CarMaintenance
	reqData := map[string]interface{}{
		"vin":       reqBody.Vin,
		"image":     reqBody.ImageBase64,
		"notifyUrl": fmt.Sprintf("%s?notify_sn=%s", config.ConfigData.Car.Callback, notifySN),
	}
	plainText, err := carService.CarReqYuShan("CAR058", &reqData)
	if err != nil {
		log.Printf("YuShan request at %s error： %s", "CAR058", err.Error())
		notifyService.SendNotification("羽山接口请求错误，请及时处理", "维保记录CAR058", userid, order.ID)
		response.FailRefund(c)
		return
	}
	data, err := carService.CarDataAnalysis(string(plainText))
	if err != nil {
		if errors.Is(err, utils.ErrNoRecord) {
			notifyService.SendNotification("用户查询数据为空，请及时处理", "维保记录CAR058", userid, order.ID)
		} else {
			notifyService.SendNotification("接口系统响应错误，请及时处理", "维保记录CAR058", userid, order.ID)
		}
		response.FailRefund(c)
		return
	}

	// 检查 report 中是否存在 "orderId"
	orderId, exists := data.Retdata["orderId"]
	if !exists {
		log.Printf("orderId不存在")
		response.FailWithMessage("信息输入不匹配，无相关数据", c)
		return
	}
	carMaintenance.Vin = reqBody.Vin
	carMaintenance.UserID = userid
	carMaintenance.YuShanOrderID = orderId.(string)
	carMaintenance.OrderID = order.ID
	carMaintenance.Status = model.StatusPending
	carMaintenance.NotifySN = notifySN
	err = db.DB.Create(&carMaintenance).Error
	if err != nil {
		log.Printf("汽车出险综合订单记录失败：%v", err)
		notifyService.SendNotification("汽车查询订单保存错误，请及时处理", "维保记录", userid, order.ID)
		response.FailRefund(c)
		return
	}
	orderService.OrderConsumed(order)

	response.OkWait(c)
}

func (car *Car) 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 = carService.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 = carService.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)
}

// 人车核验 CAR012
// 行驶证信息核验
func (car *Car) PersonCarVerify(c *gin.Context) {

	var reqBody request.CarNameTypeNumberReq
	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, "rencheheyan")
	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 carModel model.CarPersonCarVerify
	reqData := map[string]interface{}{
		"name":      reqBody.Name,
		"carType":   reqBody.CarType,
		"carNumber": reqBody.CarNumber,
	}
	plainText, err := carService.CarReqYuShan("P_C_B332", &reqData)
	if err != nil {
		log.Printf("YuShan request at %s error： %s", "P_C_B332", err.Error())
		notifyService.SendNotification("羽山接口请求错误，请及时处理", "人车核验P_C_B332", userid, order.ID)
		response.FailRefund(c)
		return
	}

	_, err = carService.CarPersonCarVerifyDataAnalysis(string(plainText))
	if err != nil {
		if errors.Is(err, utils.ErrNoRecord) {
			notifyService.SendNotification("用户查询数据为空，请及时处理", "人车核验P_C_B332", userid, order.ID)
		} else {
			notifyService.SendNotification("接口系统响应错误，请及时处理", "人车核验P_C_B332", userid, order.ID)
		}
		response.FailRefund(c)
		return
	}
	carModel.Resp = string(plainText)
	carModel.Name = reqBody.Name
	carModel.CarNumber = reqBody.CarNumber
	carModel.CarType = reqBody.CarType
	carModel.UserID = userid
	err = db.DB.Create(&carModel).Error
	if err != nil {
		log.Printf("人车核验保存错误：%v", err)
		notifyService.SendNotification("人车核验保存错误，请及时处理", "人车核验P_C_B332", userid, order.ID)
		response.FailRefund(c)
		return
	}
	orderService.OrderConsumed(order)
	response.OkWithData(gin.H{
		"record_id": carModel.OrderID,
	}, c)

}

// CAR061名下车辆
func (car *Car) UnderName(c *gin.Context) {

	var reqBody request.CarCardNoReq
	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, "mingxiacheliang")
	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 carModel model.CarUnderName
	reqData := map[string]interface{}{
		"cardNo": reqBody.CardNo,
	}
	plainText, err := carService.CarReqYuShan("CAR061", &reqData)
	if err != nil {
		log.Printf("YuShan request at %s error： %s", "CAR061", err.Error())
		notifyService.SendNotification("羽山接口请求错误，请及时处理", "CAR061名下车辆", userid, order.ID)
		response.FailRefund(c)
		return
	}

	_, err = carService.CarInsuranceDataAnalysis(string(plainText))
	if err != nil {
		if errors.Is(err, utils.ErrNoRecord) {
			notifyService.SendNotification("用户查询数据为空，请及时处理", "CAR061名下车辆", userid, order.ID)
		} else {
			notifyService.SendNotification("接口系统响应错误，请及时处理", "CAR061名下车辆", userid, order.ID)
		}
		response.FailRefund(c)
		return
	}
	carModel.Resp = string(plainText)
	carModel.UserID = userid
	carModel.OrderID = order.ID
	err = db.DB.Create(&carModel).Error
	if err != nil {
		log.Printf("名下车辆查询保存错误：%v", err)
		notifyService.SendNotification("汽车查询数据保存错误，请及时处理", "CAR061名下车辆", userid, order.ID)
		response.FailRefund(c)
		return
	}
	orderService.OrderConsumed(order)

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

}

// CAR070车辆上险信息
func (car *Car) InsuranceInfo(c *gin.Context) {
	var reqBody request.CarVinReq
	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, "cheliangshangxian")
	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 carModel model.CarInsuranceInfo
	reqData := map[string]interface{}{
		"vin": reqBody.Vin,
	}
	var wg sync.WaitGroup

	var plainTextSx, plainTextWx []byte
	var sxErr, WxErr error

	wg.Add(2)
	go func() {
		defer wg.Done()
		plainTextSx, sxErr = carService.CarReqYuShan("CAR070", &reqData)
	}()
	go func() {
		defer wg.Done()
		plainTextWx, WxErr = carService.CarReqYuShan("CAR095", &reqData)
	}()
	wg.Wait()

	if sxErr != nil {
		log.Printf("YuShan request at %s error： %s", "CAR070", sxErr.Error())
		notifyService.SendNotification("羽山接口请求错误，请及时处理", "CAR070", userid, order.ID)
		response.FailRefund(c)
		return
	}
	if WxErr != nil {
		log.Printf("YuShan request at %s error： %s", "CAR095", WxErr.Error())
		notifyService.SendNotification("羽山接口请求错误，请及时处理", "CAR095", userid, order.ID)
		response.FailRefund(c)
		return
	}

	_, err = carService.CarInsuranceDataAnalysis(string(plainTextSx))
	if err != nil {
		if errors.Is(err, utils.ErrNoRecord) {
			notifyService.SendNotification("用户查询数据为空，请及时处理", "CAR070", userid, order.ID)
		} else {
			notifyService.SendNotification("接口系统响应错误，请及时处理", "CAR070", userid, order.ID)
		}
		response.FailRefund(c)
		return
	}
	_, err = carService.CarInsuranceDataAnalysis(string(plainTextWx))
	if err != nil {
		if errors.Is(err, utils.ErrNoRecord) {
			notifyService.SendNotification("用户查询数据为空，请及时处理", "CAR095", userid, order.ID)
		} else {
			notifyService.SendNotification("接口系统响应错误，请及时处理", "CAR095", userid, order.ID)
		}
		response.FailRefund(c)
		return
	}
	carModel.Resp = string(plainTextSx)
	carModel.FiveResp = string(plainTextWx)
	carModel.UserID = userid
	carModel.Vin = reqBody.Vin
	carModel.OrderID = order.ID

	err = db.DB.Create(&carModel).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": carModel.OrderID,
	}, c)

}

// CAR079 车辆VIN码查车辆信息
func (car *Car) VinCheckInfo(c *gin.Context) {
	var reqBody request.CarVinReq
	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, "vinchache")
	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 carModel model.CarVinCheckInfo
	reqData := map[string]interface{}{
		"vin": reqBody.Vin,
	}
	plainText, err := carService.CarReqYuShan("CAR079", &reqData)
	if err != nil {
		log.Printf("YuShan request at %s error： %s", "CAR079", err.Error())
		notifyService.SendNotification("羽山接口请求错误，请及时处理", "车辆VIN码查车辆信息", userid, order.ID)
		response.FailRefund(c)
		return
	}

	_, err = carService.CarInsuranceDataAnalysis(string(plainText))
	if err != nil {
		if errors.Is(err, utils.ErrNoRecord) {
			notifyService.SendNotification("用户查询数据为空，请及时处理", "车辆VIN码查车辆信息", userid, order.ID)
		} else {
			notifyService.SendNotification("接口系统响应错误，请及时处理", "车辆VIN码查车辆信息", userid, order.ID)
		}
		response.FailRefund(c)
		return
	}
	carModel.Resp = string(plainText)
	carModel.UserID = userid
	carModel.Vin = reqBody.Vin
	carModel.OrderID = order.ID

	err = db.DB.Create(&carModel).Error
	if err != nil {
		log.Printf("VIN查车辆信息保存错误：%v", err)
		notifyService.SendNotification("汽车查询数据保存错误，请及时处理", "VIN查车辆信息", userid, order.ID)
		response.FailRefund(c)
		return
	}
	orderService.OrderConsumed(order)

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

// 车辆维保记录CAR058回调
func (car *Car) CarCallback(c *gin.Context) {
	// 读取请求体
	encryptedData, err := io.ReadAll(c.Request.Body)
	if err != nil {
		log.Printf("CarCallback ReadAll err:%s", err.Error())
		return
	}
	NotifySN := c.Query("notify_sn")
	apiKey := config.ConfigData.Car.ApiKey
	respStr, err := utils.Decrypt(string(encryptedData), []byte(apiKey))
	if err != nil {
		log.Printf("CarCallback DecodeYushan err:%s", err.Error())
	}
	log.Printf("%sCarCallback：%s", NotifySN, respStr)
	_, err = carService.CarDataAnalysis(respStr)
	if err != nil {
		if errors.Is(err, utils.ErrUnmashal) {
			log.Printf("CarCallback Unmashal err:%s", err.Error())
			return
		}
	}
	maintenance, GetMaintenanceErr := carService.GetMaintenanceBySn(NotifySN)
	if GetMaintenanceErr != nil {
		log.Printf("GetMaintenanceBySn err:%s", GetMaintenanceErr.Error())
		return
	}
	maintenance.Resp = respStr
	if err != nil {
		if errors.Is(err, utils.ErrNoRecord) {
			notifyService.SendNotification("用户查询数据为空，请及时处理", "维保记录CAR059", maintenance.UserID, maintenance.OrderID)
		} else {
			notifyService.SendNotification("接口系统响应错误，请及时处理", "维保记录CAR059", maintenance.UserID, maintenance.OrderID)
		}
		maintenance.Status = model.StatusFailed
	} else {
		maintenance.Status = model.StatusSuccess
	}
	err = db.DB.Save(&maintenance).Error
	if err != nil {
		log.Printf("callback maintenance save err:%s", err.Error())
	}
	response.Ok(c)
}

// 查询维保历史
func (car *Car) QueryHistoryList(c *gin.Context) {
	// 从查询参数中获取分页参数
	pageSizeStr := c.DefaultQuery("page_size", "10")
	pageNumStr := c.DefaultQuery("page_num", "1")
	userId := utils.GetUserID(c)
	pageSize, err := strconv.Atoi(pageSizeStr)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}

	pageNum, err := strconv.Atoi(pageNumStr)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}

	list, err := carService.GetMaintenanceList(pageSize, pageNum, userId)
	if err != nil {
		log.Println("GetMaintenanceList:", err)
		response.FailWithMessage("系统错误，请稍后再试", c)
		return
	}
	response.OkWithData(list, c)
}

// CAR066 车辆过户次数
func (car *Car) VehicleTransfer(c *gin.Context) {
	var reqBody request.CarVinReq
	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, "cheliangguohu")
	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 carModel model.CarVehicleTransfer
	reqData := map[string]interface{}{
		"vin": reqBody.Vin,
	}
	plainText, err := carService.CarReqYuShan("CAR066", &reqData)
	if err != nil {
		log.Printf("YuShan request at %s error： %s", "CAR066", err.Error())
		notifyService.SendNotification("羽山接口请求错误，请及时处理", "车辆过户次数", userid, order.ID)
		response.FailRefund(c)
		return
	}

	_, err = carService.CarInsuranceDataAnalysis(string(plainText))
	if err != nil {
		if errors.Is(err, utils.ErrNoRecord) {
			notifyService.SendNotification("用户查询数据为空，请及时处理", "车辆过户次数", userid, order.ID)
		} else {
			notifyService.SendNotification("接口系统响应错误，请及时处理", "车辆过户次数", userid, order.ID)
		}
		response.FailRefund(c)
		return
	}
	carModel.Resp = string(plainText)
	carModel.UserID = userid
	carModel.Vin = reqBody.Vin
	carModel.OrderID = order.ID

	err = db.DB.Create(&carModel).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": carModel.OrderID,
	}, c)
}

// CAR100 车辆估值
func (car *Car) VehicleValuation(c *gin.Context) {
	var reqBody request.VehicleValuationReq
	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, "cheliangguzhi")
	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 carModel model.CarVehicleValuation
	reqData := map[string]interface{}{
		"vin":       reqBody.Vin,
		"carNumber": reqBody.CarNumber,
		"cardNo":    "",
	}
	plainText, err := carService.CarReqYuShan("CAR100", &reqData)
	if err != nil {
		log.Printf("YuShan request at %s error： %s", "CAR066", err.Error())
		notifyService.SendNotification("羽山接口请求错误，请及时处理", "车辆估值", userid, order.ID)
		response.FailRefund(c)
		return
	}

	_, err = carService.CarInsuranceDataAnalysis(string(plainText))
	if err != nil {
		if errors.Is(err, utils.ErrNoRecord) {
			notifyService.SendNotification("用户查询数据为空，请及时处理", "车辆估值", userid, order.ID)
		} else {
			notifyService.SendNotification("接口系统响应错误，请及时处理", "车辆估值", userid, order.ID)
		}
		response.FailRefund(c)
		return
	}
	carModel.Resp = string(plainText)
	carModel.UserID = userid
	carModel.Vin = reqBody.Vin
	carModel.CarNumber = reqBody.CarNumber
	carModel.OrderID = order.ID

	err = db.DB.Create(&carModel).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": carModel.OrderID,
	}, c)
}