package handler

import (
	"fmt"
	"gorm.io/gorm/clause"
	"math/rand"
	"server/call"
	"server/common"
	"server/config"
	"server/db"
	"server/modules/web/app"
	"server/modules/web/values"
	"server/util"
	"sort"
	"strconv"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/liangdas/mqant/log"
	"github.com/olivere/elastic/v7"
	"gorm.io/gorm"
)

// GetUserTaskStatus 获取任务状态
func GetUserTaskStatus(a *app.Gin) (ret []*values.OneTask) {
	userTask := call.GetUserTaskData(a.UID)
	taskCfgs := call.GetConfigTask()
	taskMap := make(map[int]*common.ConfigTaskStr) // 任务列表
	userTaskMap := make(map[int]*common.TaskData)
	preTask := make(map[int]struct{})
	var update bool
	for _, v := range taskCfgs {
		taskMap[v.TaskID] = &common.ConfigTaskStr{
			ConfigTask: v,
		}
		if v.PreTaskId > 0 {
			preTask[v.PreTaskId] = struct{}{}
		}
	}
	for _, v := range userTask {
		if _, ok := taskMap[v.TaskID]; !ok { // 不存在则删除
			db.Mysql().C().Model(&common.TaskData{}).Where("id = ?", v.ID).Delete(&common.TaskData{})
			update = true
			continue
		} else {
			taskMap[v.TaskID].Exist = true
		}
	}

	for _, v := range taskMap {
		if !v.Exist { // 不存在/失效的 则创建/更新
			update = true
			task := &common.TaskData{
				UID:        a.UID,
				TaskID:     v.TaskID,
				TaskType:   int(v.Type),
				TaskValue:  0,
				TaskStatus: 0,
				EndAt:      0,
				CreatedAt:  time.Now(),
				UpdatedAt:  time.Now(),
			}
			switch v.Cycle {
			case 1:
				task.EndAt = util.GetZeroTime(time.Now().AddDate(0, 0, 1)).Unix()
			case 2:
				task.EndAt = util.GetWeekZeroTime(time.Now().AddDate(0, 0, 7)).Unix()
			case 3:
				task.EndAt = util.GetFirstDateOfMonth(time.Now().AddDate(0, 1, 0)).Unix()
			case 4:
				task.EndAt = -1
			}
			err := db.Mysql().C().Model(&common.TaskData{}).Clauses(clause.OnConflict{
				Columns: []clause.Column{{Name: "uid"}, {Name: "task_id"}},
				DoUpdates: clause.Assignments(map[string]interface{}{
					"task_type":   task.TaskType,
					"task_value":  task.TaskValue,
					"task_status": task.TaskStatus,
					"end_at":      task.EndAt,
					"updated_at":  task.UpdatedAt,
				}),
			}).Create(task).Error
			if err != nil {
				log.Error("create task err, %s", err.Error())
				continue
			}
		}
	}

	if update {
		userTask = call.GetUserTaskData(a.UID)
	}

	for _, v := range userTask {
		userTaskMap[v.TaskID] = v
	}

	ret = make([]*values.OneTask, 0, len(userTask))
	for _, v := range userTask {
		if taskMap[v.TaskID].PreTaskId > 0 && userTaskMap[taskMap[v.TaskID].PreTaskId].TaskStatus != 2 {
			continue
		}
		if _, ok := preTask[v.TaskID]; ok && v.TaskStatus == 2 {
			continue
		}
		oneTask := &values.OneTask{
			TaskID:   v.TaskID,
			Progress: int64(v.TaskValue),
			Target:   taskMap[v.TaskID].Target,
			Reward:   taskMap[v.TaskID].Reward,
			Cycle:    taskMap[v.TaskID].Cycle,
			TaskType: int(taskMap[v.TaskID].Type),
			Status:   v.TaskStatus,
			Title:    taskMap[v.TaskID].Title,
			Url:      taskMap[v.TaskID].Url,
			Sort:     taskMap[v.TaskID].Sort,
		}
		if oneTask.Progress >= oneTask.Target && oneTask.Status != 2 {
			oneTask.Status = 1
		}
		ret = append(ret, oneTask)
	}

	sort.SliceStable(ret, func(i, j int) bool {
		return ret[i].Sort > ret[j].Sort
	})
	return
}

func GetPromotions(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	ret := &values.GetPromotionsResp{}
	a.Data = ret
	a.GetUID()
	ret.ActivityList = call.GetConfigActivityActiveAll(a.UID)
	ret.TaskList = GetUserTaskStatus(a)
	num := 0
	for _, task := range ret.TaskList {
		if task.Status == 1 {
			num++
		}
	}
	if num > 0 {
		//call.PushRed(a.UID, pb.RedPointModule_RedPointTask, uint32(num))
	}
}

func UploadActivityData(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.UploadActivityReq)
	if !a.S(req) {
		return
	}
	call.UploadActivityData(a.UID, req.ActivityID, common.ActivityDataClick, 0)
}

func GetAllActivity(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	ret := values.GetAllActivityResp{
		List: call.GetConfigActivityActiveAll(a.UID),
	}
	a.Data = ret
}

func GetActivityAppSpinInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDAppSpin) {
		return
	}
	resp := &values.ActivityAppSpinInfoResp{}
	a.Data = resp
	resp.List = call.GetConfigAppSpin()
}

func DrawActivityAppSpin(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDAppSpin) {
		return
	}
	pd := call.GetPlayerData(a.UID)
	if pd.LastAppSpinDraw > 0 {
		a.Code = values.CodeRetry
		return
	}
	total := 0
	list := call.GetConfigAppSpin()
	for _, v := range list {
		total += v.Weight
	}
	weight := rand.Intn(total)
	per := 0
	var win *common.ConfigAppSpin
	for _, v := range list {
		per += v.Weight
		if weight < per {
			win = v
			break
		}
	}
	if win == nil {
		a.Code = values.CodeRetry
		return
	}
	rows, err := db.Mysql().UpdateResW(&common.PlayerData{}, map[string]interface{}{"last_app_spin_draw": time.Now().Unix()}, fmt.Sprintf("uid = %v and last_app_spin_draw = 0", a.UID))
	if err != nil || rows == 0 {
		log.Error("err:%v", err)
		return
	}
	call.UpdateCurrencyPro(&common.UpdateCurrency{
		CurrencyBalance: &common.CurrencyBalance{
			UID:       a.UID,
			ChannelID: a.Channel,
			Type:      win.CurrencyType,
			Value:     win.Amount,
			Event:     common.CurrencyEventActivityAppSpin,
			NeedBet:   call.GetConfigCurrencyResourceNeedBet(common.CurrencyResourceBonus, win.Amount),
		},
	})
	call.UploadActivityData(a.UID, common.ActivityIDAppSpin, common.ActivityDataJoin, win.Amount)
	a.Data = values.ActivityAppSpinDrawResp{ID: win.ID}
}

func ActivityPddInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDPDD) {
		return
	}
	con := call.GetConfigActivityPdd()
	if con == nil {
		a.Code = values.CodeRetry
		return
	}
	resp := &values.ActivityPddInfoResp{WithdrawAmount: con.WithdrawAmount, Spin: 1}
	a.GetUID()
	pddData := &common.PddData{UID: a.UID}
	if pddData.UID > 0 {
		pddData = call.GetAcitivityPddData(pddData.UID)
		if pddData == nil {
			a.Code = values.CodeRetry
			return
		}
		resp.Spin = pddData.Spin
		resp.Amount = pddData.Amount
		channel := call.GetChannelByID(a.Channel)
		if channel != nil {
			resp.ShareLink = channel.URL + "?code=" + call.GetShareInfo(a.UID).Share
		}
		resp.Expire = con.Expire*60 + pddData.Time - time.Now().Unix()
		resp.NewPddShare = call.HasNewAcitivityPddShare(a.UID)
	}

	list := call.GetConfigActivityPddSpinByAmount(pddData.Amount)
	for _, v := range list {
		resp.Items = append(resp.Items, values.OnePddSpinItem{
			ID:     v.ID,
			Type:   v.Type,
			Amount: v.Amount,
			Sort:   v.Sort,
		})
	}
	a.Data = resp
}

func ActivityPddSpin(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDPDD) {
		return
	}
	con := call.GetConfigActivityPdd()
	if con == nil {
		a.Code = values.CodeRetry
		return
	}
	pddData := call.GetAcitivityPddData(a.UID)
	if pddData == nil {
		a.Code = values.CodeRetry
		return
	}
	now := time.Now().Unix()
	todaySpin := util.IsSameDayTimeStamp(now, pddData.FreeSpinTime)
	if pddData.Spin <= 0 {
		a.Code = values.CodeParam
		return
	}
	if pddData.Amount >= con.WithdrawAmount {
		a.Code = values.CodeParam
		a.Msg = "You can withdraw now."
		return
	}
	items := call.GetConfigActivityPddSpinByAmount(pddData.Amount)
	var bingo *common.ConfigActivityPddSpin
	var amount int64
	if pddData.Amount == 0 { // 第一次转
		for _, v := range items {
			if v.Type == common.ActivityPddItemTypeRandomCash {
				bingo = v
				break
			}
		}

		if bingo == nil {
			a.Code = values.CodeRetry
			return
		}

		diff := con.AmountUp - con.AmountDown
		if diff > 0 {
			amount = rand.Int63n(con.AmountUp-con.AmountDown) + con.AmountDown
		}
	} else {
		totalWeight := 0
		for _, v := range items {
			totalWeight += v.Weight
		}
		if totalWeight == 0 {
			a.Code = values.CodeRetry
			return
		}

		thisWeight := 0
		rans := rand.Intn(totalWeight)
		for _, v := range items {
			thisWeight += v.Weight
			if rans < thisWeight {
				bingo = v
				break
			}
		}
		if bingo == nil {
			a.Code = values.CodeRetry
			return
		}

		amount = bingo.Amount
		if bingo.Type == common.ActivityPddItemTypeRandomCash {
			diff := bingo.CashUp - bingo.CashDown
			if diff > 0 {
				amount = rand.Int63n(diff) + bingo.CashDown
			}
		}
	}

	if amount == 0 {
		a.Code = values.CodeRetry
		return
	}

	update := map[string]interface{}{}
	sql := ""
	// 今天旋转过则扣除已有旋转次数
	if todaySpin {
		update["spin"] = gorm.Expr("spin - 1")
		sql = fmt.Sprintf("uid = %d and spin >= 1 and amount = %d", a.UID, pddData.Amount)
	} else {
		update["free_spin_time"] = now
		sql = fmt.Sprintf("uid = %d and free_spin_time = %d ", a.UID, pddData.FreeSpinTime)
	}

	// ok
	switch bingo.Type {
	case common.ActivityPddItemTypeFinish:
		update["amount"] = con.WithdrawAmount
	case common.ActivityPddItemTypeCash:
		if pddData.Amount+amount > con.WithdrawAmount {
			update["amount"] = con.WithdrawAmount
		} else {
			update["amount"] = gorm.Expr("amount + ?", amount)
		}
	case common.ActivityPddItemTypeRandomCash:
		if pddData.Amount+amount > con.WithdrawAmount {
			update["amount"] = con.WithdrawAmount
		} else {
			update["amount"] = gorm.Expr("amount + ?", amount)
		}
	}

	rows, err := db.Mysql().UpdateResW(&common.PddData{}, update, sql)
	if err != nil {
		log.Error("err:%v", err)
		a.Code = values.CodeRetry
		return
	}
	if rows == 0 {
		a.Code = values.CodeRetry
		return
	}
	resp := &values.ActivityPddSpinResp{
		ID:     bingo.Sort,
		Amount: amount,
	}
	a.Data = resp
}

func ActivityPddWithdraw(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDPDD) {
		return
	}
	con := call.GetConfigActivityPdd()
	if con == nil {
		a.Code = values.CodeRetry
		return
	}
	pddData := call.GetAcitivityPddData(a.UID)
	if pddData == nil {
		a.Code = values.CodeRetry
		return
	}
	if pddData.Amount < con.WithdrawAmount {
		a.Code = values.CodeParam
		return
	}
	// 转走并重置玩家pdd活动
	spinCount := 1
	if !config.GetBase().Release {
		spinCount = 100
	}
	rows, err := db.Mysql().UpdateResW(&common.PddData{}, map[string]interface{}{"amount": 0, "spin": spinCount, "time": time.Now().Unix(), "free_spin_time": 0},
		fmt.Sprintf("uid = %d and amount >= %d", a.UID, con.WithdrawAmount))
	if err != nil {
		log.Error("err:%v", err)
		a.Code = values.CodeRetry
		return
	}
	if rows == 0 {
		a.Code = values.CodeRetry
		return
	}
	call.UpdateCurrencyPro(&common.UpdateCurrency{
		CurrencyBalance: &common.CurrencyBalance{
			UID:     a.UID,
			Value:   con.WithdrawAmount,
			Type:    common.CurrencyINR,
			Event:   common.CurrencyEventActivityPdd,
			NeedBet: call.GetConfigCurrencyResourceNeedBet(common.CurrencyResourceBonus, con.WithdrawAmount),
		},
	})
	call.UploadActivityData(a.UID, common.ActivityIDPDD, common.ActivityDataJoin, con.WithdrawAmount)
	a.Data = values.ActivityPddWithdrawResp{ExpireTime: con.Expire * 60}
}

func ActivityPddNewReference(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDPDD) {
		return
	}
	con := call.GetConfigActivityPdd()
	if con == nil {
		a.Code = values.CodeRetry
		return
	}
	resp := &values.ActivityPddNewReferenceResp{}
	a.Data = resp
	pddData := call.GetAcitivityPddData(a.UID)
	if pddData == nil {
		return
	}
	list := []common.ESPddRecord{}
	q := elastic.NewBoolQuery()
	t := pddData.Time
	if pddData.NewRecordTime > 0 {
		t = pddData.NewRecordTime
	}
	q.Filter(elastic.NewTermQuery("Referer", a.UID))
	q.Filter(elastic.NewRangeQuery("Time").Gte(t))
	db.ES().QueryList(common.ESIndexBackPddRecord, 0, 5000, q, &list, "Time", false)
	for _, v := range list {
		resp.List = append(resp.List, values.OnePddRecord{
			UID:       v.UID,
			Avatar:    v.Avatar,
			Nick:      v.Nick,
			Time:      v.Time,
			SpinCount: 1,
		})
	}
	resp.NewCount = len(list)
	resp.NewSpinCount = len(list)
	resp.SpinLeft = pddData.Spin
	db.Mysql().Update(&common.PddData{UID: a.UID}, map[string]interface{}{"new_record_time": time.Now().Unix()})
}

func ActivityPddReference(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDPDD) {
		return
	}
	req := new(values.ActivityPddReferenceReq)
	if !a.S(req) {
		return
	}
	resp := &values.ActivityPddReferenceResp{}
	a.Data = resp
	pddData := call.GetAcitivityPddData(a.UID)
	if pddData == nil {
		return
	}
	list := []common.ESPddRecord{}
	q := elastic.NewBoolQuery()
	q.Filter(elastic.NewRangeQuery("Time").Gte(pddData.Time))
	db.ES().QueryList(common.ESIndexBackPddRecord, req.Page, req.Num, q, &list, "Time", false)
	for _, v := range list {
		resp.List = append(resp.List, values.OnePddRecord{
			UID:       v.UID,
			Avatar:    v.Avatar,
			Nick:      v.Nick,
			Time:      v.Time,
			SpinCount: 1,
		})
	}
}

func ActivityFreeSpinInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDFreeSpin) {
		return
	}
	con := call.GetConfigActivityFreeSpin()
	if con == nil {
		a.Code = values.CodeRetry
		return
	}
	resp := &values.ActivityFreeSpinInfoResp{
		List:      con,
		NewReward: config.GetConfig().Web.FreeSpinFirst,
	}
	a.Data = resp
	a.GetUID()
	if a.UID > 0 {
		freeSpin := call.GetUserFreeSpinData(a.UID)
		if freeSpin.LastSpin == 0 && freeSpin.SpinNum == 0 {
			now := time.Now().Unix()
			p, _ := call.GetUserXInfo(a.UID, "birth")
			data := &common.ActivityFreeSpinData{UID: a.UID, SpinNum: common.DefaultFreeSpinNum}
			if !util.IsSameDayTimeStamp(now, p.Birth) {
				resp.Count = data.SpinNum
			}
			// } else {
			// 	data.LastSpin = now
			// }
			db.Mysql().Create(data)
			resp.Count = data.SpinNum
		} else if !util.IsSameDayTimeStamp(time.Now().Unix(), freeSpin.LastSpin) {
			resp.Count = common.DefaultFreeSpinNum
			_, err := db.Mysql().UpdateRes(&common.ActivityFreeSpinData{UID: a.UID, LastSpin: freeSpin.LastSpin},
				map[string]interface{}{"spin_num": common.DefaultFreeSpinNum})
			if err != nil {
				log.Error("ActivityFreeSpinInfo err:%v", err)
			}
		} else {
			resp.Count = freeSpin.SpinNum
		}
	} else {
		resp.Count = common.DefaultFreeSpinNum
	}
	if resp.Count > 0 {
		// call.PushRed(a.UID, pb.RedPointModule_RedPointSign, 1)
	}
}

func ActivityFreeSpinDraw(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDFreeSpin) {
		return
	}
	freeSpin := call.GetUserFreeSpinData(a.UID)
	if freeSpin.SpinNum <= 0 {
		a.Code = values.CodeRetry
		return
	}

	resp := &values.ActivityFreeSpinDrawResp{}
	a.Data = resp

	con := call.GetConfigActivityFreeSpin()
	if con == nil {
		a.Code = values.CodeRetry
		return
	}
	total := 0
	for _, v := range con {
		total += v.Weight
	}
	ran := rand.Intn(total)
	rans := 0
	for _, v := range con {
		rans += v.Weight
		if ran < rans {
			resp.ID = v.ID
			resp.Reward = v.Amount
			if v.Type == common.ActivityFreeSpinItemRandomCash {
				resp.Reward = rand.Int63n(v.CashUp-v.CashDown) + v.CashDown
			}
			rows, err := db.Mysql().UpdateRes(&common.ActivityFreeSpinData{UID: a.UID, LastSpin: freeSpin.LastSpin},
				map[string]interface{}{"last_spin": time.Now().Unix(), "spin_num": gorm.Expr("spin_num - ?", 1)})
			if rows == 0 || err != nil {
				a.Code = values.CodeRetry
				return
			}
			if v.Type == common.ActivityFreeSpinItemNone {
				return
			}
			_, err = call.UpdateCurrencyPro(&common.UpdateCurrency{
				CurrencyBalance: &common.CurrencyBalance{
					Type:      common.CurrencyINR,
					UID:       a.UID,
					Event:     common.CurrencyEventActivityFreeSpin,
					Value:     resp.Reward,
					ChannelID: a.Channel,
					NeedBet:   call.GetConfigCurrencyResourceNeedBet(common.CurrencyResourceBonus, resp.Reward),
				},
			})
			if err != nil {
				a.Code = values.CodeRetry
				return
			}
			break
		}
	}
	call.UploadActivityData(a.UID, common.ActivityIDFreeSpin, common.ActivityDataJoin, resp.Reward)
}

func ActivityFirstRechargeBackInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	a.GetUID()
	if !a.CheckActivityExpire(common.ActivityIDFirstRechargeBack) {
		return
	}
	resp := &values.ActivityFirstRechargeBackInfoResp{}
	conf := call.GetConfigActivityFirstRechargeBack()
	a.Data = resp
	data := call.GetUserFirstRechargeBackData(a.UID)
	rechargeInfo := call.GetRechargeInfo(a.UID)
	resp.MinRechargeAmount = conf.MinRecharge
	resp.TotalRechargeAmount = rechargeInfo.TotalRecharge
	resp.BackPer = conf.MaxBack
	resp.RechargeAmount = data.Amount
	p, _ := call.GetUserXInfo(a.UID, "birth")
	now := time.Now()
	if v := p.Birth + conf.CD - now.Unix(); v > 0 {
		resp.Countdown = v
	}
	if resp.MinRechargeAmount > resp.TotalRechargeAmount { // 未解锁给默认值
		resp.BackAmount = 6528600 + call.GetFirstRechargeBackSumAmount()
	}
	if data.RechargeTime == 0 { // 无充值
		return
	}
	if data.RewardTime > 0 { // 已领取
		resp.Draw = 2
		return
	}
	if data.Reward == 0 { // 计算奖励
		val := data.Amount - call.GetUserCurrencyTotal(a.UID, common.CurrencyINR) - rechargeInfo.TotalWithdraw - rechargeInfo.WithdrawingCash
		if val < 0 {
			val = 0
		}
		val = val * conf.MaxBack / 100
		resp.BackAmount = val
		if resp.Countdown == 0 { // 活动结束更新奖励
			update := map[string]interface{}{
				"reward": val,
			}
			if val == 0 {
				update["reward_time"] = now.Unix()
			}
			db.Mysql().Update(&common.ActivityFirstRechargeBackData{UID: a.UID}, update)
		}
	} else {
		resp.BackAmount = data.Reward
	}
	if resp.Countdown == 0 && resp.BackAmount > 0 {
		resp.Draw = 1
	}
	if resp.Draw == 1 {
		//call.PushRed(a.UID, pb.RedPointModule_RedPointFirstRecharge, 1)
	}
	return
}

func ActivityFirstRechargeBackDraw(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDFirstRechargeBack) {
		return
	}
	if !db.Redis().Lock(common.GetRedisKeyFirstRechargeBack(a.UID)) {
		a.Code = values.CodeRetry
		return
	}
	defer func() {
		db.Redis().UnLock(common.GetRedisKeyFirstRechargeBack(a.UID))
	}()
	resp := new(values.ActivityFirstRechargeBackDrawResp)
	a.Data = resp
	conf := call.GetConfigActivityFirstRechargeBack()
	data := call.GetUserFirstRechargeBackData(a.UID)
	p, _ := call.GetUserXInfo(a.UID, "birth")
	now := time.Now()
	if now.Unix()-p.Birth < conf.CD {
		log.Error("not ActivityFirstRechargeBackDraw time:%+v", data)
		a.Code = values.CodeRetry
		a.Msg = "Unarrived time"
		return
	}
	if data.RewardTime > 0 {
		a.Code = values.CodeRetry
		a.Msg = "Award claimed"
		return
	}
	rechargeInfo := call.GetRechargeInfo(a.UID)
	val := data.Amount - call.GetUserCurrencyTotal(a.UID, common.CurrencyINR) - rechargeInfo.TotalWithdraw - rechargeInfo.WithdrawingCash
	if val < 0 {
		val = 0
	}
	val = val * conf.MaxBack / 100
	rows, err := db.Mysql().UpdateRes(&common.ActivityFirstRechargeBackData{UID: a.UID}, map[string]interface{}{
		"reward_time": now.Unix(),
		"reward":      val,
	})
	if err != nil || rows == 0 {
		a.Code = values.CodeRetry
		return
	}
	_, err = call.UpdateCurrencyPro(&common.UpdateCurrency{
		CurrencyBalance: &common.CurrencyBalance{
			UID:       a.UID,
			ChannelID: a.Channel,
			Type:      common.CurrencyINR,
			Value:     val,
			Event:     common.CurrencyEventActivityFirstRechargeBack,
			NeedBet:   call.GetConfigCurrencyResourceNeedBet(common.CurrencyResourceDayBack, val),
		},
	})
	if err != nil {
		a.Code = values.CodeRetry
		return
	}
	resp.Reward = val
	call.UploadActivityData(a.UID, common.ActivityIDFirstRechargeBack, common.ActivityDataJoin, val)
	//call.PushRed(a.UID, pb.RedPointModule_RedPointFirstRecharge, 0)
}

// 幸运码活动
func ActivityLuckyCodeInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := new(values.ActivityLuckyCodeInfoReq)
	if !a.S(req) {
		return
	}

	if !a.CheckActivityExpire(common.ActivityIDLuckyCode) {
		return
	}
	t := req.Type
	if t == 0 {
		t = common.LuckyCodeTypeNormal
	} else {
		t = common.LuckyCodeTypeVip
	}
	resp := &values.ActivityLuckyCodeInfoResp{
		TelegramChannel: config.GetBase().Server.TelegramChannel,
	}
	a.Data = resp
	con := call.GetConfigAcitivityLuckyCode(t)
	total := call.GetConfigAcitivityLuckyCodeTotalWeight(t)
	for _, v := range con {
		resp.List = append(resp.List, values.OneActivityLuckyCodeConfig{
			ID:     v.ID,
			Reward: v.Reward,
			Per:    util.FormatFloat(float64(v.Per*100)/float64(total), 2) + "%",
		})
	}
}

func ActivityLuckyCodeDraw(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()

	if !a.CheckActivityExpire(common.ActivityIDLuckyCode) {
		return
	}
	req := new(values.ActivityLuckyCodeDrawReq)
	if !a.S(req) {
		return
	}
	resp := &values.ActivityLuckyCodeDrawResp{}
	a.Data = resp

	var reward int64

	// 判断是否为分享吗
	upShareInfo := call.GetShareInfoByCode(req.LuckyCode)
	if upShareInfo.ID > 0 {
		// 防止循环绑定
		if upShareInfo.UID == a.UID || a.UID == upShareInfo.UP1 || a.UID == upShareInfo.UP2 || a.UID == upShareInfo.UP3 {
			a.Code = values.CodeRetry
			a.Msg = "code error"
			return
		}
		shareInfo := call.GetShareInfo(a.UID)
		if shareInfo.UP1 > 0 {
			a.Code = values.CodeRetry
			a.Msg = "has binding"
			return
		}
		call.ShareBind(req.LuckyCode, true, a.UID, a.Channel)
		reward = call.GetConfigPlatform().ShareBindReward
		_, err := call.UpdateCurrencyPro(&common.UpdateCurrency{
			CurrencyBalance: &common.CurrencyBalance{
				UID:     a.UID,
				Type:    common.CurrencyINR,
				Value:   reward,
				Event:   common.CurrencyEventActivityShareBind,
				NeedBet: call.GetConfigCurrencyResourceNeedBet(common.CurrencyResourceBonus, reward),
			},
		})
		if err != nil {
			log.Error("err:%v", err)
			a.Code = values.CodeRetry
			a.Msg = "code error"
			return
		}
	} else {
		now := time.Now()
		code, err := strconv.Atoi(req.LuckyCode)
		if err != nil {
			a.Code = values.CodeParam
			a.Msg = "The code you entered is incorrect"
			return
		}
		luckyCode := &common.ActivityLuckyCode{Code: code, Date: now.Format("20060102")}
		err = db.Mysql().Get(&luckyCode)
		if err != nil {
			a.Code = values.CodeParam
			a.Msg = "The code you entered is incorrect"
			return
		}
		codeType := luckyCode.Type
		data := &common.ActivityLuckyCodeData{UID: a.UID}
		db.Mysql().Get(data)
		if (codeType == common.LuckyCodeTypeNormal && util.IsSameDayTimeStamp(now.Unix(), data.LastDraw)) ||
			(codeType == common.LuckyCodeTypeVip && util.IsSameDayTimeStamp(now.Unix(), data.LastVipDraw)) {
			a.Code = values.CodeParam
			a.Msg = "This code has already been used"
			return
		}
		// 开始发奖
		con := call.GetConfigAcitivityLuckyCode(codeType)
		total := call.GetConfigAcitivityLuckyCodeTotalWeight(codeType)
		if total == 0 {
			log.Error("con:%+v invalid,uid:%d", con, a.UID)
			a.Code = values.CodeParam
			a.Msg = "code error"
			return
		}
		if data.ID == 0 {
			codeData := &common.ActivityLuckyCodeData{UID: a.UID, Type: codeType}
			if codeType == common.LuckyCodeTypeNormal {
				codeData.LastDraw = now.Unix()
			} else if codeType == common.LuckyCodeTypeVip {
				codeData.LastVipDraw = now.Unix()
			}
			err := db.Mysql().Create(codeData)
			if err != nil {
				a.Code = values.CodeRetry
				return
			}
		} else {
			updates := map[string]interface{}{}
			if codeType == common.LuckyCodeTypeNormal {
				updates["last_draw"] = now.Unix()
			} else if codeType == common.LuckyCodeTypeVip {
				updates["last_vip_draw"] = now.Unix()
			}
			rows, err := db.Mysql().UpdateRes(&common.ActivityLuckyCodeData{UID: a.UID, LastDraw: data.LastDraw}, updates)
			if rows == 0 || err != nil {
				a.Code = values.CodeRetry
				return
			}
		}

		ran := rand.Int63n(total)
		var rans int64
		for _, v := range con {
			rans += v.Per
			if ran < rans {
				reward = v.Reward
				break
			}
		}
		_, err = call.UpdateCurrencyPro(&common.UpdateCurrency{
			CurrencyBalance: &common.CurrencyBalance{
				UID:     a.UID,
				Type:    common.CurrencyINR,
				Value:   reward,
				Event:   common.CurrencyEventActivityLuckyCode,
				Exs1:    fmt.Sprintf("%d", codeType),
				Exi1:    code,
				NeedBet: call.GetConfigCurrencyResourceNeedBet(common.CurrencyResourceBonus, reward),
			},
		})
		if err != nil {
			log.Error("err:%v", err)
			a.Code = values.CodeRetry
			a.Msg = "code error"
			return
		}
		call.UploadActivityData(a.UID, common.ActivityIDLuckyCode, common.ActivityDataJoin, reward)
	}

	resp.Reward = reward
}

// day 二进制从0位开始,实际签到日期需减1
func CanSign(sign, day int) bool {
	tmp := sign >> (day - 1)
	return tmp&1 == 0
}

func Sign(day int) int {
	ret := 0
	for i := 0; i < day; i++ {
		ret <<= 1
		ret |= 1
	}
	return ret
}

// GetSignDay 获取签到天数
func GetSignDay(sign int) (day int) {
	for i := 0; i < 7; i++ {
		if sign&1 == 1 {
			day++
		}
		sign >>= 1
	}
	return
}

// CanSignDays 返回可以签到的天数
func CanSignDays(sign, day int) (ret []int) {
	for i := 0; i < day; i++ {
		if sign&1 == 0 {
			ret = append(ret, i+1)
		}
		sign >>= 1
	}
	return
}

func GetSignInfo(uid int) (resp *values.ActivitySignInfoResp) {
	if !call.IsActivityValid(common.ActivityIDSign) {
		return
	}
	list := call.GetConfigActivitySign()
	if len(list) == 0 {
		return
	}
	resp = &values.ActivitySignInfoResp{List: list}
	if uid == 0 {
		resp.Day = 1
		resp.CanSign = true
		return
	}
	data := &common.ActivitySignData{UID: uid}
	db.Mysql().Get(data)
	if data.ID == 0 {
		user, _ := call.GetUserXInfo(uid, "birth")
		db.Mysql().Create(&common.ActivitySignData{UID: uid, Time: user.Birth})
		data.Time = user.Birth
	}
	resp.Sign = data.Sign
	first := util.GetZeroTime(time.Unix(data.Time, 0)).Unix()
	today := util.GetZeroTime(time.Now()).Unix()
	day := (today - first) / common.OneDay
	resp.Day = int(day) + 1

	if resp.Day > list[len(list)-1].Day {
		resp.Day = list[len(list)-1].Day
		return
	}

	// 说明已签到过,不需要再判断
	if !CanSign(resp.Sign, resp.Day) {
		return
	}
	resp.CanSign = true
	for _, v := range resp.List {
		if v.Day == resp.Day {
			if v.Recharge > 0 {
				re := call.GetRechargeInfo(uid)
				if re.DayRecharge < v.Recharge {
					resp.CanSign = false
				}
			}
			break
		}
	}
	return
}

func ActivitySignInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDSign) {
		return
	}
	a.GetUID()
	resp := GetSignInfo(a.UID)
	if resp == nil {
		a.Code = values.CodeRetry
		return
	}
	a.Data = resp

}

func ActivitySignDraw(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDSign) {
		return
	}
	list := call.GetConfigActivitySign()
	if len(list) == 0 {
		a.Code = values.CodeRetry
		return
	}
	data := &common.ActivitySignData{UID: a.UID}
	db.Mysql().Get(data)
	if data.ID == 0 {
		user, _ := call.GetUserXInfo(a.UID, "birth")
		db.Mysql().Create(&common.ActivitySignData{UID: a.UID, Time: user.Birth})
		data.Time = user.Birth
	}
	first := util.GetZeroTime(time.Unix(data.Time, 0)).Unix()
	today := util.GetZeroTime(time.Now()).Unix()
	day := int((today-first)/common.OneDay) + 1
	// 最大签到天数
	if day > list[len(list)-1].Day {
		a.Code = values.CodeRetry
		return
	}

	// if !CanSign(data.Sign, day) {
	// 	a.Code = values.CodeParam
	// 	return
	// }
	days := CanSignDays(data.Sign, day)
	log.Debug("uid:%v,data.Sign:%v,day:%v,days:%v", a.UID, data.Sign, day, days)
	if len(days) == 0 {
		a.Code = values.CodeParam
		a.Msg = "Check-in repetido."
		return
	}
	var reward int64
	for _, v := range list {
		if util.SliceContain(days, v.Day) {
			reward += v.Reward
			if v.Day == day {
				if v.Recharge > 0 {
					re := call.GetRechargeInfo(a.UID)
					if re.DayRecharge < v.Recharge {
						a.Code = values.CodeParam
						return
					}
				}
				break
			}
		}
	}
	if reward == 0 {
		a.Code = values.CodeRetry
		return
	}
	// ok
	newSign := Sign(day)
	rows, err := db.Mysql().UpdateRes(&common.ActivitySignData{UID: a.UID, Sign: data.Sign}, map[string]interface{}{"sign": newSign})
	if rows == 0 || err != nil {
		log.Error("err:%v", err)
		a.Code = values.CodeRetry
		return
	}
	_, err = call.UpdateCurrencyPro(&common.UpdateCurrency{
		CurrencyBalance: &common.CurrencyBalance{
			UID:       a.UID,
			Type:      common.CurrencyINR,
			ChannelID: a.Channel,
			Value:     reward,
			Event:     common.CurrencyEventActivitySign,
			NeedBet:   call.GetConfigCurrencyResourceNeedBet(common.CurrencyResourceBonus, reward),
		},
	})
	if err != nil {
		log.Error("err:%v", err)
		a.Code = values.CodeRetry
		return
	}
	a.Data = values.ActivitySignDrawResp{Reward: reward, Day: day, Sign: newSign}
	call.UploadActivityData(a.UID, common.ActivityIDSign, common.ActivityDataJoin, reward)
}

func GetSignNewInfo(uid int) (resp *values.ActivitySignInfoResp) {
	if !call.IsActivityValid(common.ActivityIDSign) {
		return
	}
	data := &common.ActivitySignData{UID: uid}
	if uid > 0 {
		db.Mysql().Get(data)
		if data.ID == 0 {
			user, _ := call.GetUserXInfo(uid, "birth")
			data.Wheel = 1
			db.Mysql().Create(&common.ActivitySignData{UID: uid, Time: user.Birth})
			data.Time = user.Birth
		}
	} else {
		data.Wheel = 1
	}
	list := call.GetConfigActivitySignByWheel(data.Wheel)
	if len(list) == 0 {
		return
	}
	resp = &values.ActivitySignInfoResp{List: list}
	if uid == 0 {
		resp.Day = 1
		resp.CanSign = true
		return
	}
	re := call.GetRechargeInfo(uid)
	playerData := call.GetPlayerData(uid)
	resp.RewardCount = data.Reward
	resp.LatestSignTime = data.SignTime
	resp.Recharge = re.DayRecharge
	resp.Bet = playerData.DayBet
	signDay := GetSignDay(data.Sign)
	resp.Sign = 7*(data.Wheel-1) + signDay
	resp.Day = signDay + 1
	now := time.Now()
	if data.Finish || util.IsSameDayTimeStamp(now.Unix(), data.SignTime) {
		for _, v := range resp.List {
			if v.Day == signDay && data.Wheel >= v.WheelStart && data.Wheel <= v.WheelEnd {
				resp.Recharge = v.Recharge
				resp.Bet = v.Bet
				break
			}
		}
	}
	if util.IsSameDayTimeStamp(now.Unix(), data.SignTime) {
		return
	}
	if resp.Day > 7 {
		if len(call.GetConfigActivitySignByWheel(data.Wheel+1)) > 0 {
			if err := db.Mysql().Update(&common.ActivitySignData{UID: data.UID}, map[string]interface{}{"sign": 0, "wheel": gorm.Expr("wheel + ?", 1)}); err != nil {
				log.Error("err:%v", err)
				resp.CanSign = false
				return
			}
			resp.Sign = 7 * (data.Wheel)
			resp.Day = 1
		}
	}
	resp.CanSign = true
	if !data.Finish {
		for _, v := range resp.List {
			if v.Day == resp.Day && data.Wheel >= v.WheelStart && data.Wheel <= v.WheelEnd {
				if re.DayRecharge < v.Recharge || playerData.DayBet < v.Bet {
					resp.CanSign = false
				} else {
					// 更新状态
					if err := db.Mysql().Update(&common.ActivitySignData{UID: data.UID}, map[string]interface{}{"finish": true}); err != nil {
						log.Error("err:%v", err)
						resp.CanSign = false
					}
				}
				break
			}
		}
	}

	return
}

func ActivitySignNewInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDSign) {
		return
	}
	a.GetUID()
	resp := GetSignNewInfo(a.UID)
	if resp == nil {
		a.Code = values.CodeRetry
		a.Msg = "पात्रता को पूरा न करें"
		return
	}
	call.UploadActivityData(a.UID, common.ActivityIDSign, common.ActivityDataClick, 0)
	num := 0
	if resp.CanSign {
		num = 1
	}
	if num > 0 {
		//call.PushRed(a.UID, pb.RedPointModule_RedPointSign, uint32(num))
	}
	a.Data = resp
}

func ActivitySignNewDraw(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDSign) {
		return
	}
	data := &common.ActivitySignData{UID: a.UID}
	db.Mysql().Get(data)
	if data.ID == 0 {
		user, _ := call.GetUserXInfo(a.UID, "birth")
		db.Mysql().Create(&common.ActivitySignData{UID: a.UID, Time: user.Birth})
		data.Time = user.Birth
	}
	list := call.GetConfigActivitySignByWheel(data.Wheel)
	if len(list) == 0 {
		a.Code = values.CodeRetry
		a.Msg = "शर्तों को पूरा नहीं किया जाता है"
		return
	}
	now := time.Now()
	if util.IsSameDayTimeStamp(now.Unix(), data.SignTime) {
		// 已经签到
		a.Code = values.CodeParam
		a.Msg = "आज में हस्ताक्षर किए"
		return
	}

	// 获取签到了几天
	day := GetSignDay(data.Sign) + 1
	var reward int64
	for _, v := range list {
		if v.Day == day {
			reward = v.Reward
			re := call.GetRechargeInfo(a.UID)
			playerData := call.GetPlayerData(a.UID)
			if re.DayRecharge < v.Recharge || playerData.DayBet < v.Bet {
				a.Code = values.CodeParam
				a.Msg = "शर्तों को पूरा नहीं किया जाता है"
				log.Error("uid:%v,conf:%v", a.UID, v)
				return
			}
			break
		}
	}
	if reward == 0 {
		a.Code = values.CodeRetry
		log.Error("reward == 0")
		return
	}

	// ok
	newSign := Sign(day)
	updates := map[string]interface{}{"sign": newSign, "finish": false, "reward": gorm.Expr("reward + ?", reward)}
	updates["sign_time"] = now.Unix()
	rows, err := db.Mysql().UpdateRes(&common.ActivitySignData{UID: a.UID, Sign: data.Sign}, updates)
	if rows == 0 || err != nil {
		log.Error("err:%v", err)
		a.Code = values.CodeRetry
		return
	}
	_, err = call.UpdateCurrencyPro(&common.UpdateCurrency{
		CurrencyBalance: &common.CurrencyBalance{
			UID:       a.UID,
			Type:      common.CurrencyINR,
			ChannelID: a.Channel,
			Value:     reward,
			Event:     common.CurrencyEventActivityBetDraw,
			NeedBet:   call.GetConfigCurrencyResourceNeedBet(common.CurrencyResourceBonus, reward),
		},
	})
	if err != nil {
		log.Error("err:%v", err)
		a.Code = values.CodeRetry
		return
	}
	a.Data = values.ActivitySignDrawResp{Reward: reward, Day: day, Sign: newSign}
	call.UploadActivityData(a.UID, common.ActivityIDSign, common.ActivityDataJoin, reward)
	//call.PushRed(a.UID, pb.RedPointModule_RedPointSign, uint32(0))
}

// 破产礼包活动
func ActivityBreakGiftInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDBreakGift) {
		return
	}
	resp := &values.ActivityBreakGiftInfoResp{}
	limit := config.GetConfig().Web.BreakLimit
	if limit <= 0 {
		limit = 1 * common.DecimalDigits
	}
	if call.GetUserCurrency(a.UID, common.CurrencyINR) > limit {
		return
	}
	payData := call.GetPlayerPayData(a.UID)
	re := call.GetRechargeInfo(a.UID)
	con := call.GetConfigActivityBreakGiftByRecharge(re.TotalRecharge, payData)
	log.Debug("con:%+v,total:%v", con, re.TotalRecharge)
	if con == nil {
		return
	}
	if util.SliceContain(payData.SubBreakGift, con.Level) {
		return
	}

	product := call.GetConfigPayProductByID(con.ProductID)
	log.Debug("product:%+v", product)
	if product == nil {
		a.Code = values.CodeRetry
		return
	}
	resp.Amount = product.Amount
	resp.Reward = product.Value
	resp.ProductID = con.ProductID
	resp.CountDown = con.CountDown
	a.Data = resp
}

func ActivitySlotsInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDSlots) {
		return
	}
	resp := &values.ActivitySlotsResp{ActivityID: common.ActivityIDSlots}
	a.Data = resp
	isSingle := call.IsActivitySingleDay(common.ActivityIDSlots)
	for _, v := range values.ActivitySlotsRank {
		one := &values.OneActivitySlotsRank{
			UID:    v.UID,
			Avatar: v.Avatar,
			Nick:   v.Nick,
		}
		if v.Avatar == "" || v.Nick == "" {
			p, _ := call.GetUserXInfo(v.UID, "mobile", "avatar")
			v.Avatar = p.Avatar
			v.Nick = p.Mobile
		}
		one.Nick = "*******" + v.Nick[len(v.Nick)-3:]
		if isSingle {
			one.Number = v.BestNumber1
		} else {
			one.Number = v.BestNumber2
		}
		resp.RankList = append(resp.RankList, one)
	}

	a.GetUID()
	if a.UID == 0 {
		return
	}

	data := call.GetUserActivitySlotsData(a.UID)
	resp.Spin = data.Spin
	if isSingle {
		if data.Time1 >= util.GetZeroTime(time.Now()).Unix() {
			resp.BestNumber = data.BestNumber1
		}
	} else {
		if data.Time2 >= util.GetZeroTime(time.Now()).Unix() {
			resp.BestNumber = data.BestNumber2
		}
	}
	lastDate := time.Now().AddDate(0, 0, -1).Format("20060102")
	record := &common.ActivitySlotsRecord{UID: a.UID, Date: lastDate}
	db.Mysql().Get(record)
	if record.ID > 0 {
		if record.Settle == 0 {
			resp.LastReward = &values.OneActivitySlotsLastReward{
				Rank:   record.Rank,
				Number: record.MyNumber,
				Reward: record.Reward,
				Draw:   record.Settle == 1,
			}
		}
	} else {
		// 查询昨天是否参与
		t := data.Time1
		number := data.BestNumber1
		if isSingle {
			t = data.Time2
			number = data.BestNumber2
		}
		if util.IsSameDayTimeStamp(t, time.Now().AddDate(0, 0, -1).Unix()) {
			resp.LastReward = &values.OneActivitySlotsLastReward{
				Number: number,
			}
		}
	}

	// 商品
	product := call.GetConfigPayProductByActivityID(common.ActivityIDSlots)
	if len(product) > 0 {
		resp.Product = values.OneActivitySlotsProduct{
			ProductID:    product[0].ProductID,
			OriginAmount: product[0].OriginAmount,
			Amount:       product[0].Amount,
			Reward:       product[0].Value,
			SpinCount:    product[0].Exi,
		}
	}

}

func ActivitySlotsDraw(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDSlots) {
		return
	}
	data := call.GetUserActivitySlotsData(a.UID)
	if data.Spin <= 0 {
		a.Code = values.CodeRetry
		return
	}
	resp := &values.ActivitySlotsDrawResp{}
	a.Data = resp
	/*
		真人玩家若充值大于200则每次抽奖会有75%的概率抽取到900-910之间的数字，25%的概率抽取到850—900以下的数字
		真人玩家若充值大于50则每次抽奖会有75%的概率抽取到850-900之间的数字，25%的概率抽取到850以下的数字
		充值小于50的真人玩家抽取到的数字只能小于850(暂定数字），随机选取
	*/
	re := call.GetRechargeInfo(a.UID)
	ran := rand.Intn(100)
	if re.DayRecharge >= 20000000000 {
		if ran < 75 {
			resp.Number = rand.Intn(11) + 900
		} else {
			resp.Number = rand.Intn(50) + 850
		}
	} else if re.DayRecharge >= 5000000000 {
		if ran < 75 {
			resp.Number = rand.Intn(50) + 850
		} else {
			resp.Number = rand.Intn(850)
		}
	} else {
		resp.Number = rand.Intn(850)
	}
	now := time.Now().Unix()

	t := data.Time2
	number := data.BestNumber2
	str := "best_number2"
	tstr := "time2"
	if call.IsActivitySingleDay(common.ActivityIDSlots) {
		t = data.Time1
		number = data.BestNumber1
		str = "best_number1"
		tstr = "time1"
	}
	u := map[string]interface{}{"spin": gorm.Expr("spin - 1"), tstr: now}

	if resp.Number > number || !util.IsSameDayTimeStamp(now, t) {
		u[str] = resp.Number
	}
	rows, err := db.Mysql().UpdateResW(&common.ActivitySlotsData{UID: a.UID}, u, fmt.Sprintf("uid = %d and %s = %d", a.UID, tstr, t))
	if err != nil || rows == 0 {
		a.Code = values.CodeRetry
		log.Error("err:%v", err)
		return
	}
	call.UploadActivityData(a.UID, common.ActivityIDSlots, 2, 0)
}

func ActivitySlotsDrawLast(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	lastDate := time.Now().AddDate(0, 0, -1).Format("20060102")
	record := &common.ActivitySlotsRecord{UID: a.UID, Date: lastDate}
	db.Mysql().Get(record)
	resp := &values.ActivitySlotsDrawLastResp{}
	a.Data = resp
	if record.ID == 0 || record.Settle == 1 {
		a.Code = values.CodeRetry
		return
	}
	rows, err := db.Mysql().UpdateResW(&common.ActivitySlotsRecord{}, map[string]interface{}{"settle": 1}, fmt.Sprintf("uid = %d and date = '%s' and settle = 0", a.UID, lastDate))
	if err != nil || rows == 0 {
		a.Code = values.CodeRetry
		return
	}
	if record.Reward == 0 {
		a.Code = values.CodeRetry
		return
	}
	call.UpdateCurrencyPro(&common.UpdateCurrency{
		CurrencyBalance: &common.CurrencyBalance{
			UID:     a.UID,
			Time:    time.Now().Unix(),
			Value:   record.Reward,
			Type:    common.CurrencyINR,
			Event:   common.CurrencyEventActivitySlots,
			NeedBet: call.GetConfigCurrencyResourceNeedBet(common.CurrencyResourceBonus, record.Reward),
		},
	})
	resp.Reward = record.Reward
	call.UploadActivityData(a.UID, common.ActivityIDSlots, 2, record.Reward)
}

func ActivityLuckyShopInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDLuckyShop) {
		return
	}
	resp := &values.ActivityLuckyShopResp{}
	a.Data = resp
	data := call.GetShowActivityLuckShopData(a.UID)
	if data == nil {
		return
	}
	if data.ProductID == 0 {
		return
	}
	product := call.GetConfigPayProductByID(data.ProductID)
	if product == nil {
		a.Code = values.CodeRetry
		return
	}
	if data.ID == 0 {
		db.Mysql().Create(data)
	}
	resp.Recharge = product.Amount
	resp.Value = product.Value
	resp.ProductID = product.ProductID
	resp.CountDown = common.ActivityLuckyShopExpire + data.Push - time.Now().Unix()
}

func ActivitySevenDayBoxInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDSevenDayBox) {
		return
	}
	resp := &values.ActivitySevenDayBoxInfoResp{}
	a.Data = resp
	re := call.GetRechargeInfo(a.UID)
	con := call.GetConfigActivitySevenDayBoxByRechargeAndType(re.TotalRecharge, common.ActivitySevenDayBoxTypeCash)
	if len(con) == 0 {
		return
	}
	var least int64 = -1
	var max int64 = -1
	for _, v := range con {
		if len(v.SubCashRange) == 2 {
			if v.SubCashRange[0] < least || least < 0 {
				least = v.SubCashRange[0]
			}
			if v.SubCashRange[1] > max {
				max = v.SubCashRange[1]
			}
		}
	}
	resp.ProductID = con[0].ProductID
	resp.RewardRange = []int64{least, max}
	data := &common.ActivitySevenDayBoxData{UID: a.UID}
	db.Mysql().Get(data)
	resp.Buy = !util.IsSameDayTimeStamp(data.Time, time.Now().Unix())
	resp.Open = data.Count > 0

	product := call.GetConfigPayProductByID(resp.ProductID)
	if product != nil {
		resp.Recharge = product.Amount
	}
}

func ActivitySevenDayBoxDraw(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	resp := &values.ActivitySevenDayBoxDrawResp{}
	a.Data = resp

	re := call.GetRechargeInfo(a.UID)
	cashCon := call.GetConfigActivitySevenDayBoxByRechargeAndType(re.TotalRecharge, common.ActivitySevenDayBoxTypeCash)
	discountCon := call.GetConfigActivitySevenDayBoxByRechargeAndType(re.TotalRecharge, common.ActivitySevenDayBoxTypeDiscountTicket)

	if len(cashCon) == 0 {
		a.Code = values.CodeRetry
		return
	}

	if len(discountCon) == 0 {
		a.Code = values.CodeRetry
		return
	}

	oneCash := cashCon[util.RandomOneEleFromSlice(cashCon, "Per")]
	oneDiscount := discountCon[util.RandomOneEleFromSlice(discountCon, "Per")]

	if len(oneCash.SubCashRange) != 2 {
		a.Code = values.CodeRetry
		return
	}

	data := &common.ActivitySevenDayBoxData{UID: a.UID}
	db.Mysql().Get(data)
	if data.Count <= 0 {
		a.Code = values.CodeRetry
		return
	}
	rows, err := db.Mysql().UpdateResW(&common.ActivitySevenDayBoxData{}, map[string]interface{}{"count": gorm.Expr("count - 1")},
		fmt.Sprintf("uid = %d and count = %d", a.UID, data.Count))
	if rows == 0 || err != nil {
		log.Error("err:%v", err)
		a.Code = values.CodeRetry
		return
	}

	var reward int64
	diff := oneCash.SubCashRange[1] - oneCash.SubCashRange[0]
	if diff <= 0 {
		reward = oneCash.SubCashRange[0]
	} else {
		diff /= common.DecimalDigits
		reward = rand.Int63n(diff)*common.DecimalDigits + oneCash.SubCashRange[0]
	}
	if reward > 0 {
		call.UpdateCurrencyPro(&common.UpdateCurrency{
			CurrencyBalance: &common.CurrencyBalance{
				UID:     a.UID,
				Event:   common.CurrencyEventActivityAppSpin,
				Type:    common.CurrencyINR,
				Value:   reward,
				NeedBet: call.GetConfigCurrencyResourceNeedBet(common.CurrencyResourceBonus, reward),
			},
		})
		resp.Reward = reward
		call.UploadActivityData(a.UID, common.ActivityIDSevenDayBox, common.ActivityDataJoin, reward)
	}
	if oneDiscount.Discount > 0 {
		// call.AddUserDiscountTicket(a.UID, oneDiscount.EmailDiscount)
		resp.Discount = oneDiscount.Discount
	}
}

func ActivitySuperInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDSuper) {
		return
	}
	resp := &values.ActivitySuperInfoResp{}
	a.Data = resp
	data := call.GetUserActivitySuperData(a.UID)
	con := call.GetConfigActivitySuperByType(data.Type)
	resp.Buy = data.CanBuy
	if len(con) > 0 {
		product := call.GetConfigPayProductByID(con[0].ProductID)
		if product != nil {
			resp.Recharge = product.Amount
			resp.ProductID = con[0].ProductID
		}
	}

	for i := 1; i <= 3; i++ {
		one := values.OneActivitySuperBox{
			Index: i,
		}
		if data.CanBuy { // 说明未付费
			one.Status = 0
		} else {
			tmp := data.Open >> (i - 1)
			if tmp&1 == 0 {
				one.Status = 1
			} else {
				one.Status = 2
			}
		}
		for _, v := range con {
			if v.Index != i {
				continue
			}
			one.Rewards = append(one.Rewards, values.ActivitySuperOneReward{
				RewardType: v.RewardType,
				Reward:     v.Reward,
			})
		}
	}
}

func ActivitySuperDraw(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDSuper) {
		return
	}
	req := new(values.ActivitySuperDrawReq)
	if !a.S(req) {
		return
	}
	if req.Index > 3 || req.Index < 1 {
		a.Code = values.CodeRetry
		return
	}
	data := call.GetUserActivitySuperData(a.UID)
	if data.Time == 0 { // 未购买
		a.Code = values.CodeRetry
		return
	}
	tmp := data.Open >> (req.Index - 1)
	if tmp&1 == 1 {
		a.Code = values.CodeParam
		a.Msg = "Coleta repetida."
		return
	}
	cons := call.GetConfigActivitySuperByTypeAndIndex(data.Type, req.Index)
	index := util.RandomOneEleFromSlice(cons, "Per")

	reward := cons[index]

	open := 1 << (req.Index - 1) & data.Open
	rows, err := db.Mysql().UpdateResW(&common.ActivitySuperData{}, map[string]interface{}{"open": open}, fmt.Sprintf("uid = %d and open = %d", a.UID, data.Open))
	if rows == 0 || err != nil {
		log.Error("err:%v", err)
		a.Code = values.CodeRetry
		return
	}
	// 发奖
	if reward.RewardType == 1 {
		call.UpdateCurrencyPro(&common.UpdateCurrency{
			CurrencyBalance: &common.CurrencyBalance{
				UID:     a.UID,
				Event:   common.CurrencyEventActivitySuper,
				Value:   reward.Reward,
				Type:    common.CurrencyINR,
				NeedBet: call.GetConfigCurrencyResourceNeedBet(common.CurrencyResourceBonus, reward.Reward),
			},
		})
		call.UploadActivityData(a.UID, common.ActivityIDSuper, 2, reward.Reward)
	} else {
		// call.AddUserDiscountTicket(a.UID, int(reward.Reward))
	}
	a.Data = &values.ActivitySuperDrawResp{
		Reward: values.ActivitySuperOneReward{
			RewardType: reward.RewardType,
			Reward:     reward.Reward,
		},
	}
}

func ActivityBetDrawInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDBetDraw) {
		return
	}
	a.GetUID()
	drawInfo := &common.ActivityBetDrawData{UID: a.UID}
	if a.UID > 0 {
		db.Mysql().Get(drawInfo)
		if drawInfo.ID == 0 {
			db.Mysql().Create(drawInfo)
		}
	}
	vipInfo := call.GetVIP(a.UID)
	confList := call.GetConfigBetDraw()
	resp := &values.ActivityBetDrawInfoResp{
		List:  confList,
		Lucky: drawInfo.Lucky,
	}
	a.Data = resp
	now := time.Now()
	update := false
	if !util.IsSameDayTimeStamp(drawInfo.SpinInfo.LastSpinTime, now.Unix()) {
		drawInfo.SpinInfo.SpinNum = 0
		update = true
	}
	if update && a.UID > 0 {
		db.Mysql().Update(&common.ActivityBetDrawData{UID: a.UID}, map[string]interface{}{
			"spin_info": drawInfo.SpinInfo,
		})
	}
	drawInfo.SpinInfo.SpinCount = confList[0].LimitNum
	resp.SpinInfo = append(resp.SpinInfo, drawInfo.SpinInfo)
	call.UploadActivityData(a.UID, common.ActivityIDBetDraw, common.ActivityDataClick, 0)
	for _, item := range resp.List {
		if resp.Lucky >= item.Cost && vipInfo.Level >= item.VipUnlock &&
			drawInfo.SpinInfo.SpinNum < drawInfo.SpinInfo.SpinCount &&
			now.Unix() >= drawInfo.SpinInfo.NextSpinTIme {
			//call.PushRed(a.UID, pb.RedPointModule_RedPointFreeSpin, uint32(1))
			break
		}
	}
}

func ActivityBetDrawDraw(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := values.ActivityBetDrawDrawReq{}
	if !a.S(&req) {
		return
	}
	if !a.CheckActivityExpire(common.ActivityIDBetDraw) {
		return
	}
	configList, weightList := call.GetConfigBetDrawByType(req.WheelType)
	if len(configList) == 0 {
		a.Code = values.CodeRetry
		return
	}
	conf := configList[0]
	drawInfo := common.ActivityBetDrawData{UID: a.UID}
	db.Mysql().Get(&drawInfo)
	now := time.Now()
	spinInfo := drawInfo.SpinInfo
	// step:判断cd
	if spinInfo.LastSpinTime != 0 && spinInfo.NextSpinTIme > now.Unix() {
		a.Code = values.CodeRetry
		a.Msg = "Unarrived spin time"
		return
	}
	if spinInfo.SpinNum >= conf.LimitNum {
		a.Code = values.CodeRetry
		a.Msg = "No spin times"
		return
	}
	if drawInfo.Lucky < conf.Cost {
		a.Code = values.CodeRetry
		a.Msg = "lucky not enough"
		return
	}
	// 计算权重
	idx := util.RandWeight(weightList)
	if idx < 0 {
		a.Code = values.CodeRetry
		return
	}
	rewardConf := configList[idx]
	reward := rewardConf.Reward
	spinInfo.LastSpinTime = time.Now().Unix()
	spinInfo.SpinNum += 1
	spinInfo.NextSpinTIme = spinInfo.LastSpinTime + conf.Cd
	err := db.Mysql().Update(&common.ActivityBetDrawData{
		UID: a.UID,
	}, map[string]interface{}{
		"lucky":     gorm.Expr("lucky - ?", conf.Cost),
		"spin_info": spinInfo,
	})
	if err != nil {
		a.Code = values.CodeRetry
		log.Error("ActivityBetDrawDraw err:%v", err)
		return
	}
	if reward > 0 {
		_, _ = call.UpdateCurrencyPro(&common.UpdateCurrency{
			CurrencyBalance: &common.CurrencyBalance{
				UID:     a.UID,
				Event:   common.CurrencyEventActivityAppSpin,
				Type:    common.CurrencyINR,
				Value:   reward,
				NeedBet: call.GetConfigCurrencyResourceNeedBet(common.CurrencyResourceBonus, reward),
			},
		})
	}

	call.UploadActivityData(a.UID, common.ActivityIDBetDraw, common.ActivityDataJoin, reward)
	db.ES().InsertToESGO(common.ESIndexBackBetDraw, common.ESActivityBetDraw{
		UID:    a.UID,
		Time:   time.Now().Unix(),
		Reward: reward,
		Type:   req.WheelType,
	})
	a.Data = &values.ActivityBetDrawDrawResp{
		Reward: reward,
	}

	drawInfo = common.ActivityBetDrawData{UID: a.UID}
	db.Mysql().Get(&drawInfo)

	//call.PushRed(a.UID, pb.RedPointModule_RedPointFreeSpin, uint32(0))
}

func ActivityBetDrawHistory(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	a.GetUID()
	req := values.ActivityBetDrawRecordReq{}
	if !a.S(&req) {
		return
	}
	resp := new(values.ActivityBetDrawRecordResp)
	if !a.CheckActivityExpire(common.ActivityIDBetDraw) {
		return
	}
	q := elastic.NewBoolQuery()
	q.Filter(elastic.NewTermQuery("Type", req.WheelType))
	_, _ = db.ES().QueryList(common.ESIndexBackBetDraw, req.Page-1, req.Num, q, &resp.RecordList, "Time", false)
	q.Filter(elastic.NewTermQuery("UID", a.UID))
	_, _ = db.ES().QueryList(common.ESIndexBackBetDraw, 0, 5000, q, &resp.SelfList, "Time", false)
	a.Data = resp
}

func ActivityPopup(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := values.ActivityPopupReq{}
	if !a.S(&req) {
		return
	}
	resp := new(values.ActivityPopupResp)
	a.Data = resp
	if req.JumpType == 0 {
		resp.List = call.GetConfigActivityPopup()
	} else {
		resp.List = call.GetConfigActivityPopupByType(req.JumpType)
	}
}

func DiscountTicketInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	resp := new(values.DiscountTicketResp)
	a.Data = resp
	list := call.GetUserValidItems(a.UID, common.ItemDiscountTicket)
	sort.Slice(list, func(i, j int) bool {
		return list[i].Exi2 > list[i].Exi2
	})
	currency := call.GetUserCurrency(a.UID, common.CurrencyINR)
	if len(list) > 0 && currency <= config.GetConfig().Web.BreakLimit {
		resp.Ticket = &values.DiscountTicketInfo{
			Amount:   list[0].Exi1,
			Discount: list[0].Exi2,
			Id:       int64(list[0].ID),
		}
	}
	resp.ChannelList = call.GetConfigPayChannelsByID(common.CurrencyINR)
}

func InviteRankInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	if !a.CheckActivityExpire(common.ActivityIDInviteRank) {
		return
	}
	a.GetUID()
	resp := new(values.InviteInfoResp)
	a.Data = resp
	resp.ActivityConf = call.GetConfigActivityByID(common.ActivityIDInviteRank)
	resp.RankInfoList = call.GetTopShareRank(call.RankNum)
	for idx, rankInfo := range resp.RankInfoList {
		if len(rankInfo.UserName) > 6 {
			rankInfo.UserName = rankInfo.UserName[:6]
			rankInfo.UserName = rankInfo.UserName[:3] + "***"
		}
		resp.RankInfoList[idx].UserName = "User" + rankInfo.UserName
	}
	resp.RewardRankConfig = call.GetConfigRobotRankReward()
	if a.UID > 0 {
		resp.MyRank = call.GetUserRank(a.UID)
	}
}