package mall

import (
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/service/provider/stocks"
	"joybuywork/internal/utils/logic"
	pb "joybuywork/proto/go_proto/w_mall"
	"joybuywork/proto/go_proto/workerr"
	"time"

	"gorm.io/gen/field"
)

type ItemStatus struct {
	logic.Logic

	Req *pb.ItemStatusReq
	Res *pb.ItemStatusRes
}

func (s *ItemStatus) Run() (err error) {
	return logic.Run(s)
}

func (s *ItemStatus) Exec() (err error) {
	item, err := s.item()
	if err != nil {
		return
	}

	return s.status(item)
}

func (s *ItemStatus) item() (item *model.RedeemMallItem, err error) {
	item, err = cache.NewRedeemMallItem(s.Ctx).FindById(s.Req.GetId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if item == nil {
		err = workerr.NotFound("not_found item")
		return
	}

	s.Res.Id = item.ID

	return
}

func (s *ItemStatus) status(item *model.RedeemMallItem) (err error) {
	switch s.Req.GetStatus() {
	case 1: //上架
		err = s._up(item)
		if err != nil {
			return
		}
	case 2: //下架
		err = s._down(item)
		if err != nil {
			return
		}
	case 3: //删除
		err = s._delete(item)
		if err != nil {
			return
		}
	default:
		return s.BE().VerifyError("invalid status")
	}

	s.AddAfterRun(func() (err error) {
		return cache.NewRedeemMallItem(s.Ctx).Clear(item)
	})

	return
}

func (s *ItemStatus) _up(item *model.RedeemMallItem) (err error) {
	if item.GetStatus() == mtype.RedeemMallItemStatusUp {
		return
	}

	if item.GetStatus() != mtype.RedeemMallItemStatusWait {
		return s.BE().VerifyError("Not a item waiting to be listed")
	}

	m := s.GetDao().RedeemMallItem
	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(item.ID)).UpdateSimple(
		m.UpAt.Value(time.Now().Unix()),
		m.UpFrom.Value(mtype.RedeemMallItemUpFromManual),
	)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return
}

func (s *ItemStatus) _down(item *model.RedeemMallItem) (err error) {
	if item.GetStatus() == mtype.RedeemMallItemStatusDown {
		return
	}

	m := s.GetDao().RedeemMallItem
	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(item.ID)).UpdateSimple(
		m.DownAt.Value(time.Now().Unix()),
		m.DownFrom.Value(mtype.RedeemMallItemDownFromManual),
	)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return s._task(item, mtype.RedeemMallItemTaskMarkDown)
}

func (s *ItemStatus) _delete(item *model.RedeemMallItem) (err error) {
	if item.GetStatus() == mtype.RedeemMallItemStatusDel {
		return
	}

	m := s.GetDao().RedeemMallItem
	var up = []field.AssignExpr{
		m.IsDel.Value(mtype.Yes),
	}

	if item.GetStatus() != mtype.RedeemMallItemStatusDown {
		up = append(
			up,
			m.DownAt.Value(time.Now().Unix()),
			m.DownFrom.Value(mtype.RedeemMallItemDownFromDel),
		)

		err = s._task(item, mtype.RedeemMallItemTaskMarkDown)
		if err != nil {
			return
		}
	}

	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(item.ID)).UpdateSimple(up...)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return
}

func (s *ItemStatus) _task(item *model.RedeemMallItem, mark string) (err error) {

	m := s.GetDao().RedeemMallItemTask
	task, err := m.WithContext(s.Ctx).Where(m.ItemID.Eq(item.ID), m.Mark.Eq(mark)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if task == nil {
		return
	}

	switch task.Mark {
	case mtype.RedeemMallItemTaskMarkDown:

		var stock *stocks.MallItem
		stock, err = stocks.NewMallItem(s.Ctx, item.ID)
		if err != nil {
			return
		}

		useNum, _ := stock.GetUseStock(item.ID)

		itemM := s.GetDao().RedeemMallItem
		_, err = itemM.WithContext(s.Ctx).Where(itemM.ID.Eq(item.ID)).UpdateSimple(
			itemM.UseStock.Value(useNum),
		)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

	}

	return
}