package reward

import (
	"context"
	"fmt"
	"server/internal/consts"
	"server/internal/dao"
	"server/internal/model"
	"server/internal/model/do"
	"server/internal/service"
	"server/utility/ecode"
)

type sReward struct{}

func init() {
	service.RegisterReward(New())
}

func New() service.IReward {
	return &sReward{}
}

// Create 创建奖励
func (s *sReward) Create(ctx context.Context, in *model.RewardCreateIn) (out *model.RewardCreateOut, err error) {
	// 仅管理员能创建系统奖励（source=1）
	if in.Source == 1 && in.OperatorRole != consts.AdminRoleCode {
		return nil, ecode.Params.Sub("只有管理员可以创建系统奖励")
	}

	// 权限验证
	switch in.OperatorRole {
	case consts.MerchantRoleCode:
		// 检查商户管理员是否有该门店权限
		exist, err := dao.MerchantAdmins.Ctx(ctx).LeftJoin(
			dao.Stores.Table(),
			fmt.Sprintf("%s.%s = %s.%s",
				dao.MerchantAdmins.Table(), dao.MerchantAdmins.Columns().MerchantId,
				dao.Stores.Table(), dao.Stores.Columns().MerchantId,
			),
		).Where(
			fmt.Sprintf("%s.%s = ?", dao.Stores.Table(), dao.Stores.Columns().Id), in.StoreId,
		).Where(
			do.MerchantAdmins{Id: in.OperatorId},
		).Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("检查商户权限失败")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}

	case consts.StoreRoleCode:
		// 检查门店管理员是否有该门店权限
		exist, err := dao.StoreAdmins.Ctx(ctx).LeftJoin(
			dao.Stores.Table(),
			fmt.Sprintf("%s.%s = %s.%s",
				dao.StoreAdmins.Table(), dao.StoreAdmins.Columns().StoreId,
				dao.Stores.Table(), dao.Stores.Columns().Id,
			),
		).Where(
			fmt.Sprintf("%s.%s = ?", dao.Stores.Table(), dao.Stores.Columns().Id), in.StoreId,
		).Where(
			do.StoreAdmins{Id: in.OperatorId},
		).Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("检查门店权限失败")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}
	}

	// 创建奖励
	id, err := dao.Rewards.Ctx(ctx).Data(do.Rewards{
		RewardTypeId: in.RewardTypeId,
		Name:         in.Name,
		Description:  in.Description,
		Source:       in.Source,
		StoreId:      in.StoreId,
		Value:        in.Value,
		Status:       in.Status,
	}).OmitEmptyData().InsertAndGetId()
	if err != nil {
		return nil, err
	}

	return &model.RewardCreateOut{Id: id}, nil
}

// Update 更新奖励
func (s *sReward) Update(ctx context.Context, in *model.RewardUpdateIn) (out *model.RewardUpdateOut, err error) {
	// 查询原始记录，确保存在，并获取 source 与 store_id 用于权限校验
	data, err := dao.Rewards.Ctx(ctx).
		Fields(dao.Rewards.Columns().Id, dao.Rewards.Columns().Source, dao.Rewards.Columns().StoreId).
		Where(do.Rewards{Id: in.Id}).One()
	if err != nil {
		return nil, ecode.Fail.Sub("查询奖励失败")
	}
	if data.IsEmpty() {
		return nil, ecode.Params.Sub("奖励不存在")
	}

	// 系统奖励（source=1）只能由管理员修改
	if data[dao.Rewards.Columns().Source].Int() == 1 && in.OperatorRole != consts.AdminRoleCode {
		return nil, ecode.Params.Sub("只有管理员可以修改系统奖励")
	}

	storeId := data[dao.Rewards.Columns().StoreId].Int64()

	// 权限校验（管理员跳过）
	switch in.OperatorRole {
	case consts.MerchantRoleCode:
		// 商户管理员权限校验：是否管理该门店
		exist, err := dao.MerchantAdmins.Ctx(ctx).LeftJoin(
			dao.Stores.Table(),
			fmt.Sprintf("%s.%s = %s.%s",
				dao.MerchantAdmins.Table(), dao.MerchantAdmins.Columns().MerchantId,
				dao.Stores.Table(), dao.Stores.Columns().MerchantId,
			),
		).Where(
			fmt.Sprintf("%s.%s = ?", dao.Stores.Table(), dao.Stores.Columns().Id), storeId,
		).Where(
			do.MerchantAdmins{Id: in.OperatorId},
		).Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("检查操作者权限异常")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}

	case consts.StoreRoleCode:
		// 门店管理员权限校验：是否管理该门店
		exist, err := dao.StoreAdmins.Ctx(ctx).LeftJoin(
			dao.Stores.Table(),
			fmt.Sprintf("%s.%s = %s.%s",
				dao.StoreAdmins.Table(), dao.StoreAdmins.Columns().StoreId,
				dao.Stores.Table(), dao.Stores.Columns().Id,
			),
		).Where(
			fmt.Sprintf("%s.%s = ?", dao.Stores.Table(), dao.Stores.Columns().Id), storeId,
		).Where(
			do.StoreAdmins{Id: in.OperatorId},
		).Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("检查操作者权限异常")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}
	}

	// 执行更新（不允许更新 store_id 和 source）
	_, err = dao.Rewards.Ctx(ctx).
		Where(do.Rewards{Id: in.Id}).
		Data(do.Rewards{
			Name:        in.Name,
			Description: in.Description,
			Value:       in.Value,
			Status:      in.Status,
		}).OmitEmptyData().Update()
	if err != nil {
		return nil, ecode.Fail.Sub("更新奖励失败")
	}

	return &model.RewardUpdateOut{Success: true}, nil
}

// Delete 删除奖励
func (s *sReward) Delete(ctx context.Context, in *model.RewardDeleteIn) (out *model.RewardDeleteOut, err error) {
	data, err := dao.Rewards.Ctx(ctx).
		Fields("id", "source", "store_id").
		Where(do.Rewards{Id: in.Id}).One()
	if err != nil {
		return nil, ecode.Fail.Sub("查询奖励失败")
	}
	if data.IsEmpty() {
		return nil, ecode.Params.Sub("奖励不存在")
	}

	if data["source"].Int() == 1 && in.OperatorRole != consts.AdminRoleCode {
		return nil, ecode.Params.Sub("只有管理员可以删除系统奖励")
	}

	storeId := data["store_id"].Int64()
	switch in.OperatorRole {
	case consts.MerchantRoleCode:
		exist, err := dao.MerchantAdmins.Ctx(ctx).LeftJoin(
			dao.Stores.Table(),
			fmt.Sprintf("%s.%s = %s.%s",
				dao.MerchantAdmins.Table(), dao.MerchantAdmins.Columns().MerchantId,
				dao.Stores.Table(), dao.Stores.Columns().MerchantId),
		).Where(fmt.Sprintf("%s.%s = ?", dao.Stores.Table(), dao.Stores.Columns().Id), storeId).
			Where(do.MerchantAdmins{Id: in.OperatorId}).Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("权限校验失败")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}
	case consts.StoreRoleCode:
		exist, err := dao.StoreAdmins.Ctx(ctx).Where(do.StoreAdmins{Id: in.OperatorId, StoreId: storeId}).Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("权限校验失败")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}
	}

	_, err = dao.Rewards.Ctx(ctx).Where(do.Rewards{Id: in.Id}).Delete()
	if err != nil {
		return nil, ecode.Fail.Sub("删除失败")
	}

	return &model.RewardDeleteOut{Success: true}, nil
}

// List 奖励列表
func (s *sReward) List(ctx context.Context, in *model.RewardListIn) (out *model.RewardListOut, err error) {
	var list []model.Reward
	orm := dao.Rewards.Ctx(ctx)

	// 根据角色和权限构建查询条件
	switch in.OperatorRole {
	case consts.MerchantRoleCode:
		// 检查商户是否有该门店权限
		exist, err := dao.MerchantAdmins.Ctx(ctx).
			Where(do.MerchantAdmins{Id: in.OperatorId}).
			LeftJoin(
				dao.Stores.Table(),
				fmt.Sprintf(
					"%s.%s = %s.%s",
					dao.MerchantAdmins.Table(), dao.MerchantAdmins.Columns().MerchantId,
					dao.Stores.Table(), dao.Stores.Columns().MerchantId,
				),
			).
			Where(fmt.Sprintf("%s.%s = ?", dao.Stores.Table(), dao.Stores.Columns().Id), in.StoreId).
			Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("检查操作者权限出现异常")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}
		orm = orm.Where(
			fmt.Sprintf("%s.%s = ?", dao.Rewards.Table(), dao.Rewards.Columns().Source),
			1,
		).WhereOr(
			fmt.Sprintf("%s.%s = ?", dao.Rewards.Table(), dao.Rewards.Columns().StoreId),
			in.StoreId,
		)

	case consts.StoreRoleCode:
		// 检查门店是否有权限
		exist, err := dao.StoreAdmins.Ctx(ctx).
			Where(do.StoreAdmins{Id: in.OperatorId}).
			LeftJoin(
				dao.Stores.Table(),
				fmt.Sprintf(
					"%s.%s = %s.%s",
					dao.StoreAdmins.Table(), dao.StoreAdmins.Columns().StoreId,
					dao.Stores.Table(), dao.Stores.Columns().Id,
				),
			).
			Where(fmt.Sprintf("%s.%s = ?", dao.Stores.Table(), dao.Stores.Columns().Id), in.StoreId).
			Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("检查操作者权限出现异常")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}
		orm = orm.Where(
			fmt.Sprintf("%s.%s = ?", dao.Rewards.Table(), dao.Rewards.Columns().Source),
			1,
		).WhereOr(
			fmt.Sprintf("%s.%s = ?", dao.Rewards.Table(), dao.Rewards.Columns().StoreId),
			in.StoreId,
		)
	}

	if in.Status != 0 {
		orm = orm.Where(do.Rewards{Status: in.Status})
	}
	if in.StoreId != 0 {
		orm = orm.Where(do.Rewards{StoreId: in.StoreId})
	}
	if in.RewardTypeId != 0 {
		orm = orm.Where(do.Rewards{RewardTypeId: in.RewardTypeId})
	}
	if in.Name != "" {
		orm = orm.WhereLike(dao.Rewards.Columns().Name, "%"+in.Name+"%")
	}

	total, err := orm.Count()
	if err != nil {
		return nil, err
	}
	err = orm.Page(in.Page, in.Size).LeftJoin(
		dao.RewardTypes.Table(),
		fmt.Sprintf(
			"%s.%s = %s.%s",
			dao.Rewards.Table(), dao.Rewards.Columns().RewardTypeId,
			dao.RewardTypes.Table(), dao.RewardTypes.Columns().Id,
		),
	).Fields(fmt.Sprintf("%s.*, %s.%s %s", dao.Rewards.Table(), dao.RewardTypes.Table(), dao.RewardTypes.Columns().Name, "reward_type_name")).OrderDesc(dao.Rewards.Columns().CreatedAt).Scan(&list)
	if err != nil {
		return nil, err
	}
	return &model.RewardListOut{
		List:  list,
		Total: total,
	}, nil
}