package model

import (
	"errors"
	"fmt"
	"github.com/codinl/go-logger"
	"github.com/jinzhu/gorm"
	"strings"
	"time"
)

//go:generate goqueryset -in game_card.go
// gen:qs
type GameCard struct {
	Model

	Name                  string `json:"name" gorm:"index"`                                // 名称
	Price                 uint32 `json:"price" gorm:"index"`                               // 价格
	CoverImg              string `json:"cover_img"`                                        // 封面
	OrderCount            uint32 `json:"order_count" gorm:"index"`                         // 订单数
	NewProducts           uint8  `json:"new_products"`                                     // 新品: 1-新品 2-非新品
	Status                uint8  `json:"status"`                                           // 状态: 1-上架 2-下架
	StockCount            uint32 `json:"stock_count"`                                      // 库存
	StockState            uint32 `json:"stock_state" gorm:"-"`                             // 1-库存 2-门店库存 3-无库存
	TotalCount            uint32 `json:"total_count"`                                      // 总量
	GameTypeId            uint32 `json:"game_type_id"`                                     // 游戏类型
	GoodsGalleryUrl       string `json:"goods_gallery_url" gorm:"type:text;comment:'轮播图'"` // 轮播图
	ViewCount             uint32 `json:"view_count"`                                       // 查看人数
	Playability           uint32 `json:"playability"`                                      // 耐玩度
	Playfulness           uint32 `json:"playfulness"`                                      // 好玩度
	GameTime              uint32 `json:"game_time"`                                        // 游戏时间
	Likes                 uint32 `json:"likes"`                                            // 点赞
	DetailInfo            string `json:"detail_info" gorm:"type:text;comment:'详情描述'"`      // 详情描述
	DetailImg             string `json:"detail_img"`                                       // 详情图片
	EstimateVm            uint32 `json:"estimate_vm" gorm:"-"`                             // 预计积分
	RealPrice             uint32 `json:"real_price"`                                       // 真实价格
	CooperativeBusinessId uint32 `json:"cooperative_business_id" gorm:"index"`             // 合作商id
	CooperativeName       string `json:"cooperative_name"`                                 // 合作商名称
	VideoLink             string `json:"video_link"`                                       // 链接
}

func (*GameCard) TableName() string {
	return "game_card"
}

// gen:qs
type GameCardLabel struct {
	Model

	GameCardId uint32 `json:"game_card_id" gorm:"index"`
	GameLabel  string `json:"game_label" gorm:"index"`
}

func (*GameCardLabel) TableName() string {
	return "game_card_label"
}

// gen:qs
type HomeCarousel struct {
	Model

	Name         string `json:"name" gorm:"index"` // 名称
	Img          string `json:"img"`               // 图片
	Sort         uint32 `json:"sort" gorm:"index"`
	IsShow       uint32 `json:"is_show"` // 1-显示 2-隐藏
	Detail       string `json:"detail" gorm:"type:text;comment:'详情描述'"`
	Link         string `json:"link"`
	ActivityType uint32 `json:"activity_type"` // 活动类型:1-会员续费
}

func (*HomeCarousel) TableName() string {
	return "home_carousel"
}

type CardInfo struct {
	GameCardId uint32 `json:"game_card_id"`
	Count      uint32 `json:"count"`
}

func (m *User) IsMember() bool {
	if m.MemberLevel == 2 || m.MemberLevel == 4 || m.MemberLevel == 5 {
		return true
	}
	return false
}

//var GameCardListUpdateTime = time.Time{}

func GetGameCardList(sortType, page, pageSize int, gameTypeIds []uint64, storeId, uid uint32) ([]GameCard, uint32, error) {
	var (
		cards     []GameCard = make([]GameCard, 0)
		totalPage uint32
		count     int
		err       error
	)
	page = page - 1
	if page < 0 {
		page = 0
		//return cards, 0, errors.New("page is err")
	}
	if pageSize == 0 {
		pageSize = 10
	}
	//count, err := NewGameCardQuerySet(DB).Count()
	//if err != nil {
	//	logger.Error("NewGameCardQuerySet err:", err)
	//	return cards, 0, err
	//}

	qs := NewGameCardQuerySet(DB).IDNe(914)
	switch sortType {
	case 1:
		// 排序类型  1-默认
		//qs = qs.OrderDescByCreatedAt()
		//qs = qs.OrderAscByStockState()
		qs = qs.OrderAscByID()
	case 2:
		// 排序类型  2-新品
		qs = qs.NewProductsEq(1).OrderDescByID()
		//count, err = NewGameCardQuerySet(DB).NewProductsEq(1).Count()
	case 3:
		// 排序类型  3-销量
		qs = qs.OrderDescByOrderCount()
	case 4:
		// 排序类型  4-价格 大到小
		qs = qs.OrderDescByPrice()
	case 5:
		// 排序类型  5-价格 小到大
		qs = qs.OrderAscByPrice()
	}
	qs = qs.StatusEq(1)
	if len(gameTypeIds) > 0 {
		gameIdByType, err := GetGameIdByType(gameTypeIds)
		if err != nil {
			logger.Error("GetGameIdByType err:", err)
			return cards, 0, err
		}
		if len(gameIdByType) != 0 {
			//qs = qs.GameTypeIdIn(gameIdByType...)
			qs = qs.IDIn(gameIdByType...)
		} else {
			return cards, 0, err
		}
	}

	hideGamePrice := uint32(30000)
	var user *User
	if uid != 0 {
		user = GetUserByUid(uid)
		if user == nil {
			logger.Error("get user err:", err)
			return cards, 0, err
		}
		if user.MemberExpire.After(time.Now()) &&
			user.MemberExpire.AddDate(0, 0, -14).Before(time.Now()) {
			qs = qs.RealPriceLte(hideGamePrice)
		}
	}
	gameIds := make([]uint32, 0)
	gameIdMap := make(map[uint32]uint32)

	if sortType == 1 {
		if storeId != 0 {
			//gameIds := make([]uint32, 0)
			////gameIdMap := make(map[uint32]int)
			//var cardStocks []GameCardGoodsStock
			//err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(storeId)).RentStockGt(0).OrderDescByRentStock().All(&cardStocks)
			//if err != nil {
			//	logger.Error("GetGameIdByType err:", err)
			//	return cards, 0, err
			//}
			//for i, _ := range cardStocks {
			//	gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
			//}
			//if len(gameIds) <= 0 {
			//	return cards, 0, nil
			//}
			//qs = qs.IDIn(gameIds...)

			var cardStocks []GameCardGoodsStock
			//err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(storeId)).RentStockGt(0).
			//	OrderDescByRentStock().All(&cardStocks)
			//DB.Table("game_card_goods_stock").Joins("")
			cardStockSql1 := fmt.Sprintf("SELECT a.* FROM game_card_goods_stock a LEFT JOIN game_card b ON a.game_card_id=b.id WHERE a.store_id=%d AND a.rent_stock>0 ORDER BY b.id ASC;", storeId)
			err = DB.Raw(cardStockSql1).Scan(&cardStocks).Error
			if err != nil {
				logger.Error("GetGameIdByType err:", err)
				return cards, 0, err
			}
			for i, _ := range cardStocks {
				_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
				if !ok {
					gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
					gameIdMap[uint32(cardStocks[i].GameCardId)] = 1
				}
			}

			cardStocks = []GameCardGoodsStock{}
			//err = NewGameCardGoodsStockQuerySet(DB).StoreIdNe(uint64(storeId)).RentStockGt(0).
			//	OrderDescByRentStock().All(&cardStocks)
			cardStockSql2 := fmt.Sprintf("SELECT a.* FROM game_card_goods_stock a LEFT JOIN game_card b ON a.game_card_id=b.id WHERE a.store_id!=%d AND a.rent_stock>0 ORDER BY b.id ASC;", storeId)
			err = DB.Raw(cardStockSql2).Scan(&cardStocks).Error
			if err != nil {
				logger.Error("GetGameIdByType err:", err)
				return cards, 0, err
			}
			for i, _ := range cardStocks {
				_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
				if !ok {
					gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
					gameIdMap[uint32(cardStocks[i].GameCardId)] = 2
				}
			}

			cardStocks = []GameCardGoodsStock{}
			//err = NewGameCardGoodsStockQuerySet(DB).RentStockEq(0).All(&cardStocks)
			cardStockSql3 := fmt.Sprintf("SELECT a.* FROM game_card_goods_stock a LEFT JOIN game_card b ON a.game_card_id=b.id WHERE  a.rent_stock=0 ORDER BY b.id ASC;")
			err = DB.Raw(cardStockSql3).Scan(&cardStocks).Error
			if err != nil {
				logger.Error("GetGameIdByType err:", err)
				return cards, 0, err
			}
			for i, _ := range cardStocks {
				_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
				if !ok {
					gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
					gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
				}
			}

			if len(gameIds) > 0 {
				qs = qs.IDIn(gameIds...)
			}
		} else {
			var cardStocks []GameCardGoodsStock
			//err := NewGameCardGoodsStockQuerySet(DB).RentStockGt(0).
			//	OrderDescByRentStock().All(&cardStocks)
			cardStockSql1 := fmt.Sprintf("SELECT a.* FROM game_card_goods_stock a LEFT JOIN game_card b ON a.game_card_id=b.id WHERE  a.rent_stock>0 ORDER BY b.id ASC;")
			err = DB.Raw(cardStockSql1).Scan(&cardStocks).Error
			if err != nil {
				logger.Error("GetGameIdByType err:", err)
				return cards, 0, err
			}
			for i, _ := range cardStocks {
				_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
				if !ok {
					gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
					gameIdMap[uint32(cardStocks[i].GameCardId)] = 1
				}
			}

			cardStocks = []GameCardGoodsStock{}
			//err = NewGameCardGoodsStockQuerySet(DB).RentStockEq(0).All(&cardStocks)
			cardStockSql2 := fmt.Sprintf("SELECT a.* FROM game_card_goods_stock a LEFT JOIN game_card b ON a.game_card_id=b.id WHERE  a.rent_stock=0 ORDER BY b.id ASC;")
			err = DB.Raw(cardStockSql2).Scan(&cardStocks).Error
			if err != nil {
				logger.Error("GetGameIdByType err:", err)
				return cards, 0, err
			}
			for i, _ := range cardStocks {
				_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
				if !ok {
					gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
					gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
				}
			}
			if len(gameIds) > 0 {
				qs = qs.IDIn(gameIds...)
			}
		}
	}

	count, err = qs.Count()
	if err != nil {
		logger.Error("count err:", err)
	}
	totalPage = uint32(count/pageSize + 1)
	if count%pageSize == 0 {
		totalPage = uint32(count / pageSize)
	}
	//err = qs.OrderDescByCreatedAt().Offset(page * pageSize).Limit(pageSize).All(&cards)
	if sortType != 1 {
		err = qs.Offset(page * pageSize).Limit(pageSize).All(&cards)
		if err != nil && err != RecordNotFound {
			logger.Error("err:", err)
			return cards, 0, err
		}

		GameCardListSetStockState(cards, storeId)
	} else {
		err = qs.OrderDescByID().All(&cards)
		//err = qs.OrderAscByID().All(&cards)
		if err != nil && err != RecordNotFound {
			logger.Error("list err:", err)
			return cards, 0, err
		}
		//fmt.Println("page:", page, totalPage)
		list := make([]GameCard, 0, len(cards))
		cardMap := make(map[uint32]GameCard, 0)
		for i, _ := range cards {
			cardMap[cards[i].ID] = cards[i]
		}
		for i, _ := range gameIds {
			v, ok1 := cardMap[gameIds[i]]
			v2, _ := gameIdMap[gameIds[i]]
			v.StockState = v2
			if ok1 {
				list = append(list, v)
			}
		}
		count = len(list)
		totalPage = uint32(count/pageSize + 1)
		if count%pageSize == 0 {
			totalPage = uint32(count / pageSize)
		}

		if uint32(page) < totalPage-1 && totalPage != 1 {
			cards = list[page*pageSize : (page+1)*pageSize]
		} else {
			cards = list[page*pageSize:]
		}
	}

	//cardIds := make([]uint64, 0)
	//for i, _ := range cards {
	//	cardIds = append(cardIds, uint64(cards[i].ID))
	//}

	//var cardStocks []GameCardGoodsStock
	//err = NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(cardIds...).All(&cardStocks)
	//if err != nil {
	//	logger.Error("err:", err)
	//	return cards, totalPage, nil
	//}
	//cardStockMap := make(map[uint64]uint32, 0)
	//for i, _ := range cardStocks {
	//	cardStockMap[cardStocks[i].GameCardId] += cardStocks[i].RentStock
	//}

	for i, _ := range cards {
		//stock, ok := cardStockMap[uint64(cards[i].ID)]
		//if ok {
		//	cards[i].StockCount = stock
		//}
		if user != nil && user.IsMember() {
			cards[i].RealPrice = 0
		}
	}
	return cards, totalPage, nil
}

func IsGameCardOnline(gameCardId uint32) (bool, error) {
	count, err := NewGameCardQuerySet(DB).IDEq(gameCardId).StatusEq(1).Count()
	if err != nil {
		logger.Error("err:", err)
		return false, err
	}
	return count == 1, nil
}

func IsGameCardListOnline(gameCards []CardInfo) (bool, error) {
	for _, v := range gameCards {
		count, err := NewGameCardQuerySet(DB).IDEq(v.GameCardId).StatusEq(1).Count()
		if err != nil {
			logger.Error("err:", err)
			return false, err
		}
		if count < 1 {
			return false, nil
		}
	}

	return true, nil
}

func IsGameCardHaveStoke(storeId, gameCardId uint32) (bool, error) {
	var stock GameCardGoodsStock
	err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(storeId)).GameCardIdEq(uint64(gameCardId)).One(&stock)
	//count, err := NewGameCardQuerySet(DB).IDEq(gameCardId).StatusEq(1).Count()
	if err != nil {
		logger.Error("err:", err)
		return false, err
	}
	// 发货的时候减库存
	return stock.RentStock > 0, nil
}

const (
	GameCardGoodsStatusStock         = 1 // 库存中
	GameCardGoodsStatusInWay         = 2 // 在途
	GameCardGoodsStatusCustomerHold  = 3 // 客户持有
	GameCardGoodsStatusCannibalize   = 4 // 调拨
	GameCardGoodsStatusReceivingCard = 5 //
	GameCardGoodsStatusReceivedCard  = 6 // 调拨
	GameCardGoodsStatusUnusual       = 7 // 异常锁定
)

const (
	GameCardGoodsTypeShare  = "user_share" // 用户共享
	GameCardGoodsTypeCommon = "common"     // 公共
)

// gen:qs
type GameCardGoods struct {
	Model

	GameCardId            uint64    `json:"game_card_id"`                         // 游戏卡id
	SerialNumber          string    `json:"serial_number" gorm:"index"`           // 编号
	Status                uint32    `json:"status"`                               // 状态:1-库存中 2-在途 3-客户持有 4-调拨 5-待收回 6-已收回 7-锁定
	StoreId               uint64    `json:"store_id"`                             // 门店id
	Provider              string    `json:"provider"`                             // 供应商
	StockTime             time.Time `json:"stock_time"`                           // 入库时间
	CardType              string    `json:"card_type" gorm:"index"`               // -用户共享  -公共
	FunctionState         uint32    `json:"function_state"`                       // 1-异常 2-正常
	ShareProfitType       uint32    `json:"share_profit_type"`                    // 1-非共享收益卡 2-共享收益卡
	CooperativeBusinessId uint32    `json:"cooperative_business_id" gorm:"index"` // 合作商id
	CooperativeName       string    `json:"cooperative_name"`                     // 合作商名称

	Store             *Store             `json:"store"  gorm:"-"`    // 门店
	GameCard          *GameCard          `json:"game_card" gorm:"-"` // 游戏
	UserShareCardBill *UserShareCardBill `json:"user_share_card_bill" gorm:"-"`
}

func (*GameCardGoods) TableName() string {
	return "game_card_goods"
}

// gen:qs
type GameCardGoodsStock struct {
	Model

	StoreId               uint64 `json:"store_id"`     // 门店id
	GameCardId            uint64 `json:"game_card_id"` // 游戏卡id
	StoreStock            uint32 `json:"store_stock"`  // 门店库存
	RentStock             uint32 `json:"rent_stock"`   // 租借库存
	UserHoldStock         uint32 `json:"user_hold_stock"`
	OrderCount            uint32 `json:"order_count"`
	TotalStock            uint32 `json:"total_stock"`
	CooperativeBusinessId uint32 `json:"cooperative_business_id" gorm:"index"` // 合作商id
	CooperativeName       string `json:"cooperative_name"`                     // 合作商名称

	Name     string `json:"name" gorm:"-"`     // 名称
	CoverImg string `json:"coverImg" gorm:"-"` // 封面

}

func (*GameCardGoodsStock) TableName() string {
	return "game_card_goods_stock"
}

func GetGameCardInfo(id uint64, storeId uint32) (GameCard, error) {
	game := GameCard{}
	err := NewGameCardQuerySet(DB).IDEq(uint32(id)).One(&game)
	if err != nil && err != RecordNotFound {
		logger.Error("err:", err)
		return game, err
	}

	var cardStock GameCardGoodsStock
	if storeId != 0 {
		err = NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(uint64(game.ID)).StoreIdEq(uint64(storeId)).One(&cardStock)
		if err != nil && err != RecordNotFound {
			logger.Error("err:", err)
			return game, nil
		}
		if cardStock.RentStock > 0 {
			game.StockState = 1
			return game, nil
		}

		cardStock = GameCardGoodsStock{}
		err = NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(uint64(game.ID)).
			StoreIdNe(uint64(storeId)).RentStockGt(0).One(&cardStock)
		if err != nil && err != RecordNotFound {
			logger.Error("err:", err)
			return game, nil
		}
		if cardStock.RentStock > 0 {
			game.StockState = 2
			return game, nil
		}
	} else {
		cardStock = GameCardGoodsStock{}
		err = NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(uint64(game.ID)).RentStockGt(0).One(&cardStock)
		if err != nil && err != RecordNotFound {
			logger.Error("err:", err)
			return game, nil
		}
		if cardStock.RentStock > 0 {
			game.StockState = 1
			return game, nil
		}
	}

	game.StockState = 3
	//cardStock := uint32(0)
	//for i, _ := range cardStocks {
	//	cardStock += cardStocks[i].RentStock
	//}
	//game.StockCount = cardStock

	return game, nil
}

func GetGameCardSearch(name string, page, pageSize int, storeId uint32) ([]GameCard, uint32, error) {
	var (
		cards     []GameCard = make([]GameCard, 0)
		totalPage uint32
		cardCount = struct {
			Count uint32 `json:"count"`
		}{}
	)
	page -= 1
	if page < 0 {
		page = 0
	}
	if pageSize <= 0 {
		pageSize = 10
	}
	//sqlStore := ""
	//if storeId != 0 {
	//	var gameStocks []GameCardGoodsStock
	//	err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(storeId)).All(&gameStocks)
	//	if err != nil {
	//		logger.Error("game card goods stock err:", err)
	//	}
	//	if len(gameStocks) == 0 {
	//		logger.Error("err:", err)
	//		return cards, 0, err
	//	}
	//	gameCardIds := make([]string, 0, len(gameStocks))
	//	for i, _ := range gameStocks {
	//		gameCardIds = append(gameCardIds, fmt.Sprintf("%d", gameStocks[i].GameCardId))
	//	}
	//	sqlStore = fmt.Sprintf(" AND id IN (%s) ", strings.Join(gameCardIds, ","))
	//}

	countSql := "SELECT COUNT(id) AS count  FROM game_card WHERE status=1 AND game_card.name LIKE '%" + name + "%'"
	err := DB.Raw(countSql).Scan(&cardCount).Error
	if err != nil {
		logger.Error("err:", err)
		return cards, 0, err
	}

	sql := "SELECT game_card.* FROM game_card WHERE status=1 AND game_card.name LIKE '%" + name + "%'"
	//sql := "SELECT game_card.* FROM game_card WHERE status=1 AND game_card.name LIKE '%" + name + "%'" + sqlStore +
	//	fmt.Sprintf(" LIMIT %d,%d;", page*pageSize, pageSize)
	err = DB.Raw(sql).Scan(&cards).Error
	if err != nil {
		logger.Error("err:", err)
		return cards, 0, err
	}
	cardMap := make(map[uint32]GameCard, 0)
	cardIds := make([]uint64, 0, len(cards))
	for i, _ := range cards {
		if cards[i].ID == 914 {
			continue
		}
		cardIds = append(cardIds, uint64(cards[i].ID))
		cardMap[cards[i].ID] = cards[i]
	}
	var cardStocks []GameCardGoodsStock
	if len(cardIds) != 0 {
		err = NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(cardIds...).RentStockGt(0).All(&cardStocks)
		if err != nil {
			logger.Error("game card goods stock err:", err)
			return cards, totalPage, nil
		}
	}

	list := make([]GameCard, 0, len(cards))
	stockMap := make(map[uint64]uint32, 0)
	for i, _ := range cardStocks {
		_, ok := stockMap[cardStocks[i].GameCardId]
		if !ok {
			stockMap[cardStocks[i].GameCardId] = 1
			v2, ok2 := cardMap[uint32(cardStocks[i].GameCardId)]
			v2.StockState = 1
			if ok2 {
				list = append(list, v2)
			}
		}
	}

	for i, _ := range cardIds {
		_, ok := stockMap[cardIds[i]]
		if !ok {
			stockMap[cardIds[i]] = 3
			v2, ok2 := cardMap[uint32(cardIds[i])]
			v2.StockState = 3
			if ok2 {
				list = append(list, v2)
			}
		}
	}
	totalPage = cardCount.Count/uint32(pageSize) + 1
	if cardCount.Count%uint32(pageSize) == 0 {
		totalPage = cardCount.Count / uint32(pageSize)
	}

	if uint32(page) < totalPage-1 && totalPage != 1 {
		cards = list[page*pageSize : (page+1)*pageSize]
	} else {
		cards = list[page*pageSize:]
	}

	return cards, totalPage, nil
}

// TODO  订单

func GetHomeCarouselList() ([]HomeCarousel, error) {
	carousels := make([]HomeCarousel, 0)
	err := NewHomeCarouselQuerySet(DB).IsShowEq(1).OrderDescBySort().All(&carousels)
	if err != nil && err != RecordNotFound {
		logger.Error("err:", err)
		return carousels, err
	}

	return carousels, nil
}

// gen:qs
type GameCardType struct {
	Model

	Name string `json:"name"`              // 游戏类型
	Sort uint32 `json:"sort" gorm:"index"` // 排序
	//GameCount uint32 `json:"game_count"`        // 游戏数量
}

func (*GameCardType) TableName() string {
	return "game_card_type"
}

func GetGameCardTypeList() ([]GameCardType, error) {
	gameTypes := make([]GameCardType, 0)
	err := NewGameCardTypeQuerySet(DB).OrderAscBySort().All(&gameTypes)
	if err != nil {
		logger.Errorf("err:%+v", err)
		return gameTypes, err
	}
	return gameTypes, nil
}

// gen:qs
type GameType struct {
	Model

	GameCardId     uint64 `json:"gameCardId" gorm:"column:game_card_id;index"`          // 游戏卡id
	GameCardTypeId uint64 `json:"gameCardTypeId" gorm:"column:game_card_type_id;index"` // 分类id
}

func (*GameType) TableName() string {
	return "game_type"
}

func GetGameIdByType(gameTypeIds []uint64) ([]uint32, error) {
	gameTypes := make([]GameType, 0)
	err := NewGameTypeQuerySet(DB).GameCardTypeIdIn(gameTypeIds...).All(&gameTypes)
	if err != nil && err != RecordNotFound {
		logger.Error("err:", err)
		return nil, err
	}

	gameIds := make([]uint32, 0)
	if len(gameTypes) == 0 {
		return gameIds, nil
	}

	for i, _ := range gameTypes {
		gameIds = append(gameIds, uint32(gameTypes[i].GameCardId))
	}
	return gameIds, nil
}

//func (m *GameType) GetGameByType(gameIds []int) ([]GameCard, error) {
//	games := make([]GameCard, 0)
//	gameTypes := make([]GameType,0)
//	err := DB.Table(m.TableName()).Where("id in (?)", ids).Find(&gameTypes).Error
//	if err != nil {
//		logger.Error("err:", err)
//		return games, err
//	}
//	gameCardId := make([]uint32,0)
//	for i, _ := range gameTypes {
//		gameCardId= append(gameCardId, uint32(gameTypes[i].GameCardId))
//	}
//	NewGameCardQuerySet(DB).IDIn(gameCardId...).All()
//	return games, nil
//}

func (m *GameCard) GetGameType() ([]GameCardType, error) {
	gameCardTypes := make([]GameCardType, 0)
	gameTypes := make([]GameType, 0)
	err := NewGameTypeQuerySet(DB).GameCardIdEq(uint64(m.ID)).All(&gameTypes)
	if err != nil {
		logger.Error("err:", err)
		return gameCardTypes, err
	}
	gameCardTypeId := make([]uint32, 0)
	for i, _ := range gameTypes {
		gameCardTypeId = append(gameCardTypeId, uint32(gameTypes[i].GameCardTypeId))
	}
	if len(gameCardTypeId) == 0 {
		return gameCardTypes, nil
	}
	err = NewGameCardTypeQuerySet(DB).IDIn(gameCardTypeId...).All(&gameCardTypes)
	if err != nil {
		logger.Error("err:", err)
		return gameCardTypes, err
	}
	return gameCardTypes, nil
}

type RspAliyunStsToken struct {
	AccessKeyId     string `json:"access_key_id"`
	AccessKeySecret string `json:"access_key_secret"`
	SecurityToken   string `json:"security_token"`
	BucketName      string `json:"bucket_name"`
	Expiration      uint64 `json:"expiration"`
}

func GetOrderCardMapSerialNumberUnset(list map[uint32]OrderCard, gameCardId uint32) *OrderCard {
	for _, v := range list {
		if v.GameCardId == gameCardId && v.SerialNumber == "" {
			return &v
		}
	}
	return nil
}

func (m *GameCardGoodsStock) AddUserHoldStock(gdb *gorm.DB) error {
	if m.StoreId == 0 || m.GameCardId == 0 {
		return errors.New("store id or game card id is null")
	}
	if gdb == nil {
		gdb = DB
	}
	sql := fmt.Sprintf("UPDATE game_card_goods_stock SET user_hold_stock= user_hold_stock+1 WHERE store_id=%d AND game_card_id=%d;", m.StoreId, m.GameCardId)
	fmt.Println("sql:", sql)
	err := gdb.Exec(sql).Error
	if err != nil {
		logger.Error("err:", err)
		return err
	}
	return nil
}

func GetGameCardGoodsBySerialNumber(serialNumber string) (GameCardGoods, error) {
	var gameGoods GameCardGoods
	err := NewGameCardGoodsQuerySet(DB).SerialNumberEq(serialNumber).One(&gameGoods)
	if err != nil {
		logger.Error("gameGoods err:", err)
		return gameGoods, err
	}
	return gameGoods, nil
}

func (m *GameCardGoodsStock) Add(begin *gorm.DB) error {
	if begin == nil {
		begin = DB
	}
	//err := orm.Eloquent.Table("game_card_goods_stock").Where("store_id", m.StoreId).
	//	Where("game_card_id", m.GameCardId).Count(&count).Error

	recordExist, err := QueryRecordExist(fmt.Sprintf(
		"SELECT * FROM game_card_goods_stock WHERE store_id=%d AND game_card_id=%d",
		m.StoreId, m.GameCardId))
	if err != nil {
		logger.Error("game card goods stock record exist err:", err)
		return err
	}
	if !recordExist {
		m.StoreStock = 1
		m.RentStock = 1
		m.TotalStock = 1
		err := begin.Create(m).Error
		if err != nil {
			logger.Error("create ame card goods stock record err:", err)
			return err
		}
		return nil
	}

	sql := fmt.Sprintf(
		"UPDATE game_card_goods_stock SET rent_stock= rent_stock+1,store_stock=store_stock+1,total_stock=total_stock+1 WHERE store_id=%d AND game_card_id=%d;", m.StoreId, m.GameCardId)
	fmt.Println("sql:", sql)
	err = begin.Exec(sql).Error
	if err != nil {
		logger.Errorf("err:%#v", err)
		return err
	}
	return nil
}

func (*GameCardGoods) Adds(cards []GameCardGoods) error {
	serialNumbers := make([]string, 0, len(cards))
	for i, _ := range cards {
		serialNumbers = append(serialNumbers, cards[i].SerialNumber)
	}
	var goodsList []GameCardGoods
	err := NewGameCardGoodsQuerySet(DB).SerialNumberIn(serialNumbers...).All(&goodsList)
	if err != nil && err != RecordNotFound {
		logger.Error("err:", err)
		return err
	}
	goodsMap := make(map[string]int, 0)
	for i, _ := range goodsList {
		goodsMap[goodsList[i].SerialNumber] = i
	}

	for i, _ := range cards {
		_, ok := goodsMap[cards[i].SerialNumber]
		if !ok {
			begin := DB.Begin()
			// 入库 公共添加数据
			cards[i].StockTime = time.Now()
			cards[i].FunctionState = 2

			err = begin.Create(&cards[i]).Error
			if err != nil {
				begin.Rollback()
				logger.Error("err:", err)
				continue
			}

			stock := GameCardGoodsStock{StoreId: cards[i].StoreId, GameCardId: cards[i].GameCardId}
			err = stock.Add(begin)
			if err != nil {
				begin.Rollback()
				logger.Error("err:", err)
				continue
			}
			if cards[i].CardType == GameCardGoodsTypeShare {
				userShareCard := &UserShareCard{
					Uid:                 cards[i].UserShareCardBill.Uid,
					SerialNumber:        cards[i].SerialNumber,
					BillSn:              cards[i].UserShareCardBill.BillSn,
					GameCardId:          uint32(cards[i].GameCardId),
					State:               ShareCardStateSharing,
					GameCardGoodsId:     cards[i].ID,
					UserShareCardBillId: cards[i].UserShareCardBill.ID,
					ShareCardBillGameId: 0,
					StoreId:             uint32(cards[i].StoreId),
					ProfitState:         1,
				}
				if cards[i].CardType == GameCardGoodsTypeShare {
					userShareCard.AllotSerialNumber = userShareCard.SerialNumber
					userShareCard.AllotCardGoodsId = userShareCard.GameCardGoodsId
				}
				err = begin.Create(userShareCard).Error
				if err != nil {
					begin.Rollback()
					logger.Error("err:", err)
					return err
				}

			}
			err := begin.Commit().Error
			if err != nil {
				begin.Rollback()
				logger.Error("err:", err)
				continue
			}
		}

	}
	return nil
}

type CooperativeRentCardOrderListReq struct {
	AssistantUid uint32    `json:"assistant_uid"`
	Uid          uint64    `json:"uid" `
	OrderId      uint64    `json:"order_id"`
	GameCardId   uint64    `json:"game_card_id"`
	StoreId      uint64    `json:"store_id" `      // 门店id 游戏id
	CardStatus   uint8     `json:"card_status"`    // 1-待取货中 2-游玩中 3-归还中 4-已完成
	PayStatus    uint8     `json:"pay_status"`     //
	DeliveryType uint8     `json:"delivery_type"`  //
	SerialNumber string    `json:"serial_number" ` // 编号
	PickupCode   string    `json:"pickup_code"`    // 取货码
	StartTime    time.Time `json:"start_time"`     // 开始时间
	EndTime      time.Time `json:"end_time"`       // 结束时间
	PageNum      int       `json:"page_num"`
	PageSize     int       `json:"page_size"`
}

func (m *CooperativeRentCardOrderListReq) List() ([]Order, int, error) {
	var orderCards []OrderCard
	orders := make([]Order, 0)
	if m.PageSize == 0 {
		m.PageSize = 10
	}
	assistant := GetUserByUid(m.AssistantUid)
	if m.SerialNumber == "" {
		m.StoreId = assistant.StoreId
	}
	if assistant.UserType != 2 {
		return orders, 0, errors.New("not assistant")
	}
	qs := NewOrderQuerySet(DB).PayStatusEq(2)
	isDeliver := true
	if m.SerialNumber != "" {
		isDeliver = false
		err := NewOrderCardQuerySet(DB).SerialNumberEq(m.SerialNumber).OrderDescByID().OrderAscByCardStatus().All(&orderCards)
		if err != nil {
			logger.Error("err:", err)
			return orders, 0, err
		}
		orderIds := make([]uint32, 0)
		for i, _ := range orderCards {
			orderIds = append(orderIds, orderCards[i].OrderId)
		}
		qs = qs.IDIn(orderIds...)
		//qs = qs.Where("id in (?)", orderIds)
	}
	if m.PickupCode != "" {
		isDeliver = false
		//qs = qs.Where("pickup_code", m.PickupCode)
		qs = qs.PickupCodeEq(m.PickupCode)
	}
	if m.PayStatus != 0 {
		//qs = qs.Where("pay_status", m.PayStatus)
		qs = qs.PayStatusEq(m.PayStatus)
	}
	if m.DeliveryType != 0 {
		//qs = qs.Where("delivery_type", m.DeliveryType)
		qs = qs.DeliveryTypeEq(m.DeliveryType)
	}
	if m.OrderId != 0 {
		isDeliver = false
		//qs = qs.Where("id", m.OrderId)
		qs = qs.IDEq(uint32(m.OrderId))
	}
	if isDeliver {
	}
	if m.Uid != 0 {
		qs = qs.UidEq(m.Uid)
	}
	if m.GameCardId != 0 {
		qs = qs.GameCardIdEq(m.GameCardId)
	}
	if m.CardStatus != 0 {
		qs = qs.CardStatusEq(m.CardStatus)
	}
	if !m.StartTime.IsZero() {
		qs = qs.CreatedAtGte(m.StartTime)
	}
	if !m.EndTime.IsZero() {
		qs = qs.CreatedAtLte(m.EndTime)
	}
	if m.StoreId != 0 {
		qs = qs.StoreIdEq(m.StoreId)
	}
	count, err := qs.Count()
	if err != nil {
		logger.Errorf("err:%#v", err)
		return orders, 0, err
	}

	pageSize := m.PageSize
	page := m.PageNum - 1
	if page < 0 {
		page = 0
	}
	if m.PageSize == 0 {
		m.PageSize = 10
	}
	err = qs.OrderDescByID().Offset(page * pageSize).Limit(m.PageSize).All(&orders)
	if err != nil {
		logger.Errorf("err:%#v", err)
		return orders, 0, err
	}

	ids := make([]uint32, 0, len(orders))
	for i, _ := range orders {
		ids = append(ids, uint32(orders[i].ID))
	}
	if len(ids) == 0 {
		logger.Error("gameIds is nil")
		return orders, 0, err
	}

	err = NewOrderCardQuerySet(DB).OrderIdIn(ids...).All(&orderCards)
	if err != nil {
		logger.Error("err:", err)
		return orders, 0, err
	}
	orderCards = OrderCardListSetGameInfo(orderCards)
	orderCardsMap := make(map[uint32][]OrderCard, 0)
	for i, _ := range orderCards {
		orderCardsMap[orderCards[i].OrderId] = append(orderCardsMap[orderCards[i].OrderId], orderCards[i])
	}
	for i, _ := range orders {
		if orders[i].CardStatus == 2 || orders[i].CardStatus == 3 {
			orders[i].CardStatus = 4
		}
		v, ok := orderCardsMap[orders[i].ID]
		if ok {
			orders[i].OrderCards = v
		}
	}

	return orders, count, nil
}

type GameCardGoodsStockAnalysisReq struct {
	Name                  string `json:"name"`
	SortType              uint32 `json:"sort_type"`               // 1-总库存 2-库存 3-用户持有 4-订单数量
	SortDirection         uint32 `json:"sort_direction"`          // 1-升序 2-降序
	CooperativeBusinessId uint32 `json:"cooperative_business_id"` // 合作商id
	StoreId               uint32 `json:"store_id"`
	PageNum               int    `json:"page_num"`
	PageSize              int    `json:"page_size"`
}
type GameCardGoodsStockAnalysisResp struct {
	List      []GameCardGoodsStock `json:"list"`
	Count     uint32               `json:"count"`
	PageIndex int                  `json:"page_index"`

	CardTotalCount int `json:"card_total_count"`
	CardTotalStock int `json:"card_total_stock"`
	CardHoldCount  int `json:"card_hold_count"`
}

func (m *GameCardGoodsStockAnalysisReq) GameCardStockListAnalysis() (*GameCardGoodsStockAnalysisResp, error) {
	resp := &GameCardGoodsStockAnalysisResp{PageIndex: m.PageNum}
	type GameCardCount struct {
		CountGame uint32 `json:"count_game"`
	}
	var gameCardCount GameCardCount
	var goodsStocks []GameCardGoodsStock
	sqlOrder := ""
	switch m.SortType {
	case 1:
		sqlOrder = fmt.Sprintf(" ORDER BY total_stock ")
	case 2:
		sqlOrder = fmt.Sprintf(" ORDER BY rent_stock ")
	case 3:
		sqlOrder = fmt.Sprintf(" ORDER BY user_hold_stock ")
	case 4:
		sqlOrder = fmt.Sprintf(" ORDER BY order_count ")
	}

	if m.SortDirection == 1 {
		sqlOrder += " DESC"
	} else if m.SortDirection == 2 {
		sqlOrder += " ASC"
	}
	sqlStore := fmt.Sprintf(" AND cooperative_business_id = %d", m.CooperativeBusinessId)
	if m.StoreId != 0 {
		sqlStore = fmt.Sprintf(" AND store_id = %d", m.StoreId)
	}
	if m.Name != "" {
		var gameCards []GameCard
		sqlName := "SELECT * FROM game_card WHERE `name` LIKE '%" + m.Name + "%';"
		err := DB.Raw(sqlName).Scan(&gameCards).Error
		//err := orm.Eloquent.Exec(sqlName).Find(&gameCards).Error
		if err != nil {
			return resp, err
		}
		//fmt.Println("--sqlName:", sqlName)
		gameIds := make([]string, 0)
		for i, _ := range gameCards {
			gameIds = append(gameIds, fmt.Sprintf("%d", gameCards[i].ID))
		}

		//fmt.Println("--gameIds:", gameIds)
		sqlStore += fmt.Sprintf(" AND game_card_id IN (%s) ", strings.Join(gameIds, ","))
	}

	//var countGame int64
	sqlCount := fmt.Sprintf("SELECT COUNT(*) AS count_game FROM (SELECT SUM(total_stock) AS total_stock,SUM(order_count) AS order_count,SUM(user_hold_stock) AS user_hold_stock,SUM(rent_stock) AS rent_stock FROM game_card_goods_stock WHERE 1 %s GROUP BY game_card_id) a ;", sqlStore)
	fmt.Println("sqlCount:", sqlCount)
	err := DB.Raw(sqlCount).Scan(&gameCardCount).Error
	if err != nil {
		logger.Info("sqlCount:", sqlCount)
		logger.Error("sqlCount  err:", err)
		return resp, err
	}
	fmt.Println("countGame:", gameCardCount.CountGame)
	resp.Count = gameCardCount.CountGame
	page := int(m.PageNum) - 1
	if page < 0 {
		page = 0
	}
	if m.PageSize == 0 {
		m.PageSize = 10
	}

	sql := fmt.Sprintf(
		"SELECT * FROM (SELECT SUM(total_stock) AS total_stock,SUM(order_count) AS order_count,SUM(user_hold_stock) AS user_hold_stock,SUM(rent_stock) AS rent_stock,game_card_id FROM game_card_goods_stock WHERE 1 %s GROUP BY game_card_id) a  %s  LIMIT %d,%d;",
		sqlStore, sqlOrder, page*m.PageSize, m.PageSize)
	fmt.Println("sql:", sql)
	err = DB.Raw(sql).Scan(&goodsStocks).Error
	if err != nil {
		logger.Error("err:", err)
		return resp, err
	}

	if len(goodsStocks) == 0 {
		return resp, nil
	}

	gameIds := make([]uint32, 0, len(goodsStocks))
	for i, _ := range goodsStocks {
		gameIds = append(gameIds, uint32(goodsStocks[i].GameCardId))
	}
	fmt.Println("gameIds:", gameIds)
	var games []GameCard
	err = NewGameCardQuerySet(DB).IDIn(gameIds...).All(&games)
	//err = orm.Eloquent.Table("game_card").Where("id IN (?)", gameIds).Find(&games).Error
	if err != nil {
		logger.Error("err:", err)
		return resp, err
	}
	gameMap := make(map[uint32]GameCard, 0)
	for i, _ := range games {
		gameMap[games[i].ID] = games[i]
	}
	fmt.Println("games:", games)
	for i, _ := range goodsStocks {
		game, ok := gameMap[uint32(goodsStocks[i].GameCardId)]
		if ok {
			goodsStocks[i].Name = game.Name
			goodsStocks[i].CoverImg = game.CoverImg
		}
	}
	resp.List = goodsStocks

	holdQs := NewGameCardGoodsQuerySet(DB).StatusEq(GameCardGoodsStatusCustomerHold)
	//holdQs := orm.Eloquent.Table("game_card_goods").Where("status", GameCardGoodsStatusCustomerHold)
	if m.StoreId != 0 {
		holdQs = holdQs.StoreIdEq(uint64(m.StoreId))
	}
	cardHoldCount, err := holdQs.Count()
	if err != nil {
		logger.Error("hold count err:", err)
		return resp, err
	}
	resp.CardHoldCount = int(cardHoldCount)

	var (
		rentStock  uint32
		totalCount int
		cardStocks []GameCardGoodsStock
	)

	if m.StoreId != 0 {
		err = NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(m.StoreId)).All(&cardStocks)
	} else {
		err = NewGameCardGoodsStockQuerySet(DB).All(&cardStocks)
	}
	if err != nil {
		logger.Error("err:", err)
		return resp, err
	}
	for i, _ := range cardStocks {
		rentStock += cardStocks[i].RentStock
	}
	//var game GameCardGoods
	if m.StoreId != 0 {
		totalCount, err = NewGameCardGoodsQuerySet(DB).StoreIdEq(uint64(m.StoreId)).StatusIn([]uint32{1, 2, 3, 4}...).Count()
	} else {
		totalCount, err = NewGameCardGoodsQuerySet(DB).StatusIn([]uint32{1, 2, 3, 4}...).Count()
	}
	if err != nil {
		logger.Error("total count err:", err)
		return resp, err
	}

	resp.CardTotalStock = int(rentStock)
	resp.CardTotalCount = int(totalCount)

	return resp, nil
}

func CannibalizeTaskImportGoods(taskId uint32, serials []string) (uint32, error) {
	if taskId == 0 || len(serials) == 0 {
		return 0, errors.New("para err")
	}
	var cannibalizeTask CannibalizeStockTask
	err := NewCannibalizeStockTaskQuerySet(DB).IDEq(taskId).One(&cannibalizeTask)
	//err := orm.Eloquent.Table("cannibalize_stock_task").Where("id = ?", taskId).Find(&cannibalizeTask).Error
	if err != nil {
		logger.Error("cannibalize task err:", err)
		return 0, err
	}
	if cannibalizeTask.Status != CannibalizeTaskStatusNotImportGoods &&
		cannibalizeTask.Status != CannibalizeTaskStatusNotDeliverGoods {
		logger.Error("cannibalize status err:", err)
		return 0, err
	}

	var cannibalizeGoodses []CannibalizeGameCardGoods
	err = NewCannibalizeGameCardGoodsQuerySet(DB).CannibalizeStockTaskIdEq(taskId).All(&cannibalizeGoodses)
	if err != nil && err != RecordNotFound {
		logger.Error("cannibalize goods err:", err)
		return 0, err
	}
	impotentSerialMap := make(map[string]uint32, 0)
	if len(cannibalizeGoodses) > 0 {
		for i, _ := range cannibalizeGoodses {
			impotentSerialMap[cannibalizeGoodses[i].SerialNumber] = cannibalizeGoodses[i].GameCardId
		}
	}

	serialNumberSql := ""
	for i, _ := range serials {
		serialNumberSql += "'" + serials[i] + "',"
	}
	serialNumberSql = serialNumberSql[:len(serialNumberSql)-1]
	// 这些卡已在调拨任务中
	var cannibalizeInGoodses []CannibalizeGameCardGoods
	sql := fmt.Sprintf(
		"SELECT cannibalize_game_card_goods.* FROM cannibalize_game_card_goods LEFT JOIN cannibalize_stock_task ON cannibalize_stock_task.id = cannibalize_game_card_goods.cannibalize_stock_task_id WHERE  serial_number IN (%s) AND cannibalize_stock_task.status  IN (1,2,3) ;",
		serialNumberSql)
	err = DB.Raw(sql).Scan(&cannibalizeInGoodses).Error
	if err != nil {
		logger.Error("cannibalize in goods err:", err)
		return 0, err
	}
	cannibalizeInGoodsMap := make(map[string]uint32, 0)
	if len(cannibalizeInGoodses) > 0 {
		for i, _ := range cannibalizeInGoodses {
			cannibalizeInGoodsMap[cannibalizeInGoodses[i].SerialNumber] = cannibalizeInGoodses[i].GameCardId
		}
	}

	list := make([]GameCardGoods, 0)
	err = DB.Table("game_card_goods").Where("serial_number in (?)", serials).Find(&list).Error
	if err != nil {
		logger.Error("err:", err)
		return 0, err
	}
	unImpotentCount := 0
	impotentCount := 0
	begin := DB.Begin()
	for i, _ := range list {
		if list[i].Status != 1 {
			unImpotentCount++
			//fmt.Println("1", list[i].Status)
			continue
		}
		_, ok := impotentSerialMap[list[i].SerialNumber]
		if ok {
			unImpotentCount++
			//fmt.Println("2", list[i].SerialNumber)
			continue
		}
		if uint32(list[i].StoreId) != cannibalizeTask.FromStoreId {
			//fmt.Println("3", list[i].StoreId)
			continue
		}
		_, ok2 := cannibalizeInGoodsMap[list[i].SerialNumber]
		if ok2 {
			unImpotentCount++
			//fmt.Println("4", list[i].SerialNumber)
			continue
		}

		cardGoods := &CannibalizeGameCardGoods{
			CannibalizeStockTaskId: taskId,
			GameCardId:             uint32(list[i].GameCardId),
			SerialNumber:           list[i].SerialNumber,
		}
		err := begin.Create(cardGoods).Error
		if err != nil {
			begin.Rollback()
			logger.Error("err:", err)
			unImpotentCount++
			continue
		}
		impotentCount++
	}

	if cannibalizeTask.Status == CannibalizeTaskStatusNotImportGoods && impotentCount > 0 {
		sql := fmt.Sprintf("UPDATE cannibalize_stock_task SET status = 2 WHERE id = %d", taskId)
		err = begin.Exec(sql).Error
		if err != nil {
			begin.Rollback()
			logger.Errorf("update status err:%s", err.Error())
		}
	}
	err = begin.Commit().Error
	if err != nil {
		begin.Rollback()
		logger.Error("commit err:", err)
	}

	return uint32(unImpotentCount), nil
}

func CannibalizeDeliverGoods(taskId uint32) error {
	var cannibalizeTask CannibalizeStockTask
	err := NewCannibalizeStockTaskQuerySet(DB).IDEq(taskId).One(&cannibalizeTask)
	//err := orm.Eloquent.Table("cannibalize_stock_task").Where("id = ?", taskId).Find(&cannibalizeTask).Error
	if err != nil {
		logger.Error("cannibalize task err:", err)
		return err
	}
	if cannibalizeTask.Status != CannibalizeTaskStatusNotDeliverGoods {
		return errors.New("cannibalize task status err")
	}
	var cannibalizeGoodses []CannibalizeGameCardGoods
	err = NewCannibalizeGameCardGoodsQuerySet(DB).CannibalizeStockTaskIdEq(taskId).All(&cannibalizeGoodses)
	//err = orm.Eloquent.Table("cannibalize_game_card_goods").Where("cannibalize_stock_task_id = ?", taskId).Find(&cannibalizeGoodses).Error
	if err != nil && err != RecordNotFound {
		logger.Error("cannibalize goods err:", err)
		return err
	}
	serials := make([]string, 0, len(cannibalizeGoodses))
	serialMap := make(map[string]int, 0)
	for i, _ := range cannibalizeGoodses {
		serials = append(serials, cannibalizeGoodses[i].SerialNumber)
		serialMap[cannibalizeGoodses[i].SerialNumber] = i
	}
	list := make([]GameCardGoods, 0)
	//err = orm.Eloquent.Table("game_card_goods").Where("serial_number in (?)", serials).Find(&list).Error
	err = NewGameCardGoodsQuerySet(DB).SerialNumberIn(serials...).All(&list)
	if err != nil {
		logger.Error("err:", err)
		return err
	}

	for i, _ := range list {
		if list[i].Status != 1 {
			err = NewCannibalizeGameCardGoodsQuerySet(DB).SerialNumberEq(list[i].SerialNumber).Delete()
			//err = orm.Eloquent.Unscoped().Table("cannibalize_game_card_goods").Where("serial_number", list[i].SerialNumber).Delete(&CannibalizeGameCardGoods{}).Error
			if err != nil {
				logger.Error("delete card goods err:", err)
			}
			continue
		}
		begin := DB.Begin()
		sqlStatus := fmt.Sprintf("UPDATE game_card_goods SET status = 4 WHERE id = %d;", list[i].ID)
		err = begin.Exec(sqlStatus).Error
		if err != nil {
			begin.Rollback()
			logger.Error("err:", err)
			continue
		}

		//sql := fmt.Sprintf("UPDATE game_card_goods_stock SET rent_stock= rent_stock-1,store_stock=store_stock-1,total_stock=total_stock-1 WHERE store_id=%d AND game_card_id=%d;", list[i].StoreId, list[i].GameCardId)
		sql := fmt.Sprintf(
			"UPDATE game_card_goods_stock SET rent_stock= rent_stock-1,total_stock=total_stock-1 WHERE store_id=%d AND game_card_id=%d;",
			list[i].StoreId, list[i].GameCardId)
		fmt.Println("sql:", sql)
		err = begin.Exec(sql).Error
		if err != nil {
			begin.Rollback()
			logger.Error("err:", err)
			continue
		}

		err = begin.Commit().Error
		if err != nil {
			begin.Rollback()
			logger.Error("commit err:", err)
			continue
		}
		delete(serialMap, list[i].SerialNumber)

	}

	// 没有更新库存的卡
	if len(serialMap) > 0 {
		for k, _ := range serialMap {
			//fmt.Println("--------k", k)
			err = NewCannibalizeGameCardGoodsQuerySet(DB).SerialNumberEq(k).Delete()
			//err = orm.Eloquent.Unscoped().Table("cannibalize_game_card_goods").Where("serial_number=?", k).Delete(&CannibalizeGameCardGoods{}).Error
			if err != nil {
				logger.Error("delete card goods err:", err)
			}
		}
	}

	if cannibalizeTask.Status == CannibalizeTaskStatusNotDeliverGoods {
		sql := fmt.Sprintf("UPDATE cannibalize_stock_task SET status = 3,delivery_time=? WHERE id = %d", taskId)
		err = DB.Exec(sql, time.Now()).Error
		if err != nil {
			logger.Errorf("update status err:%s", err.Error())
		}
	}

	return nil
}

func CannibalizePutInStorage(taskId uint32) error {
	var cannibalizeTask CannibalizeStockTask
	err := NewCannibalizeStockTaskQuerySet(DB).IDEq(taskId).One(&cannibalizeTask)
	//err := orm.Eloquent.Table("cannibalize_stock_task").Where("id = ?", taskId).Find(&cannibalizeTask).Error
	if err != nil {
		logger.Error("cannibalize task err:", err)
		return err
	}
	if cannibalizeTask.Status != CannibalizeTaskStatusDeliveredGoods {
		return errors.New("cannibalize task status err")
	}
	var cannibalizeGoodses []CannibalizeGameCardGoods
	err = NewCannibalizeGameCardGoodsQuerySet(DB).CannibalizeStockTaskIdEq(taskId).All(&cannibalizeGoodses)
	//err = orm.Eloquent.Table("cannibalize_game_card_goods").Where("cannibalize_stock_task_id = ?", taskId).
	//	Find(&cannibalizeGoodses).Error
	if err != nil && err != RecordNotFound {
		logger.Error("cannibalize goods err:", err)
		return err
	}
	serials := make([]string, 0, len(cannibalizeGoodses))
	for i, _ := range cannibalizeGoodses {
		serials = append(serials, cannibalizeGoodses[i].SerialNumber)
	}
	list := make([]GameCardGoods, 0)
	err = NewGameCardGoodsQuerySet(DB).SerialNumberIn(serials...).All(&list)
	//err = orm.Eloquent.Table("game_card_goods").Where("serial_number in (?)", serials).Find(&list).Error
	if err != nil {
		logger.Error("err:", err)
		return err
	}
	for i, _ := range list {
		if list[i].Status != 4 {
			continue
		}
		//if CannibalizeUserShareCardRetrieve(cannibalizeTask.ToStoreId, list[i]) {
		//	continue
		//}
		//var count int64
		count, err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(cannibalizeTask.ToStoreId)).
			GameCardIdEq(list[i].GameCardId).Count()
		//err = orm.Eloquent.Table("game_card_goods_stock").Where("store_id = ?", cannibalizeTask.ToStoreId).
		//	Where("game_card_id = ?", list[i].GameCardId).Count(&count).Error
		if err != nil {
			logger.Error("err:", err)
			continue
		}

		begin := DB.Begin()
		sqlStatus := fmt.Sprintf("UPDATE game_card_goods SET status = 1,store_id=%d,stock_time='%s' WHERE id = %d;",
			cannibalizeTask.ToStoreId, time.Now().Format(TimeFormat), list[i].ID)
		err = begin.Exec(sqlStatus).Error
		if err != nil {
			begin.Rollback()
			logger.Error("err:", err)
			continue
		}

		if count > 0 {
			sql := fmt.Sprintf(
				"UPDATE game_card_goods_stock SET rent_stock= rent_stock+1,store_stock=store_stock+1,total_stock=total_stock+1 WHERE store_id=%d AND game_card_id=%d;",
				cannibalizeTask.ToStoreId, list[i].GameCardId)
			fmt.Println("sql:", sql)
			err = begin.Exec(sql).Error
			if err != nil {
				begin.Rollback()
				logger.Error("err:", err)
				continue
			}
		} else {
			cardGoodsStock := &GameCardGoodsStock{
				StoreId:       uint64(cannibalizeTask.ToStoreId),
				GameCardId:    list[i].GameCardId,
				StoreStock:    1,
				RentStock:     1,
				UserHoldStock: 0,
				OrderCount:    0,
				TotalStock:    1,
			}
			err := begin.Create(cardGoodsStock).Error
			if err != nil {
				begin.Rollback()
				logger.Error("err:", err)
				continue
			}
		}

		err = begin.Commit().Error
		if err != nil {
			begin.Rollback()
			logger.Error("commit err:", err)
			continue
		}
	}

	if cannibalizeTask.Status == CannibalizeTaskStatusDeliveredGoods {
		sql := fmt.Sprintf("UPDATE cannibalize_stock_task SET status = 4,in_storage_time=? WHERE id = %d", taskId)
		err = DB.Exec(sql, time.Now()).Error
		if err != nil {
			logger.Errorf("update status err:%s", err.Error())
		}
	}

	return nil
}

type CannibalizeTaskListReq struct {
	PageNum              int    `json:"page_num"`
	PageSize             int    `json:"page_size"`
	CannibalizeDirection uint32 `json:"cannibalize_direction"` // 1-调入 2-调出
	StoreId              uint32 `json:"store_id" `             // 门店id
	Status               uint8  `json:"status"`
}
type CannibalizeTaskListResp struct {
	PageSize  int                    `json:"page_size"`
	List      []CannibalizeStockTask `json:"list"`
	Count     int                    `json:"count"`
	PageNum   int                    `json:"page_num"`
	TotalPage int                    `json:"total_page"`
}

func (m *CannibalizeTaskListReq) GetCannibalizeTaskList() (*CannibalizeTaskListResp, error) {
	resp := &CannibalizeTaskListResp{
		PageNum:  m.PageNum,
		PageSize: m.PageSize,
	}

	qs := DB.Table("cannibalize_stock_task")
	//if m.StoreId != 0 {
	//	qs = qs.Where("from_store_id = ?", m.StoreId).Or("to_store_id = ?", m.StoreId)
	//}
	if m.Status != 0 {
		qs = qs.Where("status = ?", m.Status)
	}
	if m.CannibalizeDirection != 0 {
		if m.CannibalizeDirection == 1 {
			qs = qs.Where("to_store_id=?", m.StoreId)
		} else if m.CannibalizeDirection == 2 {
			qs = qs.Where("from_store_id=?", m.StoreId)
		}
	}
	page := m.PageNum - 1
	if page < 0 {
		page = 0
	}
	if m.PageSize == 0 {
		m.PageSize = 10
	}
	var (
		count int64
		tasks []CannibalizeStockTask
	)

	err := qs.Count(&count).Offset(page * m.PageSize).Limit(m.PageSize).Order("id DESC").Find(&tasks).Error
	if err != nil && err != RecordNotFound {
		logger.Error("err:", err)
		return resp, err
	}

	resp.Count = int(count)
	resp.List = CannibalizeStockTaskListSetInfo(tasks)

	return resp, nil
}

type CannibalizeTaskGameCardGoodsListReq struct {
	PageNum                int    `json:"page_num"`
	PageSize               int    `json:"page_size"`
	CannibalizeStockTaskId uint32 `json:"cannibalize_stock_task_id"`
}
type CannibalizeTaskGameCardGoodsListResp struct {
	PageSize  int                        `json:"pageSize"`
	List      []CannibalizeGameCardGoods `json:"list"`
	Count     int                        `json:"count"`
	PageNum   int                        `json:"page_num"`
	TotalPage int                        `json:"total_page"`
}

func (m *CannibalizeTaskGameCardGoodsListReq) GetCannibalizeTaskGameCardGoodsList() (*CannibalizeTaskGameCardGoodsListResp, error) {
	resp := &CannibalizeTaskGameCardGoodsListResp{
		PageNum:  m.PageNum,
		PageSize: m.PageSize,
	}
	qs := DB.Table("cannibalize_game_card_goods").Where("cannibalize_stock_task_id = ?", m.CannibalizeStockTaskId)

	page := m.PageNum - 1
	if page < 0 {
		page = 0
	}
	if m.PageSize == 0 {
		m.PageSize = 10
	}
	var (
		count              int64
		cannibalizeGoodses []CannibalizeGameCardGoods
	)
	//CannibalizeGameCardGoods int `json:"cannibalize_game_card_goods" gorm:"-"`
	err := qs.Count(&count).Offset(page * m.PageSize).Limit(m.PageSize).Order("id DESC").Find(&cannibalizeGoodses).Error
	if err != nil && err != RecordNotFound {
		logger.Error("err:", err)
		return resp, err
	}

	resp.Count = int(count)
	resp.List = CannibalizeGameCardGoodsSetInfo(cannibalizeGoodses)

	return resp, nil
}

func CannibalizeTaskDel(taskId uint32) error {
	var cannibalizeTask CannibalizeStockTask
	err := DB.Table("cannibalize_stock_task").Where("id = ?", taskId).Find(&cannibalizeTask).Error
	if err != nil {
		logger.Error("cannibalize task err:", err)
		return err
	}

	if cannibalizeTask.Status != CannibalizeTaskStatusNotImportGoods &&
		cannibalizeTask.Status != CannibalizeTaskStatusNotDeliverGoods {
		return errors.New("status err")
	}
	sql := fmt.Sprintf("UPDATE cannibalize_stock_task SET status = 5 WHERE id = %d", taskId)
	err = DB.Exec(sql).Error
	if err != nil {
		logger.Error("update status err:", err)
	}
	return nil
}

type CooperativeGameCardGoodsListReq struct {
	PageNum      int    `json:"page_num"`
	PageSize     int    `json:"page_size"`
	StoreId      uint32 `json:"store_id"`
	Status       int    `json:"status"`
	GameCardId   int    `json:"game_card_id"`
	SerialNumber string `json:"serial_number" ` // 编号
	AssistantUid uint32 `json:"assistant_uid"`
}
type CooperativeGameCardGoodsListResp struct {
	List      []GameCardGoods `json:"list"`
	Count     int             `json:"count"`
	PageNum   int             `json:"page_num"`
	TotalPage int             `json:"total_page"`
}

func (m *CooperativeGameCardGoodsListReq) List() (*CooperativeGameCardGoodsListResp, error) {
	var (
		cardGoods = make([]GameCardGoods, 0)
		totalPage uint32
	)
	resp := &CooperativeGameCardGoodsListResp{List: cardGoods, PageNum: m.PageNum}
	m.PageNum -= 1
	if m.PageNum < 0 {
		m.PageNum = 0
	}
	if m.PageSize == 0 {
		m.PageSize = 10
	}
	assistant := GetUserByUid(m.AssistantUid)
	m.StoreId = uint32(assistant.StoreId)
	fmt.Println("GetGameCardGoodsListReq:", m)
	gdb := DB.Table("game_card_goods")
	if m.Status != 0 {
		gdb = gdb.Where("status=?", m.Status)
	}
	if m.StoreId != 0 {
		gdb = gdb.Where("store_id=?", m.StoreId)
	}
	if m.GameCardId != 0 {
		gdb = gdb.Where("game_card_id=?", m.GameCardId)
	}
	if m.SerialNumber != "" {
		gdb = gdb.Where("serial_number=?", m.SerialNumber)
	}
	var count int64
	err := gdb.Count(&count).Error
	if err != nil {
		logger.Error("err:", err)
		return resp, err
	}
	resp.Count = int(count)
	err = gdb.Order("created_at DESC").Offset(m.PageNum * m.PageSize).Limit(m.PageSize).Find(&cardGoods).Error
	if err != nil && err != RecordNotFound {
		logger.Error("err:", err)
		return resp, err
	}

	if len(cardGoods) > 0 {
		//storeIds := make([]uint32, 0)
		gameCardIds := make([]uint32, 0)

		for i, _ := range cardGoods {
			//storeIds = append(storeIds, uint32(cardGoods[i].StoreId))
			gameCardIds = append(gameCardIds, uint32(cardGoods[i].GameCardId))
		}

		cardMap, err := GameCardMap(gameCardIds)
		if err != nil {
			logger.Error("game card map err:", err)
			return resp, err
		}
		//storeMap := GetStoreMapByIds(storeIds)

		for i, _ := range cardGoods {
			gameCard, ok1 := cardMap[uint32(cardGoods[i].GameCardId)]
			if ok1 {
				cardGoods[i].GameCard = &gameCard
			}

		}
	}

	totalPage = uint32(int(count)/m.PageSize + 1)
	resp.TotalPage = int(totalPage)
	resp.List = cardGoods
	return resp, nil
}

type AssistantMemberPromotionReq struct {
	PageNum      int    `json:"page_num"`
	PageSize     int    `json:"page_size"`
	Date         string `json:"date"`
	StoreId      uint32 `json:"store_id"`
	AssistantUid uint32 `json:"assistant_uid"`
	Assistant    *User  `json:"assistant"`
}

func (m *AssistantMemberPromotionReq) List() ([]InviteMemberReport, int, error) {
	var reports []InviteMemberReport

	m.PageNum -= 1
	if m.PageNum < 0 {
		m.PageNum = 0
	}
	if m.PageSize == 0 {
		m.PageSize = 10
	}

	m.StoreId = uint32(m.Assistant.StoreId)

	qs := NewInviteMemberReportQuerySet(DB).CooperativeBusinessIdEq(m.Assistant.CooperativeBusinessId).
		StoreIdEq(m.StoreId)
	if m.Date != "" {
		qs = qs.DateEq(m.Date)
	}
	count, err := qs.Count()
	if err != nil {
		logger.Error("err:", err)
		return reports, 0, err
	}
	totalPage := int(count)/m.PageSize + 1
	err = qs.OrderDescByID().Offset(m.PageNum * m.PageSize).Limit(m.PageSize).All(&reports)
	if err != nil && err != RecordNotFound {
		logger.Error("err:", err)
		return reports, totalPage, err
	}

	reports = InviteMemberReportListSetUser(reports)
	return reports, totalPage, nil
}

func GameCardListSetStockState(list []GameCard, storeId uint32) {
	gameCardIds := make([]uint64, 0, len(list))
	for i, _ := range list {
		gameCardIds = append(gameCardIds, uint64(list[i].ID))
	}
	if len(gameCardIds) == 0 {
		return
	}
	//gameIds := make([]uint32, 0)
	gameIdMap := make(map[uint32]uint32)
	if storeId != 0 {
		var cardStocks []GameCardGoodsStock
		err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(storeId)).GameCardIdIn(gameCardIds...).
			RentStockGt(0).All(&cardStocks)
		if err != nil {
			logger.Error("GetGameIdByType err:", err)
		}
		for i, _ := range cardStocks {
			_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
			if !ok {
				//gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
				gameIdMap[uint32(cardStocks[i].GameCardId)] = 1
			}
		}

		err = NewGameCardGoodsStockQuerySet(DB).StoreIdNe(uint64(storeId)).GameCardIdIn(gameCardIds...).
			RentStockGt(0).All(&cardStocks)
		if err != nil {
			logger.Error("GetGameIdByType err:", err)
		}
		for i, _ := range cardStocks {
			_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
			if !ok {
				//gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
				gameIdMap[uint32(cardStocks[i].GameCardId)] = 2
			}
		}

		err = NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(gameCardIds...).RentStockEq(0).All(&cardStocks)
		if err != nil {
			logger.Error("GetGameIdByType err:", err)
		}
		for i, _ := range cardStocks {
			_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
			if !ok {
				//gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
				gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
			}
		}

	} else {
		var cardStocks []GameCardGoodsStock
		err := NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(gameCardIds...).RentStockGt(0).
			All(&cardStocks)
		if err != nil {
			logger.Error("GetGameIdByType err:", err)
		}
		for i, _ := range cardStocks {
			_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
			if !ok {
				gameIdMap[uint32(cardStocks[i].GameCardId)] = 1
			}
		}

		err = NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(gameCardIds...).RentStockEq(0).All(&cardStocks)
		if err != nil {
			logger.Error("GetGameIdByType err:", err)
		}
		for i, _ := range cardStocks {
			_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
			if !ok {
				gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
			}
		}

	}

	for i, _ := range list {
		v, ok := gameIdMap[uint32(list[i].ID)]
		if ok {
			//gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
			list[i].StockState = v
		}
		//gameCardIds = append(gameCardIds, uint64(list[i].ID))
	}
}

func InviteMemberReportListSetUser(list []InviteMemberReport) []InviteMemberReport {
	uids := make([]uint32, 0, len(list))
	for i, _ := range list {
		uids = append(uids, list[i].Uid)
	}
	userMap, err := GetUserMap(uids)
	if err != nil {
		logger.Error("user map err:", err)
		return list
	}
	for i, _ := range list {
		v, ok := userMap[list[i].Uid]
		if ok {
			list[i].User = v
		}
	}
	return list
}