<?php

namespace App\Service\v3\Implementations;

use App\Constants\v3\OrderState;
use App\Service\v3\Interfaces\BadgeServiceInterface;
use Hyperf\Redis\Redis;
use Hyperf\Utils\ApplicationContext;

class BadgeService implements BadgeServiceInterface
{

    /**
     * @inheritDoc
     */
    public function doByOrder($userId, $storeIds, $globalOrderId, $orderState)
    {

        switch ($orderState) {
            case OrderState::UNPAID: # 待付款（用户）
                $this->sAddUserOrder('unpaid', $userId, $globalOrderId);
                break;

            case OrderState::CANCELED: # 订单取消（用户）
                $this->sAddUserOrder('canceled', $userId, $globalOrderId);

                foreach ($storeIds as $key => &$storeId) {
                    $this->sAddStoreOrder('canceled', $storeId, $globalOrderId);
                }
                break;

            case OrderState::PAID: # 已付款（用户）
                $this->sAddUserOrder('receiving', $userId, $globalOrderId);

                foreach ($storeIds as $key => &$storeId) {
                    $this->sAddStoreOrder('paid', $storeId, $globalOrderId);
                }
                break;

            case OrderState::REFUNDING: # 用户申请退款
            case OrderState::REFUNDED: # 后台同意退款
            case OrderState::REFUND_REFUSE: # 后台拒绝退款
                $this->sAddUserOrder('refund', $userId, $globalOrderId);

                foreach ($storeIds as $key => &$storeId) {
                    $this->sAddStoreOrder('refund', $storeId, $globalOrderId);
                }
                break;

            case OrderState::REJECTION: # 后台拒单（后台）
                $this->sAddUserOrder('rejection', $userId, $globalOrderId);

                foreach ($storeIds as $key => &$storeId) {
                    $this->sAddStoreOrder('rejection', $storeId, $globalOrderId);
                }
                break;

            case OrderState::DELIVERY: # 后台接单（后台）
                $this->sAddUserOrder('receiving', $userId, $globalOrderId);

                foreach ($storeIds as $key => &$storeId) {
                    $this->sAddStoreOrder('delivery', $storeId, $globalOrderId);
                }
                break;

            case OrderState::COMPLETED: # 订单完成（用户或后台操作）
            case OrderState::EVALUATED: # 订单评价（用户）
                $this->sAddUserOrder('finish', $userId, $globalOrderId);

                foreach ($storeIds as $key => &$storeId) {
                    $this->sAddStoreOrder('finish', $storeId, $globalOrderId);
                }
                break;
        }
    }

    public function allByUserOrder($userId)
    {
        $redis = ApplicationContext::getContainer()->get(Redis::class);
        return [
            'unpaid'    => count($redis->sMembers('badge_unpaid_user_'.$userId)),
            'receiving' => count($redis->sMembers('badge_receiving_user_'.$userId)),
            'finish' => count($redis->sMembers('badge_finish_user_'.$userId)),
            'refund'    => count($redis->sMembers('badge_refund_user_'.$userId)),
            'canceled'  => count($redis->sMembers('badge_canceled_user_'.$userId)),
            'rejection' => count($redis->sMembers('badge_rejection_store_'.$userId)),
        ];
    }

    /**
     * @inheritDoc
     */
    public function allByStoreOrder($storeId)
    {
        $redis = ApplicationContext::getContainer()->get(Redis::class);
        return [
            'paid'      => count($redis->sMembers('badge_paid_store_'.$storeId)),
            'delivery'  => count($redis->sMembers('badge_delivery_store_'.$storeId)),
            'finish' => count($redis->sMembers('badge_canceled_store_'.$storeId)),
            'refund'    => count($redis->sMembers('badge_refund_store_'.$storeId)),
            'canceled'  => count($redis->sMembers('badge_canceled_store_'.$storeId)),
            'rejection' => count($redis->sMembers('badge_rejection_store_'.$storeId)),
        ];
    }

    /**
     * @inheritDoc
     */
    public function sAddUserOrder($badge, $userId, $globalOrderId)
    {
        $redis = ApplicationContext::getContainer()->get(Redis::class);
        $redis->sRem('badge_unpaid_user_'.$userId, $globalOrderId); # 移除用户待付款
        $redis->sRem('badge_receiving_user_'.$userId, $globalOrderId); # 移除用户待收货
        $redis->sRem('badge_finish_user_'.$userId, $globalOrderId); # 移除用户已完成
        $redis->sRem('badge_canceled_user_'.$userId, $globalOrderId); # 移除用户已取消
        $redis->sRem('badge_refund_user_'.$userId, $globalOrderId); # 移除用户退款售后
        $redis->sRem('badge_rejection_store_', $userId, $globalOrderId); # 移除用户拒单
        $redis->sAdd('badge_'.$badge.'_user_'.$userId, $globalOrderId); # 新增用户当前状态的值
    }

    /**
     * @inheritDoc
     */
    public function sAddStoreOrder($badge, $storeId, $globalOrderId)
    {
        $redis = ApplicationContext::getContainer()->get(Redis::class);
        $redis->sRem('badge_paid_store_'.$storeId, $globalOrderId); # 移除商户待接单
        $redis->sRem('badge_delivery_store_'.$storeId, $globalOrderId); # 移除商户待送达
        $redis->sRem('badge_finish_store_'.$storeId, $globalOrderId); # 移除商户已完成
        $redis->sRem('badge_canceled_store_'.$storeId, $globalOrderId); # 移除商户已取消
        $redis->sRem('badge_refund_store_'.$storeId, $globalOrderId); # 移除商户退款售后
        $redis->sRem('badge_rejection_store_', $storeId, $globalOrderId); # 移除商户拒单
        $redis->sAdd('badge_'.$badge.'_store_'.$storeId, $globalOrderId); # 新增用户当前状态的值
    }

    /**
     * @inheritDoc
     */
    public function clearUserOrder($userId, $badge = 'all')
    {
        $redis = ApplicationContext::getContainer()->get(Redis::class);
        if ($badge == 'all') {
            $redis->del('badge_unpaid_user_'.$userId); # 移除用户待付款
            $redis->del('badge_receiving_user_'.$userId); # 移除用户待收货
            $redis->del('badge_finish_user_'.$userId); # 移除用户已完成
            $redis->del('badge_canceled_user_'.$userId); # 移除用户已取消
            $redis->del('badge_refund_user_'.$userId); # 移除用户退款售后
            $redis->del('badge_rejection_store_', $userId); # 移除用户拒单
        } else {
            $redis->del('badge_'.$badge.'_user_'.$userId);
        }
    }

    /**
     * @inheritDoc
     */
    public function clearStoreOrder($storeId, $badge = 'all')
    {
        $redis = ApplicationContext::getContainer()->get(Redis::class);
        if ($badge == 'all') {
            $redis->del('badge_paid_user_'.$storeId); # 移除商户待付款
            $redis->del('badge_delivery_user_'.$storeId); # 移除商户待收货
            $redis->del('badge_finish_user_'.$storeId); # 移除商户已完成
            $redis->del('badge_canceled_user_'.$storeId); # 移除商户已取消
            $redis->del('badge_refund_user_'.$storeId); # 移除商户退款售后
            $redis->del('badge_rejection_store_', $storeId); # 移除商户拒单
        } else {
            $redis->del('badge_'.$badge.'_user_'.$storeId);
        }
    }
}