<?php
namespace App\Domains\Virtual\Services;

use App\Dicts;
use App\Core\Service;
use Illuminate\Validation\Rule;
use App\Models\Virtual\FlowPool;
use Illuminate\Support\Facades\DB;
use App\Exceptions\NotExistException;
use App\Exceptions\NotAllowedException;
use Illuminate\Support\Facades\Validator;
use App\Domains\Virtual\Services\CompanyService;
use App\Domains\Virtual\Services\PackageService;
use App\Domains\Virtual\Repositories\FlowPoolRepository;
use App\Domains\Virtual\Repositories\FlowPoolCardRepository;
use App\Domains\Virtual\Repositories\FlowPoolMonthRepository;
use App\Domains\Virtual\Repositories\FlowPoolPackageRepository;
use App\Domains\Virtual\Repositories\FlowPoolSettingRepository;

class FlowPoolService extends Service
{
    protected $flowPoolRepository;
    protected $flowPoolPackageRepository;
    protected $flowPoolSettingRepository;
    protected $flowPoolCardRepository;
    protected $flowPoolMonthRepository;

    protected $pools;

    /**
     * 构造函数
     *
     * @return void
     */
    public function __construct(
        FlowPoolRepository $flowPoolRepository,
        FlowPoolPackageRepository $flowPoolPackageRepository,
        FlowPoolSettingRepository $flowPoolSettingRepository,
        FlowPoolCardRepository $flowPoolCardRepository,
        FlowPoolMonthRepository $flowPoolMonthRepository
        ) {
        $this->flowPoolRepository = $flowPoolRepository;
        $this->flowPoolPackageRepository = $flowPoolPackageRepository;
        $this->flowPoolSettingRepository = $flowPoolSettingRepository;
        $this->flowPoolCardRepository = $flowPoolCardRepository;
        $this->flowPoolMonthRepository = $flowPoolMonthRepository;
    }

    /**
     * 流量池列表
     *
     * @param array $conditions
     * @return mixed
     */
    public function index(array $conditions = [])
    {
        $limit = $conditions['limit'] ?? 20;

        $flowPools = $this->flowPoolRepository->withConditions($conditions)
            ->applyConditions()->paginate($limit);

        $packages = $this->flowPoolPackageRepository->withConditions([
            'pool_id' => $flowPools->pluck('id')->toArray(),
        ])->get()->groupBy('pool_id');

        $carrierOperators = app(Dicts::class)->get('carrier_operator');
        $shares = app(Dicts::class)->get('shares');

        $flowPools->map(function ($item) use ($carrierOperators, $shares, $packages) {
            $item->company_name = app(CompanyService::class)->load($item['company_id'])['name'];
            $item->carrier_operator_name = $carrierOperators[$item['carrier_operator']];
            $item->shared_name = $shares[$item['shared']];
            $item->package_ids = $packages[$item->id] ? array_pluck($packages[$item->id], 'package_id') : [];
            $item->real_pool_ids = empty($item->real_pool_ids) ? [] : $item->real_pool_ids;
        });

        return $flowPools;
    }

    /**
     * 存储流量池
     *
     * @param array $attributes
     * @return FlowPool
     */
    public function store(array $attributes = [])
    {
        $rule = [
            'name' => ['required', 'between:2,32', Rule::unique($this->flowPoolRepository->getTable(), 'name')->ignore($attributes['id'])->whereNUll('deleted_at')],
            'carrier_operator' => ['required', 'in:0,1,2,3'],
            'shared' => ['required', 'in:1,2'],
        ];

        $message = [
            'name.required' => '请输入流量池名称',
            'name.between' => '流量池名称长度不合法',
            'name.unique' => '流量池名称已经被其他用户所使用',
            'carrier_operator.required' => '请选择运营商',
            'carrier_operator.in' => '运营商不合法',
            'shared.required' => '请选择共享类型',
            'shared.in' => '共享类型不合法',
        ];

        Validator::validate($attributes, $rule, $message);

        if (empty($attributes['package_ids'])) {
            throw new NotAllowedException('请至少加入一个套餐');
        }

        if (!$attributes['id']) {
            $maxId = FlowPool::withTrashed()->max('id');
            $attributes['id'] = $maxId ? $maxId + 1 : 1;
            $attributes['sn'] = self::sn($attributes['id']);

            DB::transaction(function () use ($attributes) {
                $node = $this->flowPoolRepository->create(array_except($attributes, ['package_ids']));

                foreach ($attributes['package_ids'] as $package_id) {
                    $this->flowPoolPackageRepository->create([
                        'pool_id' => $node->id,
                        'package_id' => $package_id,
                    ]);
                }
            });
        }

        if ($attributes['id']) {
            $node = $this->flowPoolRepository->find($attributes['id']);

            if (!$node) {
                throw new NotExistException('流量池不存在或已删除');
            }

            DB::transaction(function () use ($attributes, $node) {
                $exists = $this->flowPoolPackageRepository->withConditions([
                    'pool_id' => $node->id,
                ])->get()->pluck('package_id')->toArray();

                $this->flowPoolRepository->setModel($node)->update(array_except($attributes, ['package_ids']));

                foreach ($exists as $package_id) {
                    if (!in_array($package_id, $attributes['package_ids'])) {
                        $this->flowPoolPackageRepository->withConditions(['package_id' => $package_id])->delete();
                    }
                }

                foreach ($attributes['package_ids'] as $package_id) {
                    if (!in_array($package_id, $exists)) {
                        $this->flowPoolPackageRepository->create(['pool_id' => $node->id, 'package_id' => $package_id]);
                    }
                }
            });
        }

        return $node;
    }

    /**
     * 删除
     *
     * @return bool
     */
    public function destroy($ids)
    {
        $ids = is_array($ids) ? $ids : [$ids];

        $this->flowPoolRepository->destroy($ids);

        return true;
    }

    public static function sn($id)
    {
        return sprintf('FP%011d', $id);
    }

    public function load($id)
    {
        if (!$this->pools) {
            $this->pools = $this->flowPoolRepository->withTrashed()->get()->keyBy('id');
        }

        return $this->pools[$id];
    }
}