package model

import (
	"errors"
	"fmt"
	"github.com/codinl/go-logger"
	"math/rand"
	"qiniupkg.com/x/log.v7"
	"time"
)

const (
	OrderCardStatusUnPick    = 1 // 待取货中
	OrderCardStatusPlaying   = 2 // 游玩中
	OrderCardStatusReturning = 3 // 归还中
	OrderCardStatusCompleted = 4 // 已完成

	DeliveryTypeStorePick = 1 // 门店取货
	DeliveryTypeExpress   = 2 // 快递取货

	ExpressFeeProvince        = 10 * 100 // 省内
	ExpressFeeOutsideProvince = 15 * 100 // 省外

	PayStatusUnPay = 1 // 未支付
	PayStatusPaid  = 2 // 已支付
)

//go:generate goqueryset -in order.go
// gen:qs
type Order struct {
	Model

	Uid                    uint64    `json:"uid" gorm:"index"`
	GameCardId             uint64    `json:"game_card_id" gorm:"index"`                                 // 游戏id
	GameCardGoodsId        uint64    `json:"game_card_goods_id" gorm:"index"`                           // 游戏卡id
	StoreId                uint64    `json:"store_id"`                                                  // 门店id
	UserAddressId          uint64    `json:"user_address_id"`                                           // 地址id
	DeliveryType           uint8     `json:"delivery_type"`                                             // 取货类型 1-门店自取 2-快递
	Count                  uint32    `json:"count"`                                                     // 数量
	PickupCode             string    `json:"pickup_code"`                                               // 取货码
	CardStatus             uint8     `json:"card_status"`                                               // 1-待取货中 2-游玩中 3-归还中 4-已完成
	DeliveryTime           time.Time `json:"delivery_time"`                                             // 发货时间
	ReceiptTime            time.Time `json:"receipt_time"`                                              // 收货时间
	PayTime                time.Time `json:"pay_time"`                                                  // 支付时间
	PayStatus              uint8     `json:"pay_status"`                                                // 支付状态 1-未支付  2-已支付
	OrderSn                string    `json:"order_sn" gorm:"type:varchar(255);not null;COMMENT:'订单编号'"` // 订单编号
	PayPrice               uint32    `json:"pay_price"`                                                 // 实际付款金额(包含运费)
	Postage                uint32    `json:"postage"`                                                   // 邮费
	ExpressCompany         string    `json:"express_company"`                                           // 物流公司
	ExpressCompanyNo       string    `json:"express_company_no"`                                        // 物流公司编号
	ExpressNo              string    `json:"express_no"`                                                // 物流单号
	ExpressDuration        uint64    `json:"express_duration"`                                          // 物流时长
	RevertStoreId          uint64    `json:"revert_store_id"`                                           // 归还门店id
	RevertTime             time.Time `json:"revert_time"`                                               // 归还时间
	RevertExpressCompany   string    `json:"revert_express_company"`                                    // 归还物流公司
	RevertExpressCompanyNo string    `json:"revert_express_company_no"`                                 // 归还物流公司编号
	RevertExpressNo        string    `json:"revert_express_no"`                                         // 归还物流单号
	RevertExpressDuration  uint64    `json:"revert_express_duration"`                                   // 归还物流时长
}

func (*Order) TableName() string {
	return "order"
}

func (m *Order) ToInfo(card *GameCard) OrderInfo {
	return OrderInfo{
		Order:        *m,
		GameName:     card.Name,
		GamePrice:    card.Price,
		GameCoverImg: card.CoverImg,
	}
}

type OrderInfo struct {
	Order
	GameName     string `json:"name" gorm:"index"`  // 名称
	GamePrice    uint32 `json:"price" gorm:"index"` // 价格
	GameCoverImg string `json:"cover_img"`          // 封面
}

func GetOrderList(uid uint64, page, pageSize int) ([]OrderInfo, uint32, error) {
	var (
		orders     []Order
		totalPage  uint32
		orderInfos = make([]OrderInfo, 0, pageSize)
	)
	page -= 1
	if page < 0 {
		page = 0
	}

	oq := NewOrderQuerySet(DB).UidEq(uid).OrderDescByCreatedAt().PayStatusEq(PayStatusPaid)
	count, err := oq.Count()
	if err != nil {
		log.Error("NewGameCardQuerySet err:", err)
		return orderInfos, 0, err
	}
	err = oq.Offset(page * pageSize).Limit(pageSize).All(&orders)
	if err != nil && err != RecordNotFound {
		log.Error("err:", err)
		return orderInfos, 0, err
	}
	totalPage = uint32(count/pageSize + 1)

	var games []GameCard
	gameIds := make([]uint32, 0, len(orders))
	for i, _ := range orders {
		gameIds = append(gameIds, uint32(orders[i].GameCardId))
	}
	if len(gameIds) == 0 {
		log.Error("gameIds is null")
		return orderInfos, 0, err
	}
	err = NewGameCardQuerySet(DB).IDIn(gameIds...).All(&games)
	if err != nil && err != RecordNotFound {
		log.Error("err:", err)
		return orderInfos, 0, err
	}

	gamesMap := make(map[uint32]*GameCard)
	for i, _ := range games {
		gamesMap[games[i].ID] = &games[i]
	}
	for i, _ := range orders {
		card, ok := gamesMap[uint32(orders[i].GameCardId)]
		if !ok {
			continue
		}
		orderInfos = append(orderInfos, orders[i].ToInfo(card))
	}

	return orderInfos, totalPage, nil
}

func (m *Order) Info() (*OrderInfo, error) {
	var (
		order Order
		card  GameCard
	)
	err := NewOrderQuerySet(DB).IDEq(m.ID).One(&order)
	if err != nil {
		log.Error("err:", err)
		return nil, err
	}

	err = NewGameCardQuerySet(DB).IDEq(uint32(order.GameCardId)).One(&card)
	if err != nil && err != RecordNotFound {
		log.Error("err:", err)
		return nil, err
	}

	info := order.ToInfo(&card)
	return &info, nil
}

func (m *Order) Revert() (*OrderInfo, error) {
	var (
		order Order
		card  GameCard
	)
	err := NewOrderQuerySet(DB).IDEq(m.ID).GetUpdater().
		SetCardStatus(OrderCardStatusReturning).
		SetRevertTime(time.Now()).
		SetRevertStoreId(m.RevertStoreId).
		SetRevertExpressCompany(m.RevertExpressCompany).
		SetRevertExpressCompanyNo(m.RevertExpressCompanyNo).
		SetRevertExpressNo(m.RevertExpressNo).Update()
	if err != nil {
		log.Error("err:", err)
		return nil, err
	}

	//err = NewGameCardQuerySet(DB).IDEq(uint32(order.GameCardId)).One(&card)
	//if err != nil && err != RecordNotFound {
	//	log.Error("err:", err)
	//	return nil, err
	//}
	info := order.ToInfo(&card)
	return &info, nil
}

func (m *Order) OrderCreate() error {
	m.PayStatus = PayStatusUnPay
	err := m.Create(DB)
	if err != nil {
		log.Error("err:", err)
		return err
	}
	return nil
}

func (m *Order) Modify() (*OrderInfo, error) {
	if m.ID == 0 {
		return nil, errors.New("orderId is null")
	}
	fields := make([]OrderDBSchemaField, 0)
	if m.CardStatus != 0 {
		fields = append(fields, OrderDBSchema.CardStatus)
	}

	if len(fields) > 0 {
		err := m.Update(DB.Where(&Order{Model: Model{ID: m.ID}, Uid: m.Uid}), fields...)
		if err != nil {
			logger.Error("err:", err)
			return nil, err
		}
	}

	var card GameCard
	err := NewGameCardQuerySet(DB).IDEq(uint32(m.GameCardId)).One(&card)
	if err != nil && err != RecordNotFound {
		log.Error("err:", err)
		return nil, err
	}

	info := m.ToInfo(&card)

	return &info, nil
}

func IsHaveUnreturnedOrders(uid uint32) (bool, error) {
	count, err := NewOrderQuerySet(DB).UidEq(uint64(uid)).CardStatusNe(OrderCardStatusCompleted).Count()
	if err != nil {
		logger.Error("err:", err)
		return false, err
	}
	return count != 0, nil
}

// gen:qs
type ExpressCompany struct {
	Model

	CompanyName string `json:"company_name"`
	CompanyCode string `json:"company_code"`
}

func (*ExpressCompany) TableName() string {
	return "express_company"
}

func (*ExpressCompany) List() ([]ExpressCompany, error) {
	companys := make([]ExpressCompany, 0)
	err := NewExpressCompanyQuerySet(DB).OrderAscByID().All(&companys)
	if err != nil && err != RecordNotFound {
		logger.Error("err:", err)
		return companys, err
	}
	return companys, nil
}

func GetPickupCode() string {
	for {
		rand.Seed(time.Now().UnixNano())
		code := fmt.Sprintf("%d", rand.Intn(1000000)+100000)
		count, err := NewOrderQuerySet(DB).PickupCodeEq(code).Count()
		if err != nil {
			logger.Error("err:", err)
		}
		if count == 0 {
			return code
		}
	}
	//将时间戳设置成种子数

}