package cmm

import (
	"context"
	"joybuywork/internal/repository/dao"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/internal/utils/merr"
	"github.com/golang-module/carbon/v2"
)

type FirstCreate struct {
	ctx context.Context
	be  *merr.BusinessError
	dao *dao.Query
}

func NewFirstCreate(ctx context.Context, dao *dao.Query) *FirstCreate {
	return &FirstCreate{
		ctx: ctx,
		be:  merr.NewBE(ctx),
		dao: dao,
	}
}

func (s *FirstCreate) FissionUserStat(user *model.FissionUser) (stat *model.FissionUserStat, err error) {
	statM := s.dao.FissionUserStat
	stat, err = statM.WithContext(s.ctx).Where(statM.UserID.Eq(user.ID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.be.MysqlError(err)
		return
	}

	if stat == nil {
		stat = withdefault.FissionUserStat(&model.FissionUserStat{
			UserID:     user.ID,
			CampaignID: user.CampaignID,
		})

		err = statM.WithContext(s.ctx).Create(stat)
		if err != nil {
			err = s.be.MysqlError(err)
			return
		}
	}

	return
}

func (s *FirstCreate) FissionDice(user *model.FissionUser) (player *model.FissionDice, err error) {
	playerM := s.dao.FissionDice
	player, err = playerM.WithContext(s.ctx).Where(playerM.UserID.Eq(user.ID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.be.MysqlError(err)
		return
	}

	if player != nil {
		return
	}

	confM := s.dao.FissionCampaignDice
	conf, err := confM.WithContext(s.ctx).Where(confM.CampaignID.Eq(user.CampaignID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.be.MysqlError(err)
		return
	}

	if conf == nil {
		return
	}

	player = withdefault.FissionDice(&model.FissionDice{
		UserID:     user.ID,
		CampaignID: user.CampaignID,
		Chance:     conf.InitChance,
	})

	err = playerM.WithContext(s.ctx).Create(player)
	if err != nil {
		err = s.be.MysqlError(err)
		return
	}

	if conf.InitChance == 0 {
		return
	}

	// 看看需不需要骰子记录
	record := withdefault.FissionDiceRecord(&model.FissionDiceRecord{
		CampaignID: user.CampaignID,
		UserID:     user.ID,
		Mark:       mtype.FissionDiceRecordMarkGetRollSys,
	})

	record.SetData(&mtype.DiceRecord{
		Chance: conf.InitChance,
	})

	err = s.dao.FissionDiceRecord.WithContext(s.ctx).Create(record)
	if err != nil {
		err = s.be.MysqlError(err)
	}

	return
}

func (s *FirstCreate) FissionDiceProp(user *model.FissionUser, mark string) (prop *model.FissionDiceProp, err error) {
	m := s.dao.FissionDiceProp
	prop, err = m.WithContext(s.ctx).Where(m.UserID.Eq(user.ID), m.Mark.Eq(mark)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.be.MysqlError(err)
		return
	}

	if prop == nil {
		prop = withdefault.FissionDiceProp(&model.FissionDiceProp{
			UserID:     user.ID,
			CampaignID: user.CampaignID,
			Mark:       mark,
			Num:        0,
			TotalNum:   0,
		})
		if err = m.WithContext(s.ctx).Create(prop); err != nil {
			err = s.be.MysqlError(err)
			return
		}
	}

	return
}

func (s *FirstCreate) FissionGrow(user *model.FissionUser) (player *model.FissionGrow, err error) {
	playerM := s.dao.FissionGrow
	player, err = playerM.WithContext(s.ctx).Where(playerM.UserID.Eq(user.ID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.be.MysqlError(err)
		return
	}

	if player != nil {
		return
	}

	confM := s.dao.FissionCampaignGrow
	conf, err := confM.WithContext(s.ctx).Where(confM.CampaignID.Eq(user.CampaignID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.be.MysqlError(err)
		return
	}

	if conf == nil {
		return
	}

	player = withdefault.FissionGrow(&model.FissionGrow{
		UserID:     user.ID,
		CampaignID: user.CampaignID,
		GrowNum:    conf.InitNum,
		PropsTime:  carbon.Now().AddHours(int(conf.AutoHour)).Timestamp(),
	})

	err = playerM.WithContext(s.ctx).Create(player)
	if err != nil {
		err = s.be.MysqlError(err)
		return
	}

	return
}

func (s *FirstCreate) FissionQa(user *model.FissionUser) (player *model.FissionQa, err error) {
	playerM := s.dao.FissionQa
	player, err = playerM.WithContext(s.ctx).Where(playerM.UserID.Eq(user.ID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.be.MysqlError(err)
		return
	}

	if player != nil {
		return
	}

	confM := s.dao.FissionCampaignQa
	conf, err := confM.WithContext(s.ctx).Where(confM.CampaignID.Eq(user.CampaignID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.be.MysqlError(err)
		return
	}

	if conf == nil {
		return
	}

	player = withdefault.FissionQa(&model.FissionQa{
		UserID:     user.ID,
		CampaignID: user.CampaignID,
		Chance:     conf.InitChance,
	})

	err = playerM.WithContext(s.ctx).Create(player)
	if err != nil {
		err = s.be.MysqlError(err)
		return
	}

	return
}

func (s *FirstCreate) FissionBallot(user *model.FissionUser) (player *model.FissionBallot, err error) {
	playerM := s.dao.FissionBallot
	player, err = playerM.WithContext(s.ctx).Where(playerM.UserID.Eq(user.ID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.be.MysqlError(err)
		return
	}

	if player != nil {
		return
	}

	confM := s.dao.FissionCampaignBallot
	conf, err := confM.WithContext(s.ctx).Where(confM.CampaignID.Eq(user.CampaignID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.be.MysqlError(err)
		return
	}

	if conf == nil {
		return
	}

	player = withdefault.FissionBallot(&model.FissionBallot{
		UserID:     user.ID,
		CampaignID: user.CampaignID,
		Chance:     conf.InitChance,
	})

	err = playerM.WithContext(s.ctx).Create(player)
	if err != nil {
		err = s.be.MysqlError(err)
		return
	}

	return
}

func (s *FirstCreate) FissionWin(user *model.FissionUser) (player *model.FissionWin, err error) {
	playerM := s.dao.FissionWin
	player, err = playerM.WithContext(s.ctx).Where(playerM.UserID.Eq(user.ID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.be.MysqlError(err)
		return
	}

	if player != nil {
		return
	}

	player = withdefault.FissionWin(&model.FissionWin{
		UserID:     user.ID,
		CampaignID: user.CampaignID,
		NextStep:   1,
	})

	err = playerM.WithContext(s.ctx).Create(player)
	if err != nil {
		err = s.be.MysqlError(err)
		return
	}

	return
}

func (s *FirstCreate) FissionReferral(user *model.FissionUser) (player *model.FissionReferral, err error) {
	playerM := s.dao.FissionReferral
	player, err = playerM.WithContext(s.ctx).Where(playerM.UserID.Eq(user.ID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.be.MysqlError(err)
		return
	}

	if player != nil {
		return
	}

	player = withdefault.FissionReferral(&model.FissionReferral{
		UserID:     user.ID,
		CampaignID: user.CampaignID,
		NextStep:   1,
	})

	err = playerM.WithContext(s.ctx).Create(player)
	if err != nil {
		err = s.be.MysqlError(err)
		return
	}

	return
}