package luckdraw

import (
	"errors"
	"spaceofcheng/services/models"
	"spaceofcheng/services/models/model"
	"spaceofcheng/services/utils"
	"strconv"
	"strings"
	"time"

	"github.com/astaxie/beego"
	"github.com/go-xorm/xorm"
)

// LuckDrawDao 当前数据库操作对象
type LuckDrawDao struct {
	ctx *utils.Context
	db  *xorm.Session
}

// NewDAO 初始化DAO
func NewDAO(ctx *utils.Context) *LuckDrawDao {
	return &LuckDrawDao{
		ctx: ctx,
		db:  ctx.DB,
	}
}

// LuckDraw 抽奖记录
type LuckDraw struct {
	model.TaLuckdraw `xorm:"extends"`
	ActivityMainImg  string
	ActivityTitle    string
	ShareImg         string
	ShareContent     string
	Prizes           []model.TaLuckdrawPrize
	Imgs             []model.TaLuckdrawImg
}

type LuckInfo struct {
	model.TaLuckdrawRecord `xorm:"extends"`
	CustomerQrcode         string
}

// GetLuckDrawTpl 获取抽奖模板
func (m *LuckDrawDao) GetLuckDrawTpl(orgid string) ([]model.TaLuckdrawTpl, error) {
	var tpls []model.TaLuckdrawTpl
	err := m.db.Where("org_id=?", orgid).And("status=?", models.STATUS_NORMAL).Find(&tpls)
	return tpls, err
}

// GetLuckDrawList 获取抽奖列表
func (m *LuckDrawDao) GetLuckDrawList(caseids, name, status string, page, pageSize int) ([]model.TaLuckdraw, error) {
	var luckdraws []model.TaLuckdraw
	dao := m.db.Where("case_id in ('"+strings.Replace(caseids, ",", "','", -1)+"')").And("status<>?", models.STATUS_DEL)
	if name != "" {
		dao.And("name like '%" + name + "%'")
	}
	if status != "" {
		query := `status=?`
		switch status {
		case strconv.Itoa(models.STATUS_NORMAL):
			query = query + " and end_date>now()"
			break
		case strconv.Itoa(models.STATUS_EXPIRE):
			query = "(" + query + " or end_date<=now())"
		}
		dao.And(query, status)
	}
	err := dao.Desc("create_date").Limit(pageSize, (page-1)*pageSize).Find(&luckdraws)
	return luckdraws, err
}

// GetLuckDrawCount 获取抽奖列表count
func (m *LuckDrawDao) GetLuckDrawCount(caseids, name, status string) (int, error) {
	var luckdraws []model.TaLuckdraw
	dao := m.db.Where("case_id in ('"+strings.Replace(caseids, ",", "','", -1)+"')").And("status<>?", models.STATUS_DEL)
	if name != "" {
		dao.And("name like '%" + name + "%'")
	}
	if status != "" {
		dao.And("status=?", status)
	}
	err := dao.Find(&luckdraws)
	return len(luckdraws), err
}

// RecordWithPhone 抽奖记录
type RecordWithPhone struct {
	model.TaLuckdrawRecord `xorm:"extends"`
	CustomerName           string
	Phone                  string
	LuckDrawStatus         string
	Name                   string
}

// GetLuckDrawRecordCount 获取抽奖记录count
func (m *LuckDrawDao) GetLuckDrawRecordCount(id, tel string) (int, error) {
	var records []RecordWithPhone
	sql := `select a.*,b.customer_name,b.phone,b.name from ta_luckdraw_record a inner join ta_customer b on a.user_id=b.customer_id where a.luckdraw_id=?`
	if tel != "" {
		sql = sql + ` and b.phone=` + tel
	}

	err := m.db.Sql(sql, id).Find(&records)
	return len(records), err
}

// GetLuckDrawRecord 获取抽奖记录信息
func (m *LuckDrawDao) GetLuckDrawRecord(id, tel string, page, pageSize int) ([]RecordWithPhone, error) {
	var records []RecordWithPhone
	sql := `select a.*,b.customer_name,b.phone,b.name from ta_luckdraw_record a inner join ta_customer b on a.user_id=b.customer_id where a.luckdraw_id=?`
	if tel != "" {
		sql = sql + ` and b.phone=` + tel
	}
	sql = sql + ` ORDER BY a.create_date desc limit ` + strconv.Itoa((page-1)*pageSize) + `, ` + strconv.Itoa(pageSize)

	err := m.db.Sql(sql, id).Find(&records)
	return records, err
}

// GetLuckDrawRecordExcel 获取抽奖记录信息
func (m *LuckDrawDao) GetLuckDrawRecordExcel(id, tel string) ([]RecordWithPhone, error) {
	var records []RecordWithPhone
	sql := `select a.*,b.customer_name,b.phone,b.name from ta_luckdraw_record a inner join ta_customer b on a.user_id=b.customer_id where a.luckdraw_id=?`
	if tel != "" {
		sql = sql + ` and b.phone=` + tel
	}
	sql = sql + ` ORDER BY a.create_date desc `

	err := m.db.Sql(sql, id).Find(&records)
	return records, err
}

// GetLuckDrawShareCount 获取分享记录count
func (m *LuckDrawDao) GetLuckDrawShareCount(id, tel string) (int, error) {
	var shares []model.TaShareLuckyRecord
	dao := m.db.Where("luckydraw_id=?", id)
	if tel != "" {
		dao.And("from_customer_tel=?", tel)
	}

	err := dao.Find(&shares)
	return len(shares), err
}

// GetLuckDrawShare 获取分享记录信息
func (m *LuckDrawDao) GetLuckDrawShare(id, tel string, page, pageSize int) ([]model.TaShareLuckyRecord, error) {
	var shares []model.TaShareLuckyRecord
	dao := m.db.Where("luckydraw_id=?", id)
	if tel != "" {
		dao.And("from_customer_tel=?", tel)
	}

	err := dao.Desc("create_date").Limit(pageSize, (page-1)*pageSize).Find(&shares)
	return shares, err
}

// PrizeWithDefaults 奖品关联内定
type PrizeWithDefaults struct {
	model.TaLuckdrawPrize `xorm:"extends"`
	Defaults              []model.TaPrizeDefault
}

// LuckDrawInfo 抽奖info
type LuckDrawInfo struct {
	model.TaLuckdraw `xorm:"extends"`
	ActivityMainImg  string
	ActivityTitle    string
	ShareImg         string
	ShareContent     string
	Prizes           []PrizeWithDefaults
	Imgs             []model.TaLuckdrawImg
}

// GetLuckDrawInfoByID 获取抽奖信息
func (m *LuckDrawDao) GetLuckDrawInfoByID(id string) (*LuckDrawInfo, error) {
	if id == "" {
		return nil, errors.New("不存在抽奖信息！")
	}
	var luckdraw LuckDrawInfo
	sql := `SELECT
	a.*,
	b.activity_main_img,
	b.activity_title,
	b.share_img,
	b.share_content
FROM
	ta_luckdraw a
	LEFT JOIN ta_activity_share_info b ON a.id = b.activity_id 
	AND b.activity_type = '` + models.ACTIVITY_LUCK + `'
	WHERE a.id = '` + id + `'`
	beego.Error(sql)
	_, err := m.db.Sql(sql).Get(&luckdraw)
	if err != nil {
		return nil, err
	}

	if luckdraw.Id == "" {
		return nil, nil
	}
	prizes, err := m.GetPrizesWithDefaults(id)
	if err != nil {
		utils.LogError("获取奖品信息失败：", err)
		return nil, errors.New("获取奖品信息失败")
	}
	luckdraw.Prizes = prizes
	imgs, err := m.GetLuckDrawImgs(id)
	if err != nil {
		utils.LogError("获取抽奖图片信息失败：", err)
		return nil, errors.New("获取抽奖图片信息失败")
	}
	luckdraw.Imgs = imgs
	beego.Error(luckdraw)
	// defaults, err := m.GetLuckDrawDefault(id)
	// if err != nil {
	// 	utils.LogError("获取奖品内置信息失败：", err)
	// 	return nil, errors.New("获取奖品信息失败")
	// }
	// luckdraw.Defaults = defaults
	return &luckdraw, err
}

// GetLuckDrawImgs 获取抽奖图片
func (m *LuckDrawDao) GetLuckDrawImgs(luckdrawid string) ([]model.TaLuckdrawImg, error) {
	var imgs []model.TaLuckdrawImg
	err := m.db.Where("luckdraw_id=?", luckdrawid).Find(&imgs)
	return imgs, err
}

// GetLuckDrawDefault 获取奖品默认信息
func (m *LuckDrawDao) GetLuckDrawDefault(luckdrawid string) ([]model.TaPrizeDefault, error) {
	var defaults []model.TaPrizeDefault
	err := m.db.Where("luckdraw_id=?", luckdrawid).Find(&defaults)
	return defaults, err
}

// InsertLuckdraw 新增抽奖信息
func (m *LuckDrawDao) InsertLuckdraw(luckdraw model.TaLuckdraw) (*model.TaLuckdraw, error) {
	luckdraw.Id = utils.GetGUID()
	luckdraw.Status = models.STATUS_NORMAL
	luckdraw.CreateDate = time.Now()

	_, err := m.db.Insert(luckdraw)
	return &luckdraw, err
}

// DelLuckDrawDefault 删除抽奖默认信息
func (m *LuckDrawDao) DelLuckDrawDefault(luckdrawid string) error {
	sql := `delete from ta_prize_default where luckdraw_id=?`
	_, err := m.db.Exec(sql, luckdrawid)
	return err
}

// DelLuckDrawImgs 删除抽奖图片信息
func (m *LuckDrawDao) DelLuckDrawImgs(luckdrawid string) error {
	sql := `delete from ta_luckdraw_img where luckdraw_id=?`
	_, err := m.db.Exec(sql, luckdrawid)
	return err
}

// DelLuckDrawPrize 删除奖品信息
func (m *LuckDrawDao) DelLuckDrawPrize(luckdrawid string) error {
	sql := `delete from ta_prize_detail where prize_id in (select id from ta_luckdraw_prize where luckdraw_id=?)`
	_, err := m.db.Exec(sql, luckdrawid)
	if err != nil {
		return err
	}
	sql = `delete from ta_luckdraw_prize where luckdraw_id=?`
	_, err = m.db.Exec(sql, luckdrawid)
	return err
}

// DelLuckDrawSet 删除抽奖设置信息
func (m *LuckDrawDao) DelLuckDrawSet(luckdrawid string) error {
	sql := `delete from ta_luckdraw_customer where luckdraw_id=?`
	_, err := m.db.Exec(sql, luckdrawid)
	return err
}

// SaveLuckDrawImgs 保存抽奖图片
func (m *LuckDrawDao) SaveLuckDrawImgs(imgs []model.TaLuckdrawImg, luckdrawid string) error {
	for inx, img := range imgs {
		if img.ImgId == "" {
			imgs[inx].ImgId = utils.GetGUID()
			org := m.ctx.Get("org").(model.SysOrg)
			imgs[inx].OrgId = org.OrgId
			imgs[inx].Status = models.STATUS_NORMAL
			imgs[inx].LuckdrawId = luckdrawid
		}
	}
	_, err := m.db.Insert(imgs)
	return err
}

// SaveLuckDrawDefault 保存内定信息
func (m *LuckDrawDao) SaveLuckDrawDefault(defaults []model.TaPrizeDefault, prize model.TaLuckdrawPrize) error {
	for inx, d := range defaults {
		if d.DefaultId == "" {
			defaults[inx].DefaultId = utils.GetGUID()
			defaults[inx].Status = models.STATUS_NORMAL
			defaults[inx].CreateDate = time.Now()
			defaults[inx].LuckdrawId = prize.LuckdrawId
			defaults[inx].PrizeId = prize.Id
		}
	}
	_, err := m.db.Insert(defaults)
	return err
}

// SaveLuckDrawPrizes 保存奖品信息
func (m *LuckDrawDao) SaveLuckDrawPrizes(prizes []PrizeWithDefaults, luckdraw *model.TaLuckdraw) error {
	var saveprizes []model.TaLuckdrawPrize
	for inx, prize := range prizes {
		if prize.Id == "" {
			prizes[inx].LuckdrawId = luckdraw.Id
			prizes[inx].Id = utils.GetGUID()
		}
		prizes[inx].Remainder = prize.Stock
		prizes[inx].Status = models.STATUS_NORMAL

		if prize.PrizeType == models.PRIZE_TYPE_COUPONCARD {
			valid, err := m.SavePrizeDetail(prizes[inx].TaLuckdrawPrize)
			if err != nil {
				return err
			}
			prizes[inx].ValidDays = valid.ValidDays
			prizes[inx].VerificationStart = valid.VerificationStart
			prizes[inx].VerificationEnd = valid.VerificationEnd
		}
		saveprizes = append(saveprizes, prizes[inx].TaLuckdrawPrize)
		// 保存内定信息
		if luckdraw.IsInternalDefault == models.BOOL_TRUE {
			if len(prize.Defaults) > prize.Stock {
				return errors.New("内置用户不能超过奖品数量！")
			}

			err := m.SaveLuckDrawDefault(prize.Defaults, prizes[inx].TaLuckdrawPrize)
			if err != nil {
				return err
			}
		}
	}
	_, err := m.db.Insert(saveprizes)
	if err != nil {
		return err
	}
	return err
}

// Verification 有效期
type Verification struct {
	ValidDays         int
	VerificationStart time.Time
	VerificationEnd   time.Time
}

// SavePrizeDetail 保存奖品明细
func (m *LuckDrawDao) SavePrizeDetail(prize model.TaLuckdrawPrize) (*Verification, error) {
	var verification = Verification{}
	if prize.CouponCardType == models.PRIZE_TYPE_COUPON {
		var coupon model.TaCoupon
		_, err := m.db.Where("coupon_id=?", prize.CouponCardId).Get(&coupon)
		if err != nil {
			return nil, err
		}
		if coupon.UsedCount > 0 {
			return nil, errors.New("卡券已被使用！不允许保存！")
		}
		verification.ValidDays = coupon.ValidDays
		verification.VerificationStart = coupon.StartDate
		verification.VerificationEnd = coupon.EndDate
		var details []model.TaPrizeDetail
		i := 0
		for i < coupon.TotalCount {
			unix := time.Now().UnixNano()
			random := utils.GetRand(5) + strconv.Itoa(int(unix))
			url := `/` + prize.CouponCardId + `/` + beego.AppConfig.String("defaultShareUserID") + `/` + prize.CouponCardType + `/` + random + `/receive`
			var d = model.TaPrizeDetail{
				Id:      utils.GetGUID(),
				PrizeId: prize.Id,
				Url:     url,
				Status:  models.STATUS_READY,
			}
			details = append(details, d)
			i = i + 1
		}
		m.db.Insert(details)
	} else {
		var card model.TaCouponCard
		_, err := m.db.Where("card_id=?", prize.CouponCardId).Get(&card)
		if err != nil {
			return nil, err
		}
		if card.UsedCount > 0 {
			return nil, errors.New("卡券已被使用！不允许保存！")
		}
		verification.ValidDays = 0
		verification.VerificationStart = card.StartDate
		verification.VerificationEnd = card.EndDate
		var details []model.TaPrizeDetail
		i := 0
		for i < card.TotalCount {
			unix := time.Now().UnixNano()
			random := utils.GetRand(5) + strconv.Itoa(int(unix))
			url := `/` + prize.CouponCardId + `/` + beego.AppConfig.String("defaultShareUserID") + `/` + prize.CouponCardType + `/` + random + `/receive`
			var d = model.TaPrizeDetail{
				Id:      utils.GetGUID(),
				PrizeId: prize.Id,
				Url:     url,
				Status:  models.STATUS_READY,
			}
			details = append(details, d)
			i = i + 1
		}
		m.db.Insert(details)
	}

	return &verification, nil
}

// UpdateLuckDraw 修改抽奖
func (m *LuckDrawDao) UpdateLuckDraw(luckdraw model.TaLuckdraw, cols []string) error {
	_, err := m.db.Cols(cols...).Where("id=?", luckdraw.Id).Update(luckdraw)
	return err
}

// UpdatePrizeDesc 更新奖品描述
func (m *LuckDrawDao) UpdatePrizeDesc(prizes []PrizeWithDefaults) error {
	for _, prize := range prizes {
		_, err := m.db.Cols([]string{
			"prize_desc",
		}...).Where("id=?", prize.Id).Update(prize.TaLuckdrawPrize)
		if err != nil {
			return err
		}
	}
	return nil
}

// GetLuckDraw 获取抽奖信息
func (m *LuckDrawDao) GetLuckDraw(id string) (*LuckDraw, error) {
	if id == "" {
		return nil, errors.New("不存在抽奖信息！")
	}
	luckdraw, err := m.GetLuckDrawByID(id)
	if err != nil {
		utils.LogError("获取抽奖信息失败：", err)
		return nil, errors.New("获取抽奖信息失败")
	}
	prizes, err := m.GetPrizes(id)
	if err != nil {
		utils.LogError("获取奖品信息失败：", err)
		return nil, errors.New("获取奖品信息失败")
	}
	luckdraw.Prizes = prizes
	imgs, err := m.GetLuckDrawImgs(id)
	if err != nil {
		utils.LogError("获取抽奖图片信息失败：", err)
		return nil, errors.New("获取抽奖图片信息失败")
	}
	luckdraw.Imgs = imgs
	return luckdraw, nil
}

// AddCustomerLuckDraw 保存用户抽奖配置信息
func (m *LuckDrawDao) AddCustomerLuckDraw(custLuckDraw model.TaLuckdrawCustomer) (*model.TaLuckdrawCustomer, error) {
	custLuckDraw.LuckdrawCustomerId = utils.GetGUID()
	custLuckDraw.CreateDate = time.Now()
	custLuckDraw.ShareNum = 0
	custLuckDraw.ShareSurplusNum = 0
	_, err := m.db.Insert(custLuckDraw)
	return &custLuckDraw, err
}

// LuckDraw 抽奖
func (m *LuckDrawDao) LuckDraw(id string, user *model.TaCustomer) (*model.TaLuckdrawPrize, *model.TaPrizeDetail, *model.TaLuckdrawRecord, error) {
	luckdraw, err := m.GetLuckDrawByID(id)
	if err != nil {
		return nil, nil, nil, errors.New("获取抽奖信息失败！")
	}
	if luckdraw.Status == models.STATUS_READY {
		return nil, nil, nil, errors.New("活动已结束！")
	}
	if time.Now().Before(luckdraw.BeginDate) {
		return nil, nil, nil, errors.New("活动还未开始！")
	}
	if luckdraw.Status == models.STATUS_EXPIRE || time.Now().After(luckdraw.EndDate) {
		return nil, nil, nil, errors.New("活动已结束！")
	}
	if luckdraw.Status != models.STATUS_NORMAL {
		return nil, nil, nil, errors.New("当前抽奖活动状态异常！")
	}
	// 系统用户是否可以抽奖
	if luckdraw.IsSysLuckdraw == models.BOOL_FALSE {
		if user.Phone != "" {
			sysuser, err := m.GetUserByTel(user.Phone)
			if err != nil {
				return nil, nil, nil, errors.New("获取信息失败！")
			}
			if sysuser != nil && sysuser.UserId != "" {
				return nil, nil, nil, errors.New("内部人员不允许进行抽奖！")
			}
		}
	}

	// 判断当前用户是否为新用户
	cstluckdrawSet, err := m.GetCustomerLuckDraw(id, user.CustomerId)
	if err != nil {
		utils.LogError("获取用户抽奖配置信息失败:", err)
		return nil, nil, nil, errors.New("获取用户抽奖配置信息失败！")
	}

	if luckdraw.JoinType == models.JOINTYPE_NEWUSER {
		if cstluckdrawSet.IsNew == models.BOOL_FALSE {
			return nil, nil, nil, errors.New("您不是新用户，不允许抽奖！")
		}
	}

	// 抽奖次数判断
	if cstluckdrawSet.SurplusNum <= 0 {
		return nil, nil, nil, errors.New("您的抽奖次数已用完！")
	} else {
		// 抽奖次数库存修改
		err := m.UpdateCstLuckdrawSurplus(cstluckdrawSet)
		if err != nil {
			utils.LogError("更新抽奖次数库存失败：", err)
			return nil, nil, nil, errors.New("操作失败，请刷新后重试！")
		}
	}

	// 判断是否内置用户
	defaultPrize, err := m.GetPrizeDefaultByUser(id, user)
	if err != nil {
		utils.LogError("操作失败，请刷新后重试:", err)
		return nil, nil, nil, errors.New("操作失败，请刷新后重试！")
	}
	var prize = new(model.TaLuckdrawPrize)
	if defaultPrize.Id != "" {
		// 内置用户，直接中奖
		prize = &defaultPrize.TaLuckdrawPrize
	} else {
		prizes, err := m.GetPrizeStock(id)
		if err != nil {
			utils.LogError("获取奖项失败:", err)
			return nil, nil, nil, errors.New("获取奖项失败！")
		}
		if len(prizes) == 0 {
			// err = m.UpdateLuckDrawEndDate(luckdraw.Id)
			// if err != nil {
			// 	utils.LogError("操作失败，请刷新后重试:", err)
			// 	return nil, nil, nil, errors.New("操作失败，请刷新后重试！")
			// }
			return nil, nil, nil, errors.New("活动已结束！")
		}
		prize, err = m.GetWinning(prizes)
		if err != nil {
			utils.LogError("获取奖项失败:", err)
			return nil, nil, nil, err
		}
	}

	details, err := m.GetPrizeDetail(prize.Id)
	if err != nil {
		utils.LogError("获取奖项详情失败:", err)
		return nil, nil, nil, errors.New("获取奖项详情失败！")
	}

	// 保存中奖记录
	var record = &model.TaLuckdrawRecord{}
	record.Id = utils.GetGUID()
	record.OrgId = luckdraw.OrgId
	record.CaseId = luckdraw.CaseId
	record.PrizeId = prize.Id
	record.PrizeName = prize.PrizeName
	record.UserId = user.CustomerId
	record.UserName = user.CustomerName
	record.UserHeadImg = user.Headimgurl
	record.LuckdrawId = luckdraw.Id
	record.IsReality = prize.IsReality

	if prize.IsReality != models.BOOL_FALSE {
		if prize.ValidDays > 0 {
			record.VerificationStart = time.Now().Local()
			record.VerificationEnd = time.Now().Local().AddDate(0, 0, prize.ValidDays)
		} else {
			record.VerificationStart = prize.VerificationStart
			record.VerificationEnd = prize.VerificationEnd
		}
	} else {
		record.VerificationStart = time.Now().Local()
		record.VerificationEnd = time.Now().Local()
	}

	utils.LogInfo("生成中奖记录:", *record)

	record, err = m.SaveRecord(*record)
	if err != nil {
		utils.LogError("保存中奖纪录失败：", err)
		return nil, nil, nil, err
	}
	// 更新参与人数
	err = m.UpdateLuckDrawJoinedNum(id)
	if err != nil {
		utils.LogError("更新参与人数失败：", err)
		return nil, nil, nil, errors.New("操作失败，请刷新后重试！")
	}

	// 更新内置信息
	err = m.UpdatePrizeDefault(defaultPrize.DefaultId, record.Id)
	if err != nil {
		utils.LogError("更新内置信息失败：", err)
		return nil, nil, nil, err
	}

	var detail = model.TaPrizeDetail{}
	if len(details) > 0 {
		// 更新中奖纪录明细
		details[0].ReceiveId = record.Id
		err = m.UpdatePrizeDetail(details[0])
		if err != nil {
			utils.LogError("更新中奖纪录明细失败:", err)
			return nil, nil, nil, errors.New("操作失败！")
		}
		detail = details[0]
		// 奖项自动核销，走卡券核销流程
		err = m.PrizeWriteOff(record.Id, user.CustomerId)
		if err != nil {
			utils.LogError("卡券核销失败:", err)
			return nil, nil, nil, errors.New("操作失败！")
		}
	}
	// 更新库存
	if prize.IsReality == 1 {
		// prize.Remainder = prize.Remainder - 1
		err = m.UpdateStock(prize)
		if err != nil {
			utils.LogError("更新库存失败：", err)
			return nil, nil, nil, err
		}
		stockprizes, err := m.GetPrizeStockAll(id)
		if err != nil {
			utils.LogError("更新库存失败:", err)
			return nil, nil, nil, errors.New("操作失败，请刷新后重试！")
		}
		if len(stockprizes) == 0 {
			// 更新活动截止时间
			err = m.UpdateLuckDrawEndDate(luckdraw.Id)
		}
	} else {
		// 奖项自动核销，走卡券核销流程
		err = m.PrizeWriteOff(record.Id, user.CustomerId)
		if err != nil {
			utils.LogError("卡券核销失败:", err)
			return nil, nil, nil, errors.New("操作失败！")
		}
	}

	return prize, &detail, record, err
}

// UpdateCstLuckdrawSurplus 更新用户抽奖剩余次数
func (m *LuckDrawDao) UpdateCstLuckdrawSurplus(cstLuckDraw *model.TaLuckdrawCustomer) error {
	sql := `update ta_luckdraw_customer set share_surplus_num = (case when surplus_num > share_surplus_num then share_surplus_num else share_surplus_num - 1 end),
	surplus_num = surplus_num - 1 where luckdraw_customer_id = ? and surplus_num>0`
	res, err := m.db.Exec(sql, cstLuckDraw.LuckdrawCustomerId)
	if err != nil {
		return err
	}
	len, _ := res.RowsAffected()
	if len < 1 {
		return errors.New("您没有剩余次数！")
	}
	return nil
}

// UpdateLuckDrawJoinedNum 更新抽奖参与人数
func (m *LuckDrawDao) UpdateLuckDrawJoinedNum(id string) error {
	var records []model.TaLuckdrawRecord
	sql := `select DISTINCT user_id from ta_luckdraw_record where luckdraw_id=?`
	err := m.db.Sql(sql, id).Find(&records)
	if err != nil {
		return err
	}
	if len(records) > 0 {
		sql = `update ta_luckdraw set joined_num=? where id=?`
		_, err = m.db.Exec(sql, len(records), id)
		return err
	}
	return nil
}

// PrizeWithDefault 默认奖品
type PrizeWithDefault struct {
	DefaultId             string
	model.TaLuckdrawPrize `xorm:"extends"`
}

// GetPrizeDefaultByUser 获取默认用户
func (m *LuckDrawDao) GetPrizeDefaultByUser(id string, customer *model.TaCustomer) (*PrizeWithDefault, error) {
	var prize = PrizeWithDefault{}
	sql := `select a.default_id,b.* from ta_prize_default a inner join ta_luckdraw_prize b on a.prize_id=b.id where a.luckdraw_id=? and a.tel=? and a.is_receive=?`
	_, err := m.db.Sql(sql, id, customer.Phone, models.BOOL_FALSE).Get(&prize)
	return &prize, err
}

// UpdatePrizeDefault 更新系统内置信息
func (m *LuckDrawDao) UpdatePrizeDefault(id, recordid string) error {
	var prizeDefault = model.TaPrizeDefault{
		DefaultId:   id,
		ReceiveDate: time.Now(),
		ReceiveId:   recordid,
		IsReceive:   models.BOOL_TRUE,
	}
	cols := []string{
		"receive_id",
		"receive_date",
		"is_receive",
	}
	_, err := m.db.Cols(cols...).Where("default_id=?", prizeDefault.DefaultId).Update(prizeDefault)
	return err
}

// GetCustomerLuckDraw 获取用户抽奖设置
func (m *LuckDrawDao) GetCustomerLuckDraw(luckdrawid, customerid string) (*model.TaLuckdrawCustomer, error) {
	var customerluckdraw model.TaLuckdrawCustomer
	_, err := m.db.Where("luckdraw_id=?", luckdrawid).And("customer_id=?", customerid).Get(&customerluckdraw)
	if err != nil {
		return nil, err
	}
	return &customerluckdraw, nil
}

// PrizeWriteOff 奖品核销
func (m *LuckDrawDao) PrizeWriteOff(recordid, userid string) error {
	record, err := m.GetRecordByID(recordid)
	if err != nil {
		return err
	}
	var writeoff = model.TaLuckdrawWriteoff{}
	writeoff.LuckdrawId = record.LuckdrawId
	writeoff.CaseId = record.CaseId
	writeoff.OrgId = record.OrgId
	writeoff.RecordId = record.Id
	writeoff.WriteoffUser = userid
	_, err = m.SaveWirteOff(writeoff)
	if err != nil {
		return err
	}
	err = m.UpdateRecord(record)
	return err
}

// GetWinning 获取中奖信息
func (m *LuckDrawDao) GetWinning(prizes []model.TaLuckdrawPrize) (*model.TaLuckdrawPrize, error) {
	pList := make([]map[string]interface{}, 0)
	now := time.Now().Local()

	for _, prize := range prizes {
		// 有剩余的 并且 未过期的
		if (prize.Remainder > 0 && (now.Before(prize.VerificationEnd) || prize.ValidDays > 0)) || prize.IsReality == models.BOOL_FALSE {
			p := map[string]interface{}{
				"prize": prize,
				"prob":  prize.Probability,
			}

			pList = append(pList, p)
		}
	}

	if len(pList) == 0 {
		return nil, errors.New("所有奖品已抽完")
	}

	thePrize := utils.LuckyDraw(pList).(model.TaLuckdrawPrize)

	return &thePrize, nil
}

// GetLuckDrawByID 获取抽奖信息
func (m *LuckDrawDao) GetLuckDrawByID(id string) (*LuckDraw, error) {
	var luckdraws []LuckDraw
	sql := `SELECT
	a.*,
	b.activity_main_img,
	b.activity_title,
	b.share_img,
	b.share_content
FROM
	ta_luckdraw a
	LEFT JOIN ta_activity_share_info b ON a.id = b.activity_id 
WHERE
	id = ?`
	err := m.db.SQL(sql, id).Find(&luckdraws)
	if err != nil {
		return nil, err
	}
	if len(luckdraws) > 0 {
		return &luckdraws[0], nil
	}
	return nil, nil
}

// GetCaseAddressByLuckDarw 获取案场地址
func (m *LuckDrawDao) GetCaseAddressByLuckDarw(luckdraw string) (string, error) {
	sql := `
		SELECT
			s.case_address
		FROM
			ta_luckdraw t
		JOIN sys_case s ON t.org_id = s.org_id
		AND t.case_id = s.case_id
		AND t.id = ?
	`

	res, err := m.db.Query(sql, luckdraw)
	if err != nil {
		return "", err
	}

	if res == nil || len(res) == 0 {
		return "", nil
	}

	return string(res[0]["case_address"]), nil
}

// UpdateLuckDrawEndDate 更新活动结束时间
func (m *LuckDrawDao) UpdateLuckDrawEndDate(id string) error {
	var luckdraw = model.TaLuckdraw{
		Id:      id,
		EndDate: time.Now(),
		Status:  models.STATUS_EXPIRE,
	}
	cols := []string{
		"end_date",
		"status",
	}
	_, err := m.db.Cols(cols...).Where("id=?", id).Update(luckdraw)
	return err
}

// GetPrizes 获取奖品信息
func (m *LuckDrawDao) GetPrizes(luckdrawid string) ([]model.TaLuckdrawPrize, error) {
	var prizes []model.TaLuckdrawPrize
	err := m.db.Where("luckdraw_id=?", luckdrawid).And("status=?", models.STATUS_NORMAL).Find(&prizes)
	return prizes, err
}

// GetPrizesWithDefaults 获取奖品
func (m *LuckDrawDao) GetPrizesWithDefaults(luckdrawid string) ([]PrizeWithDefaults, error) {
	var prizes []PrizeWithDefaults
	sql := `select * from ta_luckdraw_prize where luckdraw_id=? and status=?`
	err := m.db.Sql(sql, luckdrawid, models.STATUS_NORMAL).Find(&prizes)
	if err != nil {
		return nil, err
	}
	for inx, prize := range prizes {
		defaults, err := m.GetDefaultsByPrize(prize.Id)
		if err != nil {
			return nil, err
		}
		prizes[inx].Defaults = defaults
	}
	return prizes, err
}

// GetDefaultsByPrize 根据奖品获取内定信息
func (m *LuckDrawDao) GetDefaultsByPrize(prizeid string) ([]model.TaPrizeDefault, error) {
	var defaults []model.TaPrizeDefault
	err := m.db.Where("prize_id=?", prizeid).Find(&defaults)
	return defaults, err
}

// UpdateStock 修改库存
func (m *LuckDrawDao) UpdateStock(prize *model.TaLuckdrawPrize) error {
	sql := `update ta_luckdraw_prize set remainder = remainder - 1 where id=?`
	_, err := m.db.Exec(sql, prize.Id)
	// cols := []string{
	// 	"remainder",
	// }
	// _, err := m.db.Cols(cols...).Where("id=?", prize.Id).Update(prize)
	return err
}

// GetPrizeStock 判断奖项库存
func (m *LuckDrawDao) GetPrizeStock(luckdrawid string) ([]model.TaLuckdrawPrize, error) {
	var prizes []model.TaLuckdrawPrize
	sql := `select a.remainder-(case when b.default_num is null then 0 else b.default_num end) as remainder,
	a.* from ta_luckdraw_prize a 
	left join (select prize_id,count(1) as default_num from ta_prize_default where luckdraw_id=? and is_receive=0 group by prize_id) b 
	on a.id=b.prize_id where a.luckdraw_id=? and a.status=? and (a.remainder-(case when b.default_num is null then 0 else b.default_num end)>0 or is_reality=0)`
	err := m.db.Sql(sql, luckdrawid, luckdrawid, models.STATUS_NORMAL).Find(&prizes)
	// err := m.db.Where("luckdraw_id=?", luckdrawid).And("status=?", models.STATUS_NORMAL).And("(remainder>0 or is_reality=0)").Find(&prizes)
	return prizes, err
}

// GetPrizeStockAll 获取奖项
func (m *LuckDrawDao) GetPrizeStockAll(luckdrawid string) ([]model.TaLuckdrawPrize, error) {
	var prizes []model.TaLuckdrawPrize
	err := m.db.Where("luckdraw_id=?", luckdrawid).And("status=?", models.STATUS_NORMAL).And("(remainder>0 or is_reality=0)").Find(&prizes)
	return prizes, err
}

// GetPrizeByID 根据id获取奖品信息
func (m *LuckDrawDao) GetPrizeByID(id string) (model.TaLuckdrawPrize, error) {
	var prize = model.TaLuckdrawPrize{}
	_, err := m.db.Where("id=?", id).Get(&prize)
	return prize, err
}

// SaveRecord 保存抽奖记录
func (m *LuckDrawDao) SaveRecord(record model.TaLuckdrawRecord) (*model.TaLuckdrawRecord, error) {
	record.CreateDate = time.Now()
	record.Status = models.STATUS_READY
	// record.Id = utils.GetGUID()
	_, err := m.db.Insert(&record)
	return &record, err
}

// GetUserByTel 根据电话获取用户信息
func (m *LuckDrawDao) GetUserByTel(tel string) (*model.SysUser, error) {
	var user = model.SysUser{}
	_, err := m.db.Where("phone=?", tel).And("status>?", models.STATUS_DEL).Get(&user)
	return &user, err
}

// GetPrizeDetail 获取未领取的奖品详情
func (m *LuckDrawDao) GetPrizeDetail(prizeid string) ([]model.TaPrizeDetail, error) {
	var details []model.TaPrizeDetail
	err := m.db.Where("prize_id=?", prizeid).And("status=?", models.STATUS_READY).Find(&details)
	return details, err
}

// UpdatePrizeDetail 更新库存明细为已领取
func (m *LuckDrawDao) UpdatePrizeDetail(detail model.TaPrizeDetail) error {
	detail.Status = models.STATUS_NORMAL
	detail.ReceiveDate = time.Now()
	cols := []string{
		"status",
		"receive_id",
		"receive_date",
	}
	_, err := m.db.Cols(cols...).Where("id=?", detail.Id).Update(detail)
	return err
}

// UpdateRecord 核销更新抽奖记录表
func (m *LuckDrawDao) UpdateRecord(record *LuckInfo) error {
	record.Status = models.STATUS_NORMAL
	record.WriteoffDate = time.Now()
	cols := []string{
		"status",
		"writeoff_date",
	}
	_, err := m.db.Cols(cols...).Where("id=?", record.Id).Update(record.TaLuckdrawRecord)
	return err
}

// SaveWirteOff 保存核销信息
func (m *LuckDrawDao) SaveWirteOff(writeoff model.TaLuckdrawWriteoff) (*model.TaLuckdrawWriteoff, error) {
	writeoff.Status = models.STATUS_NORMAL
	writeoff.Id = utils.GetGUID()
	writeoff.WriteoffDate = time.Now()
	_, err := m.db.Insert(&writeoff)
	return &writeoff, err
}

// GetUserRecordByLuckDraw 获取用户的抽奖信息
func (m *LuckDrawDao) GetUserRecordByLuckDraw(userid string, luckdrawid string) ([]model.TaLuckdrawRecord, error) {
	var records []model.TaLuckdrawRecord
	err := m.db.Where("user_id=?", userid).And("luckdraw_id=?", luckdrawid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&records)
	return records, err
}

// GetUserLuckDrawSet 获取用户抽奖设置
func (m *LuckDrawDao) GetUserLuckDrawSet(customer model.TaCustomer, luckdrawid string) (*model.TaLuckdrawCustomer, error) {
	var cstluckdraw = model.TaLuckdrawCustomer{}
	_, err := m.db.Where("customer_id=?", customer.CustomerId).And("luckdraw_id=?", luckdrawid).Get(&cstluckdraw)
	if err != nil {
		return nil, err
	}
	if cstluckdraw.CustomerId != "" {
		return &cstluckdraw, nil
	}
	// 插入
	luckdraw, err := m.GetLuckDrawByID(luckdrawid)
	if err != nil {
		return nil, err
	}
	surplusNum := luckdraw.LuckdrawNum
	isnew := 0
	if customer.Phone == "" {
		isnew = 1
	}
	if luckdraw.JoinType == models.JOINTYPE_NEWUSER && isnew != 1 {
		surplusNum = 0
	}
	cstluckdraw.CustomerId = customer.CustomerId
	cstluckdraw.IsNew = isnew
	cstluckdraw.LuckdrawId = luckdrawid
	cstluckdraw.SurplusNum = surplusNum
	newinfo, err := m.AddCustomerLuckDraw(cstluckdraw)
	return newinfo, err
}

// GetUserLuckDrawByLuckDraw 获取用户的抽奖信息
func (m *LuckDrawDao) GetUserLuckDrawByLuckDraw(userid string, luckdrawid string) (*model.TaLuckdrawRecord, error) {
	var records []model.TaLuckdrawRecord
	err := m.db.Where("user_id=?", userid).And("luckdraw_id=?", luckdrawid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&records)
	if err != nil {
		return nil, err
	}
	if len(records) > 0 {
		return &records[0], nil
	}
	return nil, nil
}

// GetDetailByRecord 获取detail
func (m *LuckDrawDao) GetDetailByRecord(recordid string) (*model.TaPrizeDetail, error) {
	var details []model.TaPrizeDetail
	err := m.db.Where("receive_id=?", recordid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&details)
	if err != nil {
		return nil, err
	}
	if len(details) > 0 {
		return &details[0], nil
	}
	return nil, nil
}

// UserRecord 用户抽奖信息
type UserRecord struct {
	model.TaLuckdrawRecord `xorm:"extends"`
	Url                    string
}

// GetUserLuckDraw 获取用户的抽奖信息
func (m *LuckDrawDao) GetUserLuckDraw(userid string) ([]UserRecord, error) {
	var records []UserRecord
	sql := `select a.*,b.url from ta_luckdraw_record a left join ta_prize_detail b on a.id=b.receive_id where a.user_id=? and a.status>` + strconv.Itoa(models.STATUS_DEL) + ` order by a.create_date desc`
	err := m.db.Sql(sql, userid).Find(&records)
	return records, err
}

// GetRecordByLuckDraw 抽奖记录
func (m *LuckDrawDao) GetRecordByLuckDraw(luckdrawid string) ([]model.TaLuckdrawRecord, error) {
	var records []model.TaLuckdrawRecord
	err := m.db.Where("luckdraw_id=?", luckdrawid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Desc("create_date").Find(&records)
	return records, err
}

// GetRecordByID 获取抽奖记录明细
func (m *LuckDrawDao) GetRecordByID(id string) (*LuckInfo, error) {
	var record []LuckInfo
	sql := `SELECT
	a.*,
	b.customer_qrcode 
FROM
	ta_luckdraw_record a
	LEFT JOIN ta_customer_course_qrcode b ON a.id = b.customer_course_id
	where a.id = '` + id + `'`
	err := m.db.Sql(sql).Find(&record)
	if len(record) > 0 {
		return &record[0], err
	}
	return nil, err

}

// SaveLuckDrawShareData 保存用户分享信息
func (m *LuckDrawDao) SaveLuckDrawShareData(dt *model.TaShareLuckyRecord) error {
	dt.CreateDate = time.Now().Local()
	dt.Status = models.STATUS_NORMAL
	dt.Id = utils.GetGUID()

	if _, err := m.db.Insert(dt); err != nil {
		return err
	}

	return nil
}

// GetLuckDrawShareData 获取用户分 享内容
func (m *LuckDrawDao) GetLuckDrawShareData(from, to, luckID, caseID string) ([]model.TaShareLuckyRecord, error) {
	var dts []model.TaShareLuckyRecord

	if err := m.db.Where("from_customer_id=?", from).
		And("to_customer_id=?", to).
		And("luckydraw_id=?", luckID).
		And("case_id=?", caseID).
		And("status=?", models.STATUS_NORMAL).
		Find(&dts); err != nil {
		return nil, err
	}

	return dts, nil
}

// UpdateShareNum 分享增加抽奖次数
func (m *LuckDrawDao) UpdateShareNum(luckdraw *LuckDraw, from string) error {
	num := strconv.Itoa(luckdraw.ShareAddNum)
	sql := `update ta_luckdraw_customer set share_num=share_num+` + num + `,share_surplus_num = share_surplus_num +` + num + ` ,surplus_num = surplus_num+` + num + ` where luckdraw_id=? and customer_id=?`
	_, err := m.db.Exec(sql, luckdraw.Id, from)
	return err
}

// GetLuckDrawCustomerNum 获取抽奖人数
func (m *LuckDrawDao) GetLuckDrawCustomerNum(luckdrawid string) (int, error) {
	var records []model.TaLuckdrawRecord
	sql := `select DISTINCT user_id from ta_luckdraw_record where luckdraw_id=?`
	err := m.db.Sql(sql, luckdrawid).Find(&records)
	return len(records), err
}