package model

import (
	"crypto/sha512"
	"encoding/json"
	"fmt"
	"github.com/codinl/go-logger"
	"github.com/jinzhu/gorm"
	"math/rand"
	"strings"
	"testing"
	"time"
)

func TestGameList(t *testing.T) {
	InitTestDB()
	var game GameCard
	err := NewGameCardQuerySet(DBDev).IDEq(1).One(&game)
	if err != nil {
		logger.Error("err:", err)
		return
	}
	logger.Infof("game %#v", game)
	fmt.Printf("game %#v", game)
	gameName := game.Name
	for i := 50; i < 200; i++ {
		randNum := getRandNum()
		numUnix := getRandNumUnix()

		num := fmt.Sprintf("0%d", i+1)
		game.Name = num + gameName
		game.NewProducts = 2
		game.Price = uint32(randNum)
		game.OrderCount = uint32(randNum + numUnix)
		game.ID = 0
		DBDev.Create(&game)
	}
}

func getRandNum() int {
	rand.Seed(time.Now().UnixNano())
	return rand.Intn(1000)
}

func getRandNumUnix() int {
	rand.Seed(time.Now().Unix())
	return rand.Intn(1000)
}

var DBDev *gorm.DB

// 测试服务器
func InitTestDB() {
	var err error

	dialect := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
		"mh_dev", "m5h4parZsXjbeiFh", "39.108.188.218", "3306", "mh_dev")

	db, err := gorm.Open("mysql", dialect)
	if err != nil {
		logger.Infof("Open DB error [%s] with dialect[%s]", err.Error(), dialect)
		panic(err)
	}

	if db.DB().Ping() != nil {
		fmt.Printf("Ping DB fail: %#v", db.Error)
		panic(err)
	}
	db.SingularTable(true)

	db.AutoMigrate(
		&User{},
		//&LotteryInviteTargetUser{},
		&GameCard{},
		&Collection{},
		&Config{},
		&HistoryBrowsing{},
		&ShoppingCart{},
		&UserAddress{},
		&SearchHistory{},
		&Order{},
		&HotSearch{},
		&HomeCarousel{},
		&GameCardType{},
		&Store{},
		&GameType{},
		&UserOpenMemberRecord{},
		&CommonProblem{},
		&ExpressCompany{},
		&GameCardGoodsStock{},
		&GameCardGoods{},
		&UserInvite{},
		&ArticleTitlePanel{},
		&RedeemCode{},
		&UserRedeemCode{},
		&DepositRefundRecord{},
		&GroupSendMessageTemplate{},
		&OrderCard{},
		&UserRentCard{},
		&UserConsumeRecord{},


	)

	fmt.Println("DB init success")
	DBDev = db
	logger.Info("ok")
}

func TestInitTestDBModel(t *testing.T) {
	InitTestDB()
}

func TestMemberExprireTime(t *testing.T) {
	InitTestDB()
}

var DBProd *gorm.DB

func InitDBProd() {
	var err error
	dialect := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
		"mh_pro", "fLeytnBFCRB553ab", "39.108.188.218", "3306",
		"mh_pro")

	DBProd, err = gorm.Open("mysql", dialect)
	if err != nil {
		fmt.Println("Connect Database Error, error = ", err)
		panic(err)
	}
	DBProd.DB().SetMaxOpenConns(1000)
	DBProd.DB().SetMaxIdleConns(500)
	DBProd.DB().SetConnMaxLifetime(time.Second * 10)
	DBProd.LogMode(true)
	DBProd.SingularTable(true)
	DBProd.AutoMigrate(
		&RedeemCode{},
		&UserRedeemCode{},
	)

	if err := DBProd.DB().Ping(); err != nil {
		fmt.Println("Ping Database Fail, error = ", err)
		panic(err)
	}
	fmt.Println("DB init success")
}

func TestHotSearch_TableName(t *testing.T) {
	InitTestDB()

	list := []string{"马里奥赛车8豪华版", "任天堂明星大乱斗 特别版", "超级马力欧 奥德赛", "塞尔达传说：旷野之息", "宝可梦：剑 / 盾", "精灵宝可梦 Let's Go! 皮卡丘/Let's Go! 伊布", "喷射战士2", "超级马力欧派对", "新超级马里奥兄弟U", "路易基鬼屋3", "超级马力欧创作家2", "塞尔达传说:织梦岛", "集合了！动物森友会", "1-2 Switch", "马里奥网球Aces", "马里奥+疯兔：王国之战", "火焰之纹章：风花雪月", "星之卡比：新星同盟", "大金刚国度：热带寒流"}
	for i, s := range list {
		hotSearch := &HotSearch{
			Keyword: s,
			Sort:    uint32(len(list) - i),
		}
		err := hotSearch.Create(DBDev)
		if err != nil {
			logger.Error("err:", err)
		}
	}
}

func TestGetHomeCarouselList(t *testing.T) {
	InitTestDB()
	//imgs := []string{"1-2011060021334X.jpg", "1-2011060021425N.jpg", "1-201106002150294.jpg", "1-201106002159522.jpg"}
	imgs := []string{"http://39.108.188.218:8000/img/1-2011060021334X.jpg", "http://39.108.188.218:8000/img/1-2011060021425N.jpg", "http://39.108.188.218:8000/img/1-201106002150294.jpg", "http://39.108.188.218:8000/img/1-201106002159522.jpg"}
	for i, img := range imgs {
		homeCarousel := &HomeCarousel{
			Name:   "banner" + fmt.Sprintf("%d", len(imgs)-i),
			Img:    img,
			Sort:   uint32(len(imgs) - i),
			IsShow: 1,
			Detail: "",
			Link:   "",
		}
		err := homeCarousel.Create(DBDev)
		if err != nil {
			logger.Error("err:", err)
		}
	}
}

func TestGameCardType_Create(t *testing.T) {
	InitTestDB()
	types := []string{"角色扮演", "射击游戏", "动作游戏", "冒险游戏", "赛车游戏", "策略游戏", "即时战略", "养成游戏", "桌面棋牌", "休闲益智", "体育运动", "模拟经营", "音乐游戏", "格斗游戏", "动作角色", "第一人称射击", "第三人称射击"}
	for i, s := range types {
		cardType := GameCardType{
			Name: s,
			Sort: uint32(i + 100),
		}
		err := cardType.Create(DBDev)
		if err != nil {
			logger.Error("err:", err)
		}
	}

}

func TestStore_TableName(t *testing.T) {
	InitTestDB()

	for i := 0; i < 10; i++ {
		idx := fmt.Sprintf("%d", i+1)
		store := Store{
			Name:      "门店" + idx,
			Img:       "http://39.108.188.218:8000/img/1599445323_430355.jpg",
			Tel:       "021-54473036",
			Province:  "广东省",
			City:      "深圳市",
			District:  "南山区",
			Address:   "高新园",
			Longitude: 0,
			Latitude:  0,
		}
		err := store.Create(DBDev)
		if err != nil {
			logger.Error("err:", err)
		}
	}

}

func TestPess(t *testing.T) {
	InitTestDB()
	comp := []string{"圆通速递", "韵达快递", "中通快递", "顺丰速运", "申通快递", "百世快递", "邮政快递包裹", "京东物流", "EMS", "极兔速递", "EMS包裹"}
	compCode := []string{"yuantong", "yunda", "zhongtong", "shunfeng", "shentong", "huitongkuaidi", "youzhengguonei", "jd", "ems", "jtexpress", "emsbg"}
	for i, _ := range comp {
		company := &ExpressCompany{
			CompanyName: comp[i],
			CompanyCode: compCode[i],
		}
		err := company.Create(DBDev)
		if err != nil {
			logger.Error("err:", err)
		}
	}
}

func TestGoodsStock(t *testing.T) {
	InitTestDB()
	cards := make([]GameCard, 0)
	err := NewGameCardQuerySet(DBDev).All(&cards)
	if err != nil {
		logger.Error("err:", err)
	}
	stores := make([]Store, 0)
	err = NewStoreQuerySet(DBDev).All(&stores)
	if err != nil {
		logger.Error("err:", err)
	}

	for _, store := range stores {
		for _, card := range cards {
			stock := &GameCardGoodsStock{
				StoreId:    uint64(store.ID),
				GameCardId: uint64(card.ID),
				StoreStock: 1000,
				RentStock:  10,
			}
			err := stock.Create(DBDev)
			if err != nil {
				logger.Error("err:", err)
			}
		}
	}
}

func TestGoodsCard(t *testing.T) {
	InitTestDB()
	cards := make([]GameCard, 0)
	err := NewGameCardQuerySet(DBDev).All(&cards)
	if err != nil {
		logger.Error("err:", err)
	}
	stores := make([]Store, 0)
	err = NewStoreQuerySet(DBDev).All(&stores)
	if err != nil {
		logger.Error("err:", err)
	}

	for _, store := range stores {
		for _, card := range cards {
			stock := &GameCardGoodsStock{
				StoreId:    uint64(store.ID),
				GameCardId: uint64(card.ID),
				StoreStock: 1000,
				RentStock:  10,
			}
			err := stock.Create(DBDev)
			if err != nil {
				logger.Error("err:", err)
			}
		}
	}
}

func TestOrderList(t *testing.T) {
	InitTestDB()
	count, err := NewOrderQuerySet(DBDev.Debug()).UidEq(uint64(55191926)).PayStatusEq(PayStatusPaid).CardStatusIn([]uint8{1, 2, 3}...).Count()
	if err != nil {
		logger.Error("err:", err)

	}

	fmt.Println("count:", count)
}

func TestGenShareCode(t *testing.T) {

}

func TestUserBundleFirstOrderStore(t *testing.T) {
	UserBundleFirstOrderStore()
}

func UserBundleFirstOrderStore() {
	InitDBProd()
	var users []User
	//err := NewUserQuerySet(DBProd).StoreIdEq(0).MemberLevelGte(2).OrderAscByID().All(&users)
	err := NewUserQuerySet(DBProd).StoreTypeEq(1).OrderAscByID().All(&users)
	if err != nil {
		fmt.Println("users err:", err)
		return
	}

	for i, _ := range users {
		//var order Order
		//err := NewOrderQuerySet(DBProd).UidEq(uint64(users[i].Uid)).PayStatusEq(PayStatusPaid).
		//	CardStatusEq(OrderCardStatusCompleted).OrderAscByCreatedAt().Limit(1).One(&order)
		//if err != nil {
		//	fmt.Println("store_id err:", err)
		//	//return
		//}

		//if i > 3{
		//	return
		//}
		if users[i].Uid == 0 {
			continue
		}
		//sql := fmt.Sprintf("UPDATE `user` SET store_id =%d,store_type=1 WHERE uid = %d;", order.StoreId, users[i].Uid)
		//fmt.Println("sql:", sql)
		//err = DBProd.Exec(sql).Error
		//if err != nil {
		//	fmt.Println("store_id err:", err)
		//	return
		//}
		userInvite := &UserInvite{
			FromUid:        0,
			UserType:       0,
			StoreId:        users[i].StoreId,
			MemberOpenTime: users[i].MemberExpire.AddDate(-1, 0, 0),
			MemberType:     2,
			MemberStatus:   2,
			ToUid:          users[i].Uid,
			StoreType:      1,
		}

		err = DBProd.Create(userInvite).Error
		if err != nil {
			fmt.Println("create err:", err)
		}
	}
}

func TestMemberCode(t *testing.T) {

	for i := 0; i < 100; i++ {
		MemberCode()
	}

}

func MemberCode() {
	//sha256.New()
	//ft := time.Now().Format("20060102150405")
	st := fmt.Sprintf("%d", time.Now().UnixNano())
	str := "test-hash" + st
	hasher := sha512.New()

	hasher.Write([]byte(str))

	r := hasher.Sum(nil)

	//fmt.Printf("%x \n",r)

	hs := fmt.Sprintf("%x", r)

	upper := strings.ToUpper(hs)

	fmt.Println("upper:", upper)

}

func TestLeng(t *testing.T) {
	fmt.Println("len:", len("22AB0776591642F13101"))

	// B61E1104C989D4E2F453EB6253A06A3721094DDF76FF468EB679CEA046403D3F7B963A8FBED0CB70C1EB9B17BB684DAFB700F966676D
}

func TestRedeemCodeCreate(t *testing.T) {
	RedeemCodeCreate()
}

func RedeemCodeCreate() {
	//InitTestDB()
	InitDBProd()

	for i := 0; i < 1000; i++ {
		redeem := NewRedeemCode()

		fmt.Println("redeemCode:", redeem)

		secretCode := RedeemSecretCode(redeem)

		fmt.Println("secretCode:", secretCode)
		if !IsRedeemCodeExist(redeem) {
			redeemCode := &RedeemCode{
				SerialCode:     redeem,
				CodeType:       CodeTypeMemberCard30,
				Status:         RedeemCodeStatusStock,
				CodeSecret:     secretCode,
				EffectiveTime:  time.Now(),
				ExpirationTime: time.Time{},
			}
			err := DBProd.Create(redeemCode).Error
			if err != nil {
				fmt.Println("err:", err)

			}
		}

	}

}

func IsRedeemCodeExist(code string) bool {
	var isExist uint32
	sql := fmt.Sprintf("SELECT EXISTS (SELECT * FROM redeem_code WHERE serial_code = '%s') AS code_exsit;", code)
	err := DBProd.Raw(sql).Row().Scan(&isExist)
	if err != nil {
		fmt.Println("err:", err)
		return true
	}
	return isExist == 1
}

func NewRedeemCode() string {
	semen := fmt.Sprintf("MemberCard30%d", time.Now().UnixNano())
	shaer := sha512.New()
	shaer.Write([]byte(semen))
	r := shaer.Sum(nil)
	hs := fmt.Sprintf("%x", r)
	hs = strings.ToUpper(hs)

	return "MC30" + hs[:19]
}

func TestInitConfig(t *testing.T) {
	InitConfig()
}

func InitConfig() {
	//InitTestDB()
	InitDBProd()

	payConfig := &PayConfig{
		MemberFee:  29900,
		DepositFee: 30000,
		NotifyUrl:  "https://switch.deovo.com:8001/api/v1/wxpay/notice",
	}
	bytes, err := json.Marshal(payConfig)
	if err != nil {
		fmt.Println("err:", err)
	}

	configInfo := &Config{
		Name:  "pay_config",
		Value: string(bytes),
	}

	err = DBProd.Create(configInfo).Error
	if err != nil {
		fmt.Println("err:", err)
	}
}

func TestMergingGameCards(t *testing.T) {
	MergingGameCards()
}

func MergingGameCards() {

	//UPDATE history_browsing SET game_card_id=782  WHERE game_card_id = 870;
	//UPDATE collection SET game_card_id=782  WHERE game_card_id = 870;
	//UPDATE game_card_goods SET game_card_id=782  WHERE game_card_id = 870;
	//UPDATE `order` SET game_card_id=782  WHERE game_card_id = 870;
	//UPDATE shopping_cart SET game_card_id=782  WHERE game_card_id = 870;

	fromGameId := uint64(870)
	toGameId := uint64(782)
	InitDBProd()
	var fromGameCardStock []GameCardGoodsStock
	err := NewGameCardGoodsStockQuerySet(DBProd).GameCardIdEq(fromGameId).All(&fromGameCardStock)
	if err != nil {
		logger.Error("err:", err)
		return
	}

	var toGameCardStock []GameCardGoodsStock
	err = NewGameCardGoodsStockQuerySet(DBProd).GameCardIdEq(toGameId).All(&toGameCardStock)
	if err != nil {
		logger.Error("err:", err)
		return
	}

	toGameMap := make(map[uint64]GameCardGoodsStock, 0)
	for i, _ := range toGameCardStock {
		toGameMap[toGameCardStock[i].StoreId] = toGameCardStock[i]
	}

	for _, v := range fromGameCardStock {

		//fmt.Println("fromGameCardStock:", fromGameCardStock[i].StoreId)
		//fmt.Println("fromGameCardStock:", fromGameCardStock[i].StoreStock)
		//fmt.Println("fromGameCardStock:", v.RentStock)

		cardGoodsStock, ok := toGameMap[v.StoreId]

		if ok {
			//	cardGoodsStock.StoreStock += v.StoreStock
			//	cardGoodsStock.RentStock += v.RentStock
			//	cardGoodsStock.UserHoldStock += v.UserHoldStock
			//	cardGoodsStock.OrderCount += v.OrderCount
			//	cardGoodsStock.TotalStock += v.TotalStock
			//	err := DBProd.Save(&cardGoodsStock).Error
			//	if err != nil {
			//		logger.Error("err:", err)
			//	}
			fmt.Println("cardGoodsStock:", cardGoodsStock)
		} else {
			fmt.Println("cardGoodsStock:", v.StoreId)
			v.ID = 0
			v.GameCardId = 782
			err := DBProd.Create(&v).Error
			if err != nil {
				logger.Error("create err:", err)
			}
		}
	}

}

func UpdateUserName()  {
	InitDBProd()

}