package api

import (
	"encoding/json"
	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/context"
	"go.uber.org/zap"
	"io"
	"pet-house.com/business/models"
	"pet-house.com/core/server/database"
	"pet-house.com/core/server/web/web_iris"
	"pet-house.com/core/server/zap_server"
	"time"
)

type PetGoodsInfo struct {
	PetId    int64
	GoodsIds []int64
}

type OrderCreateRequest struct {
	PetGoodsInfos []PetGoodsInfo //宠物商品信息列表
	ServiceTime   string         //预约时间 yyyy-MM-dd HH:mm
	ServiceAddrId int64          //预约服务地址
}

type OrderCreateResponse struct {
	OrderDetail OrderDetail `json:"orderDetail"`
}

// 创建
func (p DefParty) orderCreate() web_iris.Party {
	return web_iris.Party{Perfix: p.Prefix, PartyFunc: func(index iris.Party) {
		index.Post(OrderBase+"/orderCreate", func(ctx *context.Context) {
			headerBaseInfo := GetHeaderBaseInfo(ctx)
			body, _ := io.ReadAll(ctx.Request().Body)
			var orderCreateRequest OrderCreateRequest
			json.Unmarshal(body, &orderCreateRequest)
			var userServiceAddr models.UserServiceAddr
			database.Instance().Model(&models.UserServiceAddr{}).Where("uid = ? and id = ?", headerBaseInfo.Uid, orderCreateRequest.ServiceAddrId).Find(&userServiceAddr)
			if userServiceAddr.Id == 0 {
				UserServiceAddrNotExistError.Fail(ctx, nil)
				return
			}
			serviceAddr := ServiceAddrMap[userServiceAddr.AreaId]
			if serviceAddr.Id == 0 {
				ServiceAddrNotExistError.Fail(ctx, nil)
				return
			}
			orderId := NextId.Generate().String()
			orderMain := models.OrderMain{
				OrderId:       orderId,
				Uid:           headerBaseInfo.Uid,
				Status:        1,
				ServiceTime:   orderCreateRequest.ServiceTime,
				ServiceAddrId: orderCreateRequest.ServiceAddrId,
				ServiceRemark: "",
			}
			var orderSubList []models.OrderSub
			var orderSubDetailList []models.OrderDetail
			for _, value := range orderCreateRequest.PetGoodsInfos {
				subOrderId := NextId.Generate().String()
				var totalAmount int32 = 0
				for _, value := range value.GoodsIds {
					goods := GoodsMap[value]
					totalAmount = totalAmount + goods.Price
					orderSubDetailList = append(orderSubDetailList, models.OrderDetail{SubOrderId: subOrderId, GoodsId: value, Amount: goods.Price})
				}
				orderSub := models.OrderSub{
					OrderId:     subOrderId,
					MainOrderId: orderMain.OrderId,
					Status:      1,
					PetId:       value.PetId,
					PayType:     1,
					Discount:    100,
					TotalAmount: totalAmount,
					PayAmount:   0,
				}
				orderSubList = append(orderSubList, orderSub)
			}
			tx := database.Instance().Begin()
			db := tx.Model(&models.OrderDetail{}).CreateInBatches(&orderSubDetailList, len(orderSubDetailList))
			db1 := tx.Model(&models.OrderSub{}).CreateInBatches(&orderSubList, len(orderSubList))
			db2 := tx.Model(&models.OrderMain{}).Create(&orderMain)
			if db.Error != nil || db1.Error != nil || db2.Error != nil {
				tx.Callback()
				zap_server.ZAPLOG.Error("订单插入失败", zap.Any("db", db.Error), zap.Any("db1", db1.Error), zap.Any("db2", db2.Error))
				OrderCreateError.Fail(ctx, orderCreateRequest)
				return
			}
			tx.Commit()

			var findUserServiceAddr models.UserServiceAddr
			database.Instance().Model(&models.UserServiceAddr{}).Where("id = ? and uid = ?", orderMain.ServiceAddrId, headerBaseInfo.Uid).Find(&findUserServiceAddr)
			orderDetail := OrderDetail{
				OrderId:       orderMain.OrderId,
				Status:        orderMain.Status,
				ServiceTime:   orderMain.ServiceTime,
				ServiceAddr:   findUserServiceAddr,
				ServiceRemark: orderMain.ServiceRemark,
				CreateTime:    orderMain.CreateTime.String(),
			}
			var subOrderList []SubOrder
			for _, orderSub := range orderSubList {
				var orderDetailList []models.OrderDetail
				database.Instance().Model(&models.OrderDetail{}).Where("sub_order_id = ? ", orderSub.OrderId).Find(&orderDetailList)
				var goods []models.Goods
				for _, orderDetail := range orderDetailList {
					good := GoodsMap[orderDetail.GoodsId]
					goods = append(goods, good)
				}
				orderSub := SubOrder{
					OrderId:     orderSub.OrderId,
					Status:      orderSub.Status,
					UserPetInfo: GetUserPet(headerBaseInfo.Uid, orderSub.PetId),
					TotalAmount: orderSub.TotalAmount,
					PayAmount:   orderSub.PayAmount,
					Goods:       goods,
				}
				subOrderList = append(subOrderList, orderSub)
			}
			orderDetail.CreateTime = time.DateTime
			orderDetail.SubOrderList = subOrderList
			Success(ctx, orderCreateRequest, OrderCreateResponse{orderDetail})
		})
	}}
}

type OrderListRequest struct {
	Status   int //订单状态 0所有 1待服务 2服务中 3已完成 4已取消
	PageNo   int //页码
	PageSize int //数据数量
}

type SubOrder struct {
	OrderId     string         `json:"orderId"`     //子订单ID
	Status      int            `json:"status"`      //子订单状态 1待服务 2服务中 3已完成 4已取消
	UserPetInfo UserPetInfo    `json:"userPetInfo"` //用户宠物信息
	TotalAmount int32          `json:"totalAmount"` //总金额 单位：分
	PayAmount   int32          `json:"payAmount"`   //实际支付金额 单位：分
	Goods       []models.Goods `json:"goods"`       //商品信息
}

type OrderDetail struct {
	OrderId       string                 `json:"orderId"`       //主订单号
	Status        int                    `json:"status"`        //主订单状态 1待服务 2服务中 3已完成
	ServiceTime   string                 `json:"serviceTime"`   //服务时间
	ServiceAddr   models.UserServiceAddr `json:"serviceAddr"`   //服务地址信息
	ServiceRemark string                 `json:"serviceRemark"` //服务备注
	CreateTime    string                 `json:"createTime"`    //创建时间
	SubOrderList  []SubOrder             `json:"subOrderList"`  //子订单列表
}

type OrderListResponse struct {
	OrderDetail []OrderDetail `json:"orderDetail"` //订单列表
	PageNo      int           `json:"pageNo"`      //页码
	PageSize    int           `json:"pageSize"`    //数据数量
}

// 订单列表
func (p DefParty) orderList() web_iris.Party {
	return web_iris.Party{Perfix: p.Prefix, PartyFunc: func(index iris.Party) {
		index.Post(OrderBase+"/orderList", func(ctx *context.Context) {
			headerBaseInfo := GetHeaderBaseInfo(ctx)
			body, _ := io.ReadAll(ctx.Request().Body)
			var orderListRequest OrderListRequest
			json.Unmarshal(body, &orderListRequest)
			if orderListRequest.PageNo == 0 {
				ParamError.DefFail(ctx, orderListRequest, "页码必须>0")
				return
			}
			var orderList []models.OrderMain
			if orderListRequest.Status == 0 {
				database.Instance().Model(&models.OrderMain{}).Where("uid = ?", headerBaseInfo.Uid).Offset((orderListRequest.PageNo - 1) * orderListRequest.PageSize).Limit(orderListRequest.PageSize).Find(&orderList)
			} else {
				database.Instance().Model(&models.OrderMain{}).Where("uid = ? and status = ?", headerBaseInfo.Uid, orderListRequest.Status).Offset((orderListRequest.PageNo - 1) * orderListRequest.PageSize).Limit(orderListRequest.PageSize).Find(&orderList)
			}
			var orderDetails []OrderDetail
			for _, value := range orderList {
				var findUserServiceAddr models.UserServiceAddr
				database.Instance().Model(&models.UserServiceAddr{}).Where("id = ? and uid = ?", value.ServiceAddrId, headerBaseInfo.Uid).Find(&findUserServiceAddr)
				orderListResponse := OrderDetail{
					OrderId:       value.OrderId,
					Status:        value.Status,
					ServiceTime:   value.ServiceTime,
					ServiceAddr:   findUserServiceAddr,
					ServiceRemark: value.ServiceRemark,
					CreateTime:    value.CreateTime.String(),
				}
				var subOrderList []SubOrder
				var orderSubList []models.OrderSub
				database.Instance().Model(&models.OrderSub{}).Where("main_order_id = ? ", value.OrderId).Find(&orderSubList)
				for _, orderSub := range orderSubList {
					var orderDetailList []models.OrderDetail
					database.Instance().Model(&models.OrderDetail{}).Where("sub_order_id = ? ", orderSub.OrderId).Find(&orderDetailList)
					var goods []models.Goods
					for _, orderDetail := range orderDetailList {
						good := GoodsMap[orderDetail.GoodsId]
						goods = append(goods, good)
					}
					orderSub := SubOrder{
						OrderId:     orderSub.OrderId,
						Status:      orderSub.Status,
						UserPetInfo: GetUserPet(headerBaseInfo.Uid, orderSub.PetId),
						TotalAmount: orderSub.TotalAmount,
						PayAmount:   orderSub.PayAmount,
						Goods:       goods,
					}
					subOrderList = append(subOrderList, orderSub)
				}
				orderListResponse.SubOrderList = subOrderList
				orderDetails = append(orderDetails, orderListResponse)
			}
			var orderListResponse = OrderListResponse{
				OrderDetail: orderDetails,
				PageNo:      orderListRequest.PageNo,
				PageSize:    orderListRequest.PageSize,
			}
			Success(ctx, orderListRequest, orderListResponse)
		})
	}}
}

// 获取订单可预约时间
func (p DefParty) orderServiceTime() web_iris.Party {
	return web_iris.Party{Perfix: p.Prefix, PartyFunc: func(index iris.Party) {
		index.Post(OrderBase+"/orderServiceTime", func(ctx *context.Context) {

		})
	}}
}

// 支付
func (p DefParty) orderPay() web_iris.Party {
	return web_iris.Party{Perfix: p.Prefix, PartyFunc: func(index iris.Party) {
		index.Post(OrderBase+"/orderPay", func(ctx *context.Context) {

		})
	}}
}