package model

import (
	"github.com/codinl/go-logger"
	"golang.org/x/sync/errgroup"
	"time"
)

//go:generate goqueryset -in store.go
// gen:qs
type Store struct {
	Model

	Name                  string  `json:"name"`                                 // 门店名称
	Img                   string  `json:"img"`                                  // 门面图
	Tel                   string  `json:"tel" gorm:"type:varchar(20)"`          // 电话
	Province              string  `json:"province" gorm:"type:varchar(100)"`    // 省
	City                  string  `json:"city" gorm:"type:varchar(100)"`        // 市
	District              string  `json:"district" gorm:"type:varchar(100)"`    // 区
	Address               string  `json:"address" gorm:"type:varchar(100)"`     // 详细地址
	Longitude             float64 `json:"longitude" gorm:"column:longitude"`    // 经度
	Latitude              float64 `json:"latitude" gorm:"column:latitude"`      // 纬度
	IsOnline              uint32  `json:"is_online"`                            // 在线
	CooperativeBusinessId uint32  `json:"cooperative_business_id" gorm:"index"` // 合作商id
	CooperativeName       string  `json:"cooperative_name"`                     // 合作商名称
}

func (*Store) TableName() string {
	return "store"
}

type GameCardStock struct {
	Store
	Stock uint32 `json:"stock"`
}

func GetStoreList(cardInfos []CardInfo) ([]GameCardStock, error) {
	var eg errgroup.Group
	stores := make([]Store, 0)
	stocks := make([]GameCardGoodsStock, 0)
	list := make([]GameCardStock, 0)
	storesCh := make(chan *[]Store, 0)
	eg.Go(func() error {
		gameStore := make([]Store, 0)
		err := NewStoreQuerySet(DB).IsOnlineEq(1).OrderDescByCreatedAt().All(&gameStore)
		if err != nil && err != RecordNotFound {
			logger.Errorf("err:%+v", err)
			return err
		}
		storesCh <- &gameStore
		return nil
	})

	if len(cardInfos) == 0 {
		stores = *<-storesCh
		//fmt.Println("stores:", stores)
		for i, _ := range stores {
			cardStock := GameCardStock{
				Store: stores[i],
				Stock: 0,
			}
			list = append(list, cardStock)
		}
		return list, nil
	}

	gameIds := make([]uint64, 0)
	cardInfoMap := make(map[uint64]uint32, 0)
	for i, _ := range cardInfos {
		gameIds = append(gameIds, uint64(cardInfos[i].GameCardId))
		cardInfoMap[uint64(cardInfos[i].GameCardId)] = cardInfos[i].Count
	}
	eg.Go(func() error {
		//err := NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(gameId).RentStockGt(0).All(&stocks)
		err := NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(gameIds...).RentStockGt(0).All(&stocks)
		if err != nil {
			logger.Errorf("err:%+v", err)
			return err
		}
		return nil
	})
	stores = *<-storesCh
	err := eg.Wait()
	if err != nil {
		logger.Errorf("err:%+v", err)
		return list, err
	}
	//stockMap := make(map[uint64]uint32)
	//for i, _ := range stocks {
	//	count, ok := cardInfoMap[uint64(stocks[i].GameCardId)]
	//	if ok &&  count <= stocks[i].RentStock {
	//		stockMap[stocks[i].StoreId] = stocks[i].RentStock
	//	}
	//}

	storeStockMap := make(map[uint64]map[uint64]uint32, 0)
	for i, _ := range stocks {
		//count, ok := cardInfoMap[uint64(stocks[i].GameCardId)]
		//if ok &&  count <= stocks[i].RentStock {
		//	stockMap[stocks[i].StoreId] = stocks[i].RentStock
		//}
		stockMap, ok := storeStockMap[stocks[i].StoreId]
		if !ok {
			stockMap = make(map[uint64]uint32, 0)
		}
		stockMap[stocks[i].GameCardId] = stocks[i].RentStock
		storeStockMap[stocks[i].StoreId] = stockMap
	}

	for i, _ := range stores {
		stockMap, ok := storeStockMap[uint64(stores[i].ID)]
		if ok && IsStoreStockEnough(cardInfos, stockMap) {
			cardStock := GameCardStock{
				Store: stores[i],
				Stock: 0,
			}
			list = append(list, cardStock)
		}

		//if ok {
		//	cardStock := GameCardStock{
		//		Store: stores[i],
		//		Stock: rentStock,
		//	}
		//	list = append(list, cardStock)
		//}
	}
	//fmt.Println("list:", list)
	return list, nil
}

func GetDisplayStoreList(displayType uint32) ([]Store, error) {
	stores := make([]Store, 0)
	qs := NewStoreQuerySet(DB).IsOnlineEq(1)
	if displayType == 1 {
		qs = qs.CooperativeBusinessIdEq(1)
	}
	err := qs.OrderDescByID().All(&stores)
	if err != nil && err != RecordNotFound {
		logger.Errorf("err:%+v", err)
		return stores, err
	}

	return stores, nil
}

func (m *Store) Info() error {
	err := NewStoreQuerySet(DB).IDEq(m.ID).One(m)
	if err != nil {
		logger.Error("err:", err)
		return err
	}
	return nil
}

const (
	CannibalizeTaskStatusNotImportGoods  = 1 // 1-待填调拨卡
	CannibalizeTaskStatusNotDeliverGoods = 2 // 2-待发货
	CannibalizeTaskStatusDeliveredGoods  = 3 // 3-已发货
	CannibalizeTaskStatusInStorage       = 4 // 4-已入库
	CannibalizeTaskStatusDel             = 5 // 4-已删除
)

// gen:qs
type CannibalizeStockTask struct {
	Model
	FromStoreId uint32 `json:"from_store_id"`
	ToStoreId   uint32 `json:"to_store_id"`
	TaskId      uint32 `json:"task_id"`
	//GameCardId  uint32 `json:"game_card_id"` // 游戏卡id
	Count         uint32    `json:"count"`  // 总数量
	Status        uint8     `json:"status"` // 1-待填调拨卡 2-待发货 3-已发货 4-已入库
	DeliveryTime  time.Time `json:"delivery_time"`
	InStorageTime time.Time `json:"in_storage_time"`

	FromStoreName string `json:"from_store_name" gorm:"-"`
	ToStoreName   string `json:"to_store_name" gorm:"-"`
	// cannibalize_stock_task
}

// gen:qs
type CannibalizeGameCardGoods struct {
	Model

	CannibalizeStockTaskId uint32 `json:"cannibalize_stock_task_id"`
	GameCardId             uint32 `json:"game_card_id"`               // 游戏卡id
	SerialNumber           string `json:"serial_number" gorm:"index"` // 编号
	GameCardName           string `json:"game_card_name" gorm:"–"`
	// cannibalize_game_card_goods
}

func IsStoreStockEnough(cardInfos []CardInfo, gameStockMap map[uint64]uint32) bool {
	//haveStock =
	for i, _ := range cardInfos {
		stock, ok := gameStockMap[uint64(cardInfos[i].GameCardId)]
		if !ok || stock < cardInfos[i].Count {
			return false
		}
	}
	return true
}

func CannibalizeStockTaskListSetInfo(tasks []CannibalizeStockTask) []CannibalizeStockTask {
	if len(tasks) == 0 {
		return tasks
	}
	storeMap := GetAllStoreMap()
	for i, _ := range tasks {
		toStore, ok1 := storeMap[tasks[i].ToStoreId]
		if ok1 {
			tasks[i].ToStoreName = toStore.Name
		}
		fromStore, ok2 := storeMap[tasks[i].FromStoreId]
		if ok2 {
			tasks[i].FromStoreName = fromStore.Name
		}
	}
	return tasks
}

func GetAllStoreMap() map[uint32]Store {
	storeMap := make(map[uint32]Store, 0)
	var stores []Store
	err := DB.Table("store").Find(&stores).Error
	if err != nil {
		logger.Errorf("err:%s", err)
		return storeMap
	}
	for i, _ := range stores {
		storeMap[stores[i].ID] = stores[i]
	}

	return storeMap
}

func CannibalizeGameCardGoodsSetInfo(goodses []CannibalizeGameCardGoods) []CannibalizeGameCardGoods {
	if len(goodses) == 0 {
		return goodses
	}
	ids := make([]uint32, 0)
	for i, _ := range goodses {
		ids = append(ids, goodses[i].GameCardId)
	}
	var gameCards []GameCard
	err := DB.Table("game_card").Where("id IN (?)", ids).Find(&gameCards).Error
	if err != nil {
		logger.Error("err:", err)
		return goodses
	}
	gameCardMap := make(map[uint32]GameCard, 0)
	for i, _ := range gameCards {
		gameCardMap[gameCards[i].ID] = gameCards[i]
	}

	for i, _ := range goodses {
		v, ok := gameCardMap[goodses[i].GameCardId]
		if ok {
			goodses[i].GameCardName = v.Name
		}
	}
	//UserOpenMemberRecord{}
	return goodses
}

//func GetDeliveryStoreByAddress(addressId uint32) Store {
//	// 订单最少的店
//	// 没有库存
//	// 订单最多的店
//	store := Store{}
//	var address UserAddress
//	err := NewUserAddressQuerySet(DB).IDEq(addressId).One(&address)
//	if err != nil {
//		logger.Error("user address err:", err)
//		return store
//	}
//
//	var stores []Store
//	err = NewStoreQuerySet(DB).ProvinceEq(address.Province).All(&stores)
//	if err != nil {
//		logger.Error("store err:", err)
//		return store
//	}
//
//	storeIds := make([]uint32, 0, len(stores))
//	for i, _ := range stores {
//		storeIds = append(storeIds, stores[i].ID)
//	}
//
//	NewGameCardGoodsStockQuerySet(DB).IDIn(storeIds...)
//
//}