CaiWuXiTong/app/Business/WithdrawalManagementReport.php

<?php

namespace App\Business;

use App\Models\Business\StoreReceivingAccount;
use Illuminate\Http\Request;
use Illuminate\Support\Collection;
use Modules\EcommerceFinance\Repositories\JushuitanShopBalanceRepository;

class WithdrawalManagementReport
{
    private const SORT_FIELDS = [
        'platform',
        'erp_store_name',
        'store_id',
        'store_entity',
        'withdrawal_path',
        'withdrawal_account',
        'bank_card',
        'balance',
        'reserve_standard',
        'withdrawal_amount',
        'compliance',
    ];

    public function __construct(
        private readonly JushuitanShopBalanceRepository $shopBalances,
    ) {
    }

    /**
     * @return array{
     *     filters:array{platform:string,withdrawalPath:string,storeEntity:string,keyword:string,balanceStatus:string},
     *     platforms:list<string>,paths:list<string>,storeEntities:list<string>,rows:Collection<int,StoreReceivingAccount>,
     *     balances:array<int,array{status:string,balance:?float,source_store_name:?string,source_platform:?string}>,
     *     reserveStandards:array<int,int|null>,summary:array{source:int,matched:int,ambiguous:int,unmatched:int,not_ready:int},
     *     balanceColumnLabel:string,balanceDate:string,sort:array{field:string,direction:string}
     * }
     */
    public function results(Request $request): array
    {
        $filters = $this->filters($request);
        $sort = $this->sorting($request);
        $platforms = $this->options('store_platform');
        $paths = $this->options('receiving_method');
        $storeEntities = $this->options('store_entity_name');
        $query = StoreReceivingAccount::query();

        if ($filters['platform'] !== '') {
            $query->where('store_platform', $filters['platform']);
        }
        if ($filters['withdrawalPath'] !== '') {
            $query->where('receiving_method', $filters['withdrawalPath']);
        }
        if ($filters['storeEntity'] !== '') {
            $query->where('store_entity_name', $filters['storeEntity']);
        }
        if ($filters['keyword'] !== '') {
            $query->where('store_name', 'like', '%' . addcslashes($filters['keyword'], '%_\\') . '%');
        }

        $today = now()->startOfDay();
        $balanceDate = $today->copy()->subDay()->toDateString();
        $rows = $query->orderByDesc('id')->get();
        $balances = $this->shopBalances->matchesForStores($rows, $balanceDate);
        $balanceCounts = collect($balances)->countBy(
            static fn (array $match): string => $match['status'],
        );

        if ($filters['balanceStatus'] !== '') {
            $rows = $rows->filter(
                static fn (StoreReceivingAccount $row): bool => ($balances[(int) $row->id]['status'] ?? 'not_ready') === $filters['balanceStatus'],
            );
        }

        $reserveStandards = $rows->mapWithKeys(
            static fn (StoreReceivingAccount $row): array => [
                (int) $row->id => WithdrawalReserveStandard::amountFor(
                    $row->store_platform,
                    $row->erp_store_name,
                ),
            ],
        )->all();
        $rows = $sort['field'] === ''
            ? $this->sortByBalanceStatus($rows, $balances)
            : $this->sortRows($rows, $sort, $balances, $reserveStandards);

        return [
            'filters' => $filters,
            'platforms' => $platforms,
            'paths' => $paths,
            'storeEntities' => $storeEntities,
            'rows' => $rows,
            'balances' => $balances,
            'reserveStandards' => $reserveStandards,
            'summary' => [
                'source' => $this->shopBalances->countForDate($balanceDate),
                'matched' => (int) $balanceCounts->get('matched', 0),
                'ambiguous' => (int) $balanceCounts->get('ambiguous', 0),
                'unmatched' => (int) $balanceCounts->get('unmatched', 0),
                'not_ready' => (int) $balanceCounts->get('not_ready', 0),
            ],
            'balanceColumnLabel' => $today->format('n月j日') . '店铺余额',
            'balanceDate' => $balanceDate,
            'sort' => $sort,
        ];
    }

    /** @return array{platform:string,withdrawalPath:string,storeEntity:string,keyword:string,balanceStatus:string} */
    public function filters(Request $request): array
    {
        $clean = static fn (mixed $value, int $length = 80): string => mb_substr(trim((string) $value), 0, $length);
        $balanceStatus = $clean($request->query('balance_status'));

        if (! in_array($balanceStatus, ['matched', 'unmatched', 'ambiguous', 'not_ready'], true)) {
            $balanceStatus = '';
        }

        return [
            'platform' => $clean($request->query('platform')),
            'withdrawalPath' => $clean($request->query('withdrawal_path')),
            'storeEntity' => $clean($request->query('store_entity'), 191),
            'keyword' => $clean($request->query('keyword'), 191),
            'balanceStatus' => $balanceStatus,
        ];
    }

    /** @return list<string> */
    private function options(string $column): array
    {
        return StoreReceivingAccount::query()
            ->whereNotNull($column)
            ->where($column, '<>', '')
            ->distinct()
            ->orderBy($column)
            ->pluck($column)
            ->filter()
            ->values()
            ->all();
    }

    /** @return array{field:string,direction:string} */
    private function sorting(Request $request): array
    {
        $field = trim((string) $request->query('sort'));
        $direction = strtolower(trim((string) $request->query('direction')));

        return [
            'field' => in_array($field, self::SORT_FIELDS, true) ? $field : '',
            'direction' => in_array($direction, ['asc', 'desc'], true) ? $direction : 'asc',
        ];
    }

    /**
     * @param Collection<int,StoreReceivingAccount> $rows
     * @param array<int,array{status:string,balance:?float,source_store_name:?string,source_platform:?string}> $balances
     * @return Collection<int,StoreReceivingAccount>
     */
    private function sortByBalanceStatus(Collection $rows, array $balances): Collection
    {
        $statusOrder = ['matched' => 0, 'ambiguous' => 1, 'unmatched' => 2, 'not_ready' => 3];

        return $rows->sort(
            static function (StoreReceivingAccount $left, StoreReceivingAccount $right) use ($balances, $statusOrder): int {
                $leftStatus = $balances[(int) $left->id]['status'] ?? 'not_ready';
                $rightStatus = $balances[(int) $right->id]['status'] ?? 'not_ready';
                $statusComparison = ($statusOrder[$leftStatus] ?? 99) <=> ($statusOrder[$rightStatus] ?? 99);

                return $statusComparison !== 0
                    ? $statusComparison
                    : ((int) $right->id <=> (int) $left->id);
            },
        )->values();
    }

    /**
     * @param Collection<int,StoreReceivingAccount> $rows
     * @param array{field:string,direction:string} $sort
     * @param array<int,array{status:string,balance:?float,source_store_name:?string,source_platform:?string}> $balances
     * @param array<int,int|null> $reserveStandards
     * @return Collection<int,StoreReceivingAccount>
     */
    private function sortRows(Collection $rows, array $sort, array $balances, array $reserveStandards): Collection
    {
        return $rows->sort(function (StoreReceivingAccount $left, StoreReceivingAccount $right) use ($sort, $balances, $reserveStandards): int {
            $leftValue = $this->sortValue($left, $sort['field'], $balances, $reserveStandards);
            $rightValue = $this->sortValue($right, $sort['field'], $balances, $reserveStandards);
            $comparison = $this->compareSortValues($leftValue, $rightValue, $sort['direction']);

            return $comparison !== 0
                ? $comparison
                : ((int) $right->id <=> (int) $left->id);
        })->values();
    }

    /**
     * @param array<int,array{status:string,balance:?float,source_store_name:?string,source_platform:?string}> $balances
     * @param array<int,int|null> $reserveStandards
     */
    private function sortValue(StoreReceivingAccount $row, string $field, array $balances, array $reserveStandards): mixed
    {
        return match ($field) {
            'platform' => $row->store_platform,
            'erp_store_name' => $row->erp_store_name,
            'store_id' => $row->store_id,
            'store_entity' => $row->store_entity_name,
            'withdrawal_path' => $row->withdrawal_path,
            'withdrawal_account' => $row->withdrawal_account_name,
            'bank_card' => $row->bank_card_last_four,
            'balance' => ($balances[(int) $row->id]['status'] ?? null) === 'matched'
                ? $balances[(int) $row->id]['balance']
                : null,
            'reserve_standard' => $reserveStandards[(int) $row->id] ?? null,
            default => null,
        };
    }

    private function compareSortValues(mixed $left, mixed $right, string $direction): int
    {
        $leftEmpty = $left === null || $left === '';
        $rightEmpty = $right === null || $right === '';
        if ($leftEmpty || $rightEmpty) {
            return $leftEmpty === $rightEmpty ? 0 : ($leftEmpty ? 1 : -1);
        }

        $comparison = is_numeric($left) && is_numeric($right)
            ? ((float) $left <=> (float) $right)
            : strnatcasecmp((string) $left, (string) $right);

        return $direction === 'desc' ? -$comparison : $comparison;
    }
}