<?php

namespace App\Http\Controllers\Business;

use App\Business\SystemizationTodoAuditLogger;
use App\Business\SystemizationTodoWorkbookImporter;
use App\Models\Business\SystemizationTodo;
use App\Models\Business\SystemizationTodoAttachment;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Routing\Controller;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;
use Illuminate\Validation\Rule;
use Symfony\Component\HttpFoundation\StreamedResponse;
use Throwable;

class SystemizationTodos extends Controller
{
    private const OVERDUE_FILTER = '__overdue__';
    private const REMINDER_OPTIONS = [
        'overdue' => '已逾期',
        'today' => '今天到期',
        'upcoming' => '剩余天数',
        'pending' => '时间待定',
        'none' => '已完成',
    ];
    private const OWNER_OPTIONS = ['人参', '常仪', '晨曦', '待定'];
    private const ASSIGNEE_OPTIONS = [
        '人参',
        '苏木',
        '李斯',
        '周生辰',
        '常仪',
        '玉兔',
        '山时',
        '杳杳',
        '林冲',
        '惠兰',
        '晨曦',
        '栎阳',
        '秋香',
        '待定',
    ];
    private const COLUMN_WIDTHS_SETTING = 'business.systemization_todos.column_widths';
    private const COLUMN_WIDTH_KEYS = [
        'type',
        'section',
        'sequence',
        'title',
        'owner',
        'assignee',
        'start_date',
        'due_date',
        'reminder',
        'status',
        'progress_notes',
    ];
    private const GRID_EDITABLE_FIELDS = [
        'category',
        'section',
        'title',
        'owner',
        'assignee',
        'start_date',
        'due_date',
        'status',
        'progress',
    ];
    private const FILTER_QUERY_KEYS = [
        'status' => 'status',
        'reminder' => 'reminder',
        'category' => 'category',
        'owners' => 'owner',
        'assignees' => 'assignee',
        'start_date' => 'start_date',
        'due_date' => 'due_date',
        'keyword' => 'keyword',
    ];
    private const OWNER_ALIASES = [
        '人参' => '人参',
        '苏木' => '人参',
        '李斯' => '人参',
        '周生辰' => '人参',
        '晨曦' => '晨曦',
        '栎阳' => '晨曦',
        '秋香' => '晨曦',
        '常仪' => '常仪',
        '玉兔' => '常仪',
        '山时' => '常仪',
        '林冲' => '常仪',
        '杳杳' => '常仪',
        '待定' => '待定',
    ];

    public function __construct(
        private readonly SystemizationTodoAuditLogger $audit,
    ) {
    }

    public function page(): array
    {
        $filters = $this->filters();
        $sequenceMap = $this->hierarchySequenceMap();
        $items = $this->decorateGridItems($this->filteredItems($filters), $sequenceMap);
        $positionGroups = $this->positionGroups($sequenceMap);

        $summary = $this->todoSummary();
        $categories = SystemizationTodo::query()
            ->whereNotNull('category')
            ->where('category', '<>', '')
            ->distinct()
            ->orderBy('category')
            ->pluck('category');
        $statusOptions = collect();
        foreach (SystemizationTodo::STATUSES as $status) {
            $statusOptions->push([
                'value' => $status,
                'label' => $status,
            ]);
        }
        $todoAssignees = $this->peopleOptions('assignee');

        return [
            'view' => 'business.pages.systemization-todos',
            'title' => '系统化待办',
            'items' => $items,
            'todoPositionGroups' => $positionGroups,
            'todoFilters' => $filters,
            'todoCategories' => $categories,
            'todoContentOptions' => $this->contentOptions(),
            'todoOwners' => collect(self::OWNER_OPTIONS),
            'todoAssignees' => $todoAssignees,
            'todoAssigneeOptions' => collect(self::ASSIGNEE_OPTIONS),
            'todoAssigneeOwners' => $this->assigneeOwnerMap($todoAssignees),
            'todoStatuses' => SystemizationTodo::STATUSES,
            'todoStatusOptions' => $statusOptions,
            'todoReminderOptions' => collect(self::REMINDER_OPTIONS)
                ->map(static fn (string $label, string $value): array => [
                    'value' => $value,
                    'label' => $label,
                ])
                ->values(),
            'todoReturnFilters' => base64_encode(json_encode(
                $filters,
                JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES,
            )),
            'todoColumnWidths' => $this->columnWidths(),
            'todoSummary' => $summary,
            'todoRoutes' => [
                'store' => route('business.systemization-todos.store'),
                'update' => route('business.systemization-todos.update', ['todo' => '__TODO__']),
                'category' => route('business.systemization-todos.category', ['todo' => '__TODO__']),
                'section' => route('business.systemization-todos.section', ['todo' => '__TODO__']),
                'destroy' => route('business.systemization-todos.destroy', ['todo' => '__TODO__']),
                'attachment' => route('business.systemization-todos.attachments.show', [
                    'todo' => '__TODO__',
                    'attachment' => '__ATTACHMENT__',
                ]),
                'import' => route('business.systemization-todos.import'),
                'history' => route('business.systemization-todos.history'),
                'historyExport' => route('business.systemization-todos.history.export'),
                'columnWidths' => route('business.systemization-todos.column-widths'),
                'gridCells' => route('business.systemization-todos.grid-cells'),
                'gridMove' => route('business.systemization-todos.grid-move', ['todo' => '__TODO__']),
                'gridInsert' => route('business.systemization-todos.grid-insert', ['todo' => '__TODO__']),
                'gridCreate' => route('business.systemization-todos.grid-create'),
                'gridUpload' => route('business.systemization-todos.grid-upload', ['todo' => '__TODO__']),
            ],
        ];
    }

    /**
     * @param  array<string, mixed>  $filters
     * @return Collection<int, SystemizationTodo>
     */
    private function filteredItems(array $filters): Collection
    {
        $query = SystemizationTodo::query()
            ->with('attachments')
            ->withCount('attachments');

        if ($filters['status'] === self::OVERDUE_FILTER) {
            $query->where('status', '<>', SystemizationTodo::STATUS_COMPLETED)
                ->whereNotNull('due_date')
                ->whereDate('due_date', '<', today());
        } elseif ($filters['status'] === SystemizationTodo::STATUS_INCOMPLETE) {
            $query->where('status', '<>', SystemizationTodo::STATUS_COMPLETED);
        } elseif ($filters['status'] === SystemizationTodo::STATUS_COMPLETED) {
            $query->where('status', $filters['status']);
        }
        if ($filters['reminder'] !== '') {
            if ($filters['reminder'] === 'overdue') {
                $query->where('status', '<>', SystemizationTodo::STATUS_COMPLETED)
                    ->whereNotNull('due_date')
                    ->whereDate('due_date', '<', today());
            } elseif ($filters['reminder'] === 'today') {
                $query->where('status', '<>', SystemizationTodo::STATUS_COMPLETED)
                    ->whereDate('due_date', today());
            } elseif ($filters['reminder'] === 'upcoming') {
                $query->where('status', '<>', SystemizationTodo::STATUS_COMPLETED)
                    ->whereDate('due_date', '>', today());
            } elseif ($filters['reminder'] === 'pending') {
                $query->where('status', '<>', SystemizationTodo::STATUS_COMPLETED)
                    ->whereNull('due_date');
            } elseif ($filters['reminder'] === 'none') {
                $query->where('status', SystemizationTodo::STATUS_COMPLETED);
            }
        }
        if ($filters['category'] !== '') {
            $query->where('category', $filters['category']);
        }
        if ($filters['owners'] !== []) {
            $query->where(function ($builder) use ($filters): void {
                foreach ($filters['owners'] as $owner) {
                    $this->applyOwnerFilter($builder, $owner);
                }
            });
        }
        if ($filters['assignees'] !== []) {
            $query->where(function ($builder) use ($filters): void {
                foreach ($filters['assignees'] as $assignee) {
                    $builder->orWhere(
                        'assignee',
                        'like',
                        '%' . addcslashes($assignee, '%_\\') . '%',
                    );
                }
            });
        }
        if ($filters['start_date'] !== '') {
            $query->whereDate('start_date', $filters['start_date']);
        }
        if ($filters['due_date'] !== '') {
            $query->whereDate('due_date', $filters['due_date']);
        }
        if ($filters['keyword'] !== '') {
            $like = '%' . addcslashes($filters['keyword'], '%_\\') . '%';
            $query->where(function ($builder) use ($like): void {
                $builder->where('title', 'like', $like)
                    ->orWhere('category', 'like', $like)
                    ->orWhere('section', 'like', $like)
                    ->orWhere('owner', 'like', $like)
                    ->orWhere('assignee', 'like', $like)
                    ->orWhere('progress', 'like', $like);
            });
        }

        return $query
            ->select($query->qualifyColumn('*'))
            ->orderBy('sort_order')
            ->orderBy('id')
            ->get();
    }

    /**
     * @param  Collection<int, SystemizationTodo>  $items
     * @param  array<int, array<string, mixed>>  $sequenceMap
     * @return Collection<int, SystemizationTodo>
     */
    private function decorateGridItems(Collection $items, array $sequenceMap): Collection
    {
        $items->each(function (SystemizationTodo $todo) use ($sequenceMap): void {
            $sequence = $sequenceMap[$todo->id] ?? [
                'type_sequence' => 0,
                'content_sequence' => 0,
                'item_sequence' => 0,
                'order' => PHP_INT_MAX,
                'category_display' => '',
                'section_display' => '',
                'type_count' => 0,
                'content_count' => 0,
            ];
            $todo->setAttribute('type_sequence', $sequence['type_sequence']);
            $todo->setAttribute('content_sequence', $sequence['content_sequence']);
            $todo->setAttribute('item_sequence', $sequence['item_sequence']);
            $todo->setAttribute('hierarchy_order', $sequence['order']);
            $todo->setAttribute('category_display', $sequence['category_display']);
            $todo->setAttribute('section_display', $sequence['section_display']);
            $todo->setAttribute('type_count', $sequence['type_count']);
            $todo->setAttribute('content_count', $sequence['content_count']);
            $todo->setAttribute('status_label', $todo->statusLabel());
            $todo->setAttribute('owner_display', implode('、', $this->ownerNames($todo->owner)));
            $reminder = $todo->reminder();
            $todo->setAttribute('reminder_label', $reminder['label']);
            $todo->setAttribute('reminder_tone', $reminder['tone']);
        });

        return $items->sortBy('hierarchy_order')->values();
    }

    private function todoSummary(): array
    {
        $counts = SystemizationTodo::query()
            ->selectRaw(
                'COUNT(*) AS total, '
                . 'COALESCE(SUM(CASE WHEN status = ? THEN 1 ELSE 0 END), 0) AS completed, '
                . 'COALESCE(SUM(CASE WHEN status <> ? AND due_date IS NOT NULL AND due_date < ? THEN 1 ELSE 0 END), 0) AS overdue',
                [
                    SystemizationTodo::STATUS_COMPLETED,
                    SystemizationTodo::STATUS_COMPLETED,
                    today()->toDateString(),
                ],
            )
            ->first();
        $total = (int) ($counts->total ?? 0);
        $completed = (int) ($counts->completed ?? 0);

        return [
            'total' => $total,
            'incomplete' => max(0, $total - $completed),
            'completed' => $completed,
            'overdue' => (int) ($counts->overdue ?? 0),
        ];
    }

    public function saveColumnWidths(Request $request): JsonResponse
    {
        $ruleKeys = implode(',', self::COLUMN_WIDTH_KEYS);
        $data = $request->validate([
            'widths' => ['required', 'array:' . $ruleKeys],
            'widths.*' => ['required', 'integer', 'min:64', 'max:720'],
        ]);
        $widths = [];
        foreach (self::COLUMN_WIDTH_KEYS as $key) {
            $widths[$key] = (int) $data['widths'][$key];
        }

        setting([
            self::COLUMN_WIDTHS_SETTING => json_encode(
                $widths,
                JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES,
            ),
        ])->save();

        return response()->json(['ok' => true, 'widths' => $widths]);
    }

    private function columnWidths(): ?array
    {
        $encoded = setting(self::COLUMN_WIDTHS_SETTING);
        $widths = is_string($encoded) ? json_decode($encoded, true) : $encoded;
        if (! is_array($widths)) {
            return null;
        }

        $normalized = [];
        foreach (self::COLUMN_WIDTH_KEYS as $key) {
            $width = $widths[$key] ?? null;
            if (! is_int($width) && ! ctype_digit((string) $width)) {
                return null;
            }
            $width = (int) $width;
            if ($width < 64 || $width > 720) {
                return null;
            }
            $normalized[$key] = $width;
        }

        return $normalized;
    }

    private function hierarchySequenceMap(): array
    {
        $todos = SystemizationTodo::query()
            ->orderBy('sort_order')
            ->orderBy('id')
            ->get(['id', 'category', 'section', 'sort_order']);
        $rows = $todos->map(function (SystemizationTodo $todo): array {
            $category = $this->hierarchyLabel($todo->category);
            $section = $this->hierarchyLabel($todo->section);

            return [
                'category_key' => $this->hierarchyGroupKey($category),
                'category_label' => $category,
                'section_key' => $this->hierarchyGroupKey($section),
                'section_label' => $section,
                'sort_order' => (int) $todo->sort_order,
                'id' => (int) $todo->id,
            ];
        })->all();

        $categoryOrder = [];
        $categoryLabels = [];
        $sectionOrder = [];
        $sectionLabels = [];
        $groupedRows = [];
        foreach ($rows as $row) {
            $categoryKey = $row['category_key'];
            $sectionKey = $row['section_key'];
            $categoryOrder[$categoryKey] = min(
                $categoryOrder[$categoryKey] ?? PHP_INT_MAX,
                $row['sort_order'],
            );
            $categoryLabels[$categoryKey] ??= $row['category_label'];
            $sectionOrder[$categoryKey][$sectionKey] = min(
                $sectionOrder[$categoryKey][$sectionKey] ?? PHP_INT_MAX,
                $row['sort_order'],
            );
            $sectionLabels[$categoryKey][$sectionKey] ??= $row['section_label'];
            $groupedRows[$categoryKey][$sectionKey][] = $row;
        }

        $categoryKeys = array_keys($categoryOrder);
        usort($categoryKeys, function (string $left, string $right) use (
            $categoryOrder,
            $categoryLabels,
        ): int {
            return $this->compareHierarchyGroups(
                $left,
                $right,
                $categoryOrder,
                $categoryLabels,
            );
        });

        $sequenceMap = [];
        $hierarchyOrder = 0;
        foreach ($categoryKeys as $categoryIndex => $categoryKey) {
            $typeCount = array_sum(array_map(
                static fn (array $rows): int => count($rows),
                $groupedRows[$categoryKey],
            ));
            $contentKeys = array_keys($sectionOrder[$categoryKey]);
            usort($contentKeys, function (string $left, string $right) use (
                $categoryKey,
                $sectionOrder,
                $sectionLabels,
            ): int {
                return $this->compareHierarchyGroups(
                    $left,
                    $right,
                    $sectionOrder[$categoryKey],
                    $sectionLabels[$categoryKey],
                );
            });

            foreach ($contentKeys as $contentIndex => $contentKey) {
                $contentRows = $groupedRows[$categoryKey][$contentKey];
                usort($contentRows, static fn (array $left, array $right): int =>
                    [$left['sort_order'], $left['id']] <=> [$right['sort_order'], $right['id']]
                );

                foreach ($contentRows as $itemIndex => $row) {
                    $sequenceMap[$row['id']] = [
                        'type_sequence' => $categoryIndex + 1,
                        'content_sequence' => $contentIndex + 1,
                        'item_sequence' => $itemIndex + 1,
                        'order' => $hierarchyOrder++,
                        'category_display' => $row['category_label'],
                        'section_display' => $row['section_label'],
                        'type_count' => $typeCount,
                        'content_count' => count($contentRows),
                    ];
                }
            }
        }

        return $sequenceMap;
    }

    private function positionGroups(array $sequenceMap): array
    {
        $groups = [];
        $todos = SystemizationTodo::query()
            ->orderBy('sort_order')
            ->orderBy('id')
            ->get(['id', 'category', 'section', 'sort_order']);
        foreach ($todos as $todo) {
            $sequence = $sequenceMap[$todo->id] ?? null;
            if ($sequence === null) {
                continue;
            }
            $key = $sequence['type_sequence'] . ':' . $sequence['content_sequence'];
            $groups[$key] ??= [
                'category' => (string) ($todo->category ?? ''),
                'section' => $sequence['section_display'],
                'count' => 0,
            ];
            $groups[$key]['count']++;
        }

        return array_values($groups);
    }

    private function compareHierarchyGroups(
        string $left,
        string $right,
        array $sortOrders,
        array $labels,
    ): int {
        $comparison = ($sortOrders[$left] ?? PHP_INT_MAX) <=> ($sortOrders[$right] ?? PHP_INT_MAX);

        return $comparison !== 0
            ? $comparison
            : strnatcasecmp($labels[$left] ?? '', $labels[$right] ?? '');
    }

    private function hierarchyLabel(?string $value): string
    {
        return trim((string) preg_replace(
            '/(^|\R)\s*(?:\d+|[一二三四五六七八九十百]+)\s*[、,，.．:：;；)）]\s*/u',
            '$1',
            (string) $value,
        ));
    }

    private function hierarchyGroupKey(string $label): string
    {
        $normalized = preg_replace(
            '/[\s\p{Z}\x{200B}\x{FEFF}，,、。．.；;：:！!？?（）()【】\[\]“”"\'‘’「」『』《》—\-_\/]+/u',
            '',
            $label,
        );
        $normalized = (string) $normalized;

        return $normalized === '' ? "\0" : mb_strtolower($normalized);
    }

    public function store(Request $request): RedirectResponse
    {
        $data = $this->validated($request);
        $this->normalizePendingDates($request, $data);
        $data['progress'] = SystemizationTodo::mergeNotesIntoProgress(
            $data['progress'] ?? null,
            $data['notes'] ?? null,
        );
        $data['notes'] = null;
        $this->normalizeOwnerData($data);
        $position = max(1, (int) ($data['position'] ?? 1));
        unset($data['position']);
        $data['company_id'] = (int) company_id();
        $data['created_by'] = user_id();
        $data['updated_by'] = user_id();
        $this->normalizeCompletionDates($data);
        $insertedSequence = $position;
        $todo = DB::transaction(function () use ($data, $position, &$insertedSequence): SystemizationTodo {
            $siblings = $this->contentSiblings($data['category'] ?? null, $data['section'] ?? null);
            $nextOrder = (int) SystemizationTodo::query()->max('sort_order') + 1;
            if ($siblings->isEmpty()) {
                $insertOrder = $nextOrder;
            } elseif ($position <= $siblings->count()) {
                $insertOrder = (int) $siblings[$position - 1]->sort_order;
            } else {
                $insertOrder = (int) $siblings->max('sort_order') + 1;
            }

            SystemizationTodo::query()
                ->where('sort_order', '>=', $insertOrder)
                ->increment('sort_order');
            $insertedSequence = $siblings->isEmpty()
                ? 1
                : min($position, $siblings->count() + 1);

            $todo = SystemizationTodo::query()->create([
                ...$data,
                'sort_order' => $insertOrder,
            ]);
            $this->audit->record(
                'create',
                (int) company_id(),
                (int) $todo->id,
                null,
                $this->audit->snapshot($todo),
                user_id(),
                null,
                ['source' => 'manual'],
            );

            return $todo;
        });
        $this->storeAttachments($request, $todo);

        return $this->backToPage(
            '待办事项已新增为当前内容第 ' . $insertedSequence . ' 条并定位。',
            'success',
            $todo,
            true,
        );
    }

    public function updateCategory(Request $request, SystemizationTodo $todo): RedirectResponse
    {
        $data = $request->validate([
            'category' => ['required', 'string', 'max:100'],
        ]);
        $ids = [];
        DB::transaction(function () use ($todo, $data, &$ids): void {
            $ids = $this->groupTodoIds($todo, false);
            $this->updateGroupField($ids, ['category' => trim($data['category'])]);
        });

        return $this->backToPage(
            '类型已更新，当前类型下的 ' . count($ids) . ' 条待办已同步调整。',
            'success',
            $todo,
        );
    }

    public function updateSection(Request $request, SystemizationTodo $todo): RedirectResponse
    {
        $data = $request->validate([
            'section' => ['required', 'string', 'max:255'],
        ]);
        $ids = [];
        DB::transaction(function () use ($todo, $data, &$ids): void {
            $ids = $this->groupTodoIds($todo, true);
            $this->updateGroupField($ids, ['section' => trim($data['section'])]);
        });

        return $this->backToPage(
            '内容已更新，当前内容下的 ' . count($ids) . ' 条待办已同步调整。',
            'success',
            $todo,
        );
    }

    private function contentSiblings(
        ?string $category,
        ?string $section,
        ?int $excludeId = null,
    ): Collection
    {
        $categoryKey = $this->hierarchyGroupKey($this->hierarchyLabel($category));
        $sectionKey = $this->hierarchyGroupKey($this->hierarchyLabel($section));

        return SystemizationTodo::query()
            ->orderBy('sort_order')
            ->orderBy('id')
            ->lockForUpdate()
            ->get()
            ->filter(fn (SystemizationTodo $todo): bool =>
                (int) $todo->id !== (int) $excludeId
                && $this->hierarchyGroupKey($this->hierarchyLabel($todo->category)) === $categoryKey
                && $this->hierarchyGroupKey($this->hierarchyLabel($todo->section)) === $sectionKey
            )
            ->values();
    }

    private function positionForUpdate(
        SystemizationTodo $todo,
        int $targetPosition,
        array &$data,
    ): void {
        $currentCategoryKey = $this->hierarchyGroupKey($this->hierarchyLabel($todo->category));
        $currentSectionKey = $this->hierarchyGroupKey($this->hierarchyLabel($todo->section));
        $targetCategoryKey = $this->hierarchyGroupKey($this->hierarchyLabel($data['category'] ?? null));
        $targetSectionKey = $this->hierarchyGroupKey($this->hierarchyLabel($data['section'] ?? null));
        $sameGroup = $currentCategoryKey === $targetCategoryKey
            && $currentSectionKey === $targetSectionKey;

        if ($sameGroup) {
            $currentSiblings = $this->contentSiblings($todo->category, $todo->section);
            $currentIndex = $currentSiblings->search(
                static fn (SystemizationTodo $item): bool => (int) $item->id === (int) $todo->id
            );
            if ($currentIndex !== false && $targetPosition === ((int) $currentIndex + 1)) {
                return;
            }
        }

        $siblings = $this->contentSiblings(
            $data['category'] ?? null,
            $data['section'] ?? null,
            (int) $todo->id,
        );
        if ($siblings->isEmpty()) {
            $insertOrder = (int) SystemizationTodo::query()->max('sort_order') + 1;
        } elseif ($targetPosition <= $siblings->count()) {
            $insertOrder = (int) $siblings[$targetPosition - 1]->sort_order;
        } else {
            $insertOrder = (int) $siblings->max('sort_order') + 1;
        }

        SystemizationTodo::query()
            ->where('sort_order', '>=', $insertOrder)
            ->increment('sort_order');
        $data['sort_order'] = $insertOrder;
    }

    private function groupTodoIds(SystemizationTodo $todo, bool $includeSection): array
    {
        $categoryKey = $this->hierarchyGroupKey($this->hierarchyLabel($todo->category));
        $sectionKey = $this->hierarchyGroupKey($this->hierarchyLabel($todo->section));

        return SystemizationTodo::query()
            ->lockForUpdate()
            ->get(['id', 'category', 'section'])
            ->filter(fn (SystemizationTodo $candidate): bool =>
                $this->hierarchyGroupKey($this->hierarchyLabel($candidate->category)) === $categoryKey
                && (! $includeSection
                    || $this->hierarchyGroupKey($this->hierarchyLabel($candidate->section)) === $sectionKey)
            )
            ->pluck('id')
            ->map(static fn (mixed $id): int => (int) $id)
            ->values()
            ->all();
    }

    private function updateGroupField(array $ids, array $data): void
    {
        if ($ids === []) {
            return;
        }

        $todos = SystemizationTodo::query()
            ->whereIn('id', $ids)
            ->lockForUpdate()
            ->get();
        $auditEvents = [];
        foreach ($todos as $todo) {
            $before = $this->audit->snapshot($todo);
            $todo->fill([
                ...$data,
                'updated_by' => user_id(),
            ])->save();
            $auditEvents[] = [
                'company_id' => (int) company_id(),
                'todo_id' => (int) $todo->id,
                'action' => 'update',
                'before' => $before,
                'after' => $this->audit->snapshot($todo),
                'user_id' => user_id(),
                'meta' => ['source' => 'manual', 'scope' => 'group'],
            ];
        }
        $this->audit->recordMany($auditEvents);
    }

    public function update(Request $request, SystemizationTodo $todo): RedirectResponse
    {
        $before = $this->audit->snapshot($todo, true);
        $data = $this->validated($request);
        $this->normalizePendingDates($request, $data);
        $data['progress'] = SystemizationTodo::mergeNotesIntoProgress(
            array_key_exists('progress', $data) ? $data['progress'] : $todo->progress,
            array_key_exists('notes', $data) ? $data['notes'] : $todo->notes,
        );
        $data['notes'] = null;
        $this->normalizeOwnerData($data);
        $targetPosition = max(0, (int) ($data['position'] ?? 0));
        unset($data['position']);
        $data['updated_by'] = user_id();
        $this->normalizeCompletionDates($data);

        $removeIds = collect($request->input('remove_attachments', []))
            ->map(static fn (mixed $id): int => (int) $id)
            ->filter()
            ->unique()
            ->values();
        if ($removeIds->isNotEmpty()) {
            $attachments = $todo->attachments()
                ->where('company_id', (int) company_id())
                ->whereIn('id', $removeIds)
                ->get();
            foreach ($attachments as $attachment) {
                Storage::disk('uploads')->delete($attachment->path);
                $attachment->delete();
            }
        }

        DB::transaction(function () use ($todo, $data, $targetPosition): void {
            $lockedTodo = SystemizationTodo::query()
                ->lockForUpdate()
                ->findOrFail($todo->id);
            if ($targetPosition > 0) {
                $this->positionForUpdate($lockedTodo, $targetPosition, $data);
            }
            $lockedTodo->update($data);
            $todo->setRawAttributes($lockedTodo->getAttributes(), true);
        });
        $this->storeAttachments($request, $todo);
        $todo->refresh();
        $after = $this->audit->snapshot($todo, true);
        if ($before !== $after) {
            $this->audit->record(
                'update',
                (int) company_id(),
                (int) $todo->id,
                $before,
                $after,
                user_id(),
                null,
                ['source' => 'manual'],
            );
        }

        return $this->backToPage('待办事项已更新并定位。', 'success', $todo);
    }

    public function destroy(SystemizationTodo $todo): RedirectResponse
    {
        DB::transaction(function () use ($todo): void {
            $before = $this->audit->snapshot($todo, true);
            $todo->update(['updated_by' => user_id()]);
            $todo->delete();
            $this->audit->record(
                'delete',
                (int) company_id(),
                (int) $todo->id,
                $before,
                null,
                user_id(),
                null,
                ['source' => 'manual'],
            );
        });

        return $this->backToPage('待办事项已删除。');
    }

    public function batchUpdateCells(Request $request): JsonResponse
    {
        $data = $request->validate([
            'changes' => ['required', 'array', 'min:1', 'max:1000'],
            'changes.*.id' => ['required', 'integer'],
            'changes.*.field' => ['required', Rule::in(self::GRID_EDITABLE_FIELDS)],
            'changes.*.value' => ['present', 'nullable', 'string', 'max:10000'],
            'changes.*.original' => ['nullable', 'string', 'max:10000'],
            'changes.*.scope' => ['nullable', Rule::in(['row', 'group'])],
        ]);

        $result = DB::transaction(function () use ($data): array {
            $todos = SystemizationTodo::query()
                ->lockForUpdate()
                ->get()
                ->keyBy(static fn (SystemizationTodo $todo): int => (int) $todo->id);
            $affectedIds = [];
            $changes = [];
            foreach (array_values($data['changes']) as $change) {
                $todo = $todos->get((int) $change['id']);
                if (! $todo instanceof SystemizationTodo) {
                    return ['ok' => false, 'status' => 404, 'message' => '待办不存在。'];
                }

                $field = (string) $change['field'];
                $scope = (string) ($change['scope'] ?? 'row');
                if (! $this->gridFieldSupportsGroupScope($field)) {
                    $scope = 'row';
                }
                $original = $change['original'] ?? null;
                if ($original !== null && ! $this->gridOriginalStillMatches($todo, $field, (string) $original)) {
                    return [
                        'ok' => false,
                        'status' => 409,
                        'message' => '待办已被其他人修改，请刷新后重试。',
                    ];
                }

                $targetIds = [(int) $todo->id];
                if ($scope === 'group') {
                    $targetIds = $this->gridGroupIds($todos, $todo, $field);
                }
                foreach ($targetIds as $targetId) {
                    $affectedIds[$targetId] = true;
                }
                $changes[] = [
                    'field' => $field,
                    'value' => $change['value'],
                    'scope' => $scope,
                    'todo' => $todo,
                ];
            }

            $before = [];
            foreach (array_keys($affectedIds) as $todoId) {
                $before[$todoId] = $this->audit->snapshot($todos->get($todoId));
            }

            foreach ($changes as $change) {
                $targets = $change['scope'] === 'group'
                    ? $this->gridGroupIds($todos, $change['todo'], $change['field'])
                    : [(int) $change['todo']->id];
                foreach ($targets as $targetId) {
                    $todo = $todos->get($targetId);
                    if (! $todo instanceof SystemizationTodo) {
                        continue;
                    }
                    $error = $this->applyGridCellValue($todo, $change['field'], $change['value']);
                    if ($error !== null) {
                        return ['ok' => false, 'status' => 422, 'message' => $error];
                    }
                }
            }

            $changedTodos = [];
            foreach (array_keys($affectedIds) as $todoId) {
                $todo = $todos->get($todoId);
                if (! $todo instanceof SystemizationTodo) {
                    continue;
                }
                $error = $this->normalizeGridTodo($todo, $todoId);
                if ($error !== null) {
                    return ['ok' => false, 'status' => 422, 'message' => $error];
                }
                if (! $todo->isDirty()) {
                    continue;
                }
                $changedTodos[$todoId] = $todo;
            }

            $events = [];
            foreach ($changedTodos as $todoId => $todo) {
                $todo->updated_by = user_id();
                $todo->save();
                $events[] = [
                    'company_id' => (int) company_id(),
                    'todo_id' => (int) $todo->id,
                    'action' => 'update',
                    'before' => $before[$todoId],
                    'after' => $this->audit->snapshot($todo),
                    'user_id' => user_id(),
                    'meta' => ['source' => 'grid'],
                ];
            }
            $this->audit->recordMany($events);

            return [
                'ok' => true,
                'updated_cells' => count($changes),
                'updated_rows' => count($changedTodos),
                'audit_events' => count($events),
            ];
        });

        if (($result['ok'] ?? false) !== true) {
            return response()->json(
                ['message' => (string) ($result['message'] ?? '保存失败。')],
                (int) ($result['status'] ?? 422),
            );
        }

        $result['grid'] = $this->gridRefreshPayload();

        return response()->json($result);
    }

    private function gridRefreshPayload(): array
    {
        $filters = $this->filters();
        $sequenceMap = $this->hierarchySequenceMap();
        $items = $this->decorateGridItems($this->filteredItems($filters), $sequenceMap);
        $categorySpans = $this->gridGroupRowspans(
            $items,
            static fn (SystemizationTodo $todo): string => (string) ((int) $todo->type_sequence),
        );
        $sectionSpans = $this->gridGroupRowspans(
            $items,
            static fn (SystemizationTodo $todo): string => (int) $todo->type_sequence
                . "\0"
                . (int) $todo->content_sequence,
        );

        return [
            'rows' => $items->values()->map(
                static fn (SystemizationTodo $todo, int $index): array => [
                    'id' => (int) $todo->id,
                    'position' => (int) $todo->item_sequence,
                    'content_count' => (int) $todo->content_count,
                    'type_sequence' => (int) $todo->type_sequence,
                    'content_sequence' => (int) $todo->content_sequence,
                    'category' => $todo->category ?? '',
                    'category_display' => $todo->category_display ?: '',
                    'category_span' => $categorySpans[$index] ?? 0,
                    'section' => $todo->section_display ?? '',
                    'section_span' => $sectionSpans[$index] ?? 0,
                    'title' => trim((string) preg_replace(
                        '/^\s*(?:\d+|[一二三四五六七八九十百]+)\s*[、,，.．:：;；)]\s*/u',
                        '',
                        (string) $todo->title,
                    )),
                    'owner' => $todo->owner_display ?? '',
                    'assignee' => $todo->assignee ?? '',
                    'start_date' => $todo->start_date?->format('Y-m-d') ?? '',
                    'start_note' => $todo->start_note ?? '',
                    'due_date' => $todo->due_date?->format('Y-m-d') ?? '',
                    'due_note' => $todo->due_note ?? '',
                    'reminder_label' => $todo->reminder_label,
                    'reminder_tone' => $todo->reminder_tone,
                    'status' => $todo->status_label,
                    'completed_at' => $todo->completed_at?->format('Y-m-d') ?? '',
                    'progress' => $todo->progress ?? '',
                    'progress_display' => $todo->displayProgress(),
                ],
            )->all(),
            'summary' => $this->todoSummary(),
        ];
    }

    /**
     * @param  Collection<int, SystemizationTodo>  $items
     * @return array<int, int>
     */
    private function gridGroupRowspans(Collection $items, callable $key): array
    {
        $spans = array_fill(0, $items->count(), 0);
        $items = $items->values();
        $start = 0;
        $previous = null;

        $applySpan = static function (int $from, int $to) use (&$spans): void {
            if ($to < $from || $to < 0) {
                return;
            }
            $spans[$from] = $to - $from + 1;
        };

        foreach ($items as $index => $item) {
            $current = $key($item);
            if ($index === 0) {
                $previous = $current;
                continue;
            }
            if ($current === $previous) {
                continue;
            }
            $applySpan($start, $index - 1);
            $start = $index;
            $previous = $current;
        }
        if ($items->isNotEmpty()) {
            $applySpan($start, $items->count() - 1);
        }

        return $spans;
    }

    public function moveGridRow(Request $request, SystemizationTodo $todo): JsonResponse
    {
        $data = $request->validate([
            'direction' => ['required', Rule::in(['up', 'down'])],
        ]);

        $result = DB::transaction(function () use ($todo, $data): array {
            $lockedTodo = SystemizationTodo::query()
                ->lockForUpdate()
                ->findOrFail($todo->id);
            $siblings = $this->contentSiblings($lockedTodo->category, $lockedTodo->section);
            $currentIndex = $siblings->search(
                static fn (SystemizationTodo $item): bool => (int) $item->id === (int) $lockedTodo->id
            );
            if ($currentIndex === false) {
                return ['ok' => false, 'status' => 404, 'message' => '待办不存在于当前内容中。'];
            }
            $targetIndex = $data['direction'] === 'up' ? $currentIndex - 1 : $currentIndex + 1;
            if ($targetIndex < 0) {
                return ['ok' => false, 'status' => 422, 'message' => '当前待办已经是首行。'];
            }
            if ($targetIndex >= $siblings->count()) {
                return ['ok' => false, 'status' => 422, 'message' => '当前待办已经是末行。'];
            }

            /** @var SystemizationTodo $target */
            $target = $siblings->get($targetIndex);
            $beforeTodo = $this->audit->snapshot($lockedTodo);
            $beforeTarget = $this->audit->snapshot($target);
            $todoOrder = (int) $lockedTodo->sort_order;
            $targetOrder = (int) $target->sort_order;

            if ($todoOrder === $targetOrder) {
                return [
                    'ok' => false,
                    'status' => 409,
                    'message' => '当前内容存在重复排序位置，请先通过编辑窗口调整顺序。',
                ];
            }

            $lockedTodo->sort_order = $targetOrder;
            $target->sort_order = $todoOrder;
            $lockedTodo->updated_by = user_id();
            $target->updated_by = user_id();
            $lockedTodo->save();
            $target->save();
            $this->audit->recordMany([
                [
                    'company_id' => (int) company_id(),
                    'todo_id' => (int) $lockedTodo->id,
                    'action' => 'update',
                    'before' => $beforeTodo,
                    'after' => $this->audit->snapshot($lockedTodo),
                    'user_id' => user_id(),
                    'meta' => ['source' => 'grid', 'operation' => 'move_' . $data['direction']],
                ],
                [
                    'company_id' => (int) company_id(),
                    'todo_id' => (int) $target->id,
                    'action' => 'update',
                    'before' => $beforeTarget,
                    'after' => $this->audit->snapshot($target),
                    'user_id' => user_id(),
                    'meta' => ['source' => 'grid', 'operation' => 'move_' . $data['direction']],
                ],
            ]);

            return ['ok' => true, 'direction' => $data['direction']];
        });

        if (($result['ok'] ?? false) !== true) {
            return response()->json(
                ['message' => (string) ($result['message'] ?? '移动失败。')],
                (int) ($result['status'] ?? 422),
            );
        }

        return response()->json($result);
    }

    public function insertGridRowAfter(Request $request, SystemizationTodo $todo): JsonResponse
    {
        $filters = $this->filters();
        $filterDefaults = $this->gridFilterDefaults($filters);
        $createdId = DB::transaction(function () use ($todo, $filterDefaults): int {
            $lockedTodo = SystemizationTodo::query()
                ->lockForUpdate()
                ->findOrFail($todo->id);
            $siblings = $this->contentSiblings($lockedTodo->category, $lockedTodo->section);
            $currentIndex = $siblings->search(
                static fn (SystemizationTodo $item): bool => (int) $item->id === (int) $lockedTodo->id
            );
            if ($currentIndex === false) {
                return 0;
            }

            $next = $siblings->get($currentIndex + 1);
            $insertOrder = $next instanceof SystemizationTodo
                ? (int) $next->sort_order
                : (int) $siblings->max('sort_order') + 1;
            if ($next instanceof SystemizationTodo && $insertOrder <= (int) $lockedTodo->sort_order) {
                $insertOrder = (int) $lockedTodo->sort_order + 1;
            }
            SystemizationTodo::query()
                ->where('sort_order', '>=', $insertOrder)
                ->increment('sort_order');

            $created = SystemizationTodo::query()->create([
                'company_id' => (int) company_id(),
                'category' => $lockedTodo->category,
                'section' => $lockedTodo->section,
                'title' => '新待办',
                ...$filterDefaults,
                'start_note' => null,
                'due_note' => null,
                'progress' => null,
                'notes' => null,
                'sort_order' => $insertOrder,
                'created_by' => user_id(),
                'updated_by' => user_id(),
            ]);
            $this->audit->record(
                'create',
                (int) company_id(),
                (int) $created->id,
                null,
                $this->audit->snapshot($created),
                user_id(),
                null,
                ['source' => 'grid', 'operation' => 'insert_after'],
            );

            return (int) $created->id;
        });

        if ($createdId <= 0) {
            return response()->json(['message' => '无法在当前内容中插入新行。'], 422);
        }
        $created = SystemizationTodo::query()->findOrFail($createdId);
        $clearFilters = $this->conflictingFilterQueryKeys($created, $filters);

        return response()->json([
            'ok' => true,
            'id' => $createdId,
            'clear_filters' => $clearFilters,
            'message' => '已插入空白待办行。',
        ]);
    }

    public function createGridRow(Request $request): JsonResponse
    {
        $data = $request->validate([
            'mode' => ['required', Rule::in(['type', 'content', 'todo'])],
            'category' => ['nullable', 'string', 'max:100'],
            'section' => ['nullable', 'string', 'max:255'],
        ]);

        $filters = $this->filters();
        $filterDefaults = $this->gridFilterDefaults($filters);
        $createdId = DB::transaction(function () use ($data, $filterDefaults): int {
            $mode = (string) $data['mode'];
            $category = trim((string) ($data['category'] ?? ''));
            $section = trim((string) ($data['section'] ?? ''));
            if ($mode === 'type') {
                $categories = SystemizationTodo::query()
                    ->whereNotNull('category')
                    ->pluck('category')
                    ->map(fn (mixed $value): string => $this->hierarchyLabel((string) $value));
                $category = $this->nextUniqueGridLabel($categories, '新类型');
                $section = $this->nextUniqueGridLabel(collect(), '新内容');
            } elseif ($mode === 'content') {
                $categoryKey = $this->hierarchyGroupKey($this->hierarchyLabel($category));
                $sections = SystemizationTodo::query()
                    ->whereNotNull('section')
                    ->get(['category', 'section'])
                    ->filter(fn (SystemizationTodo $todo): bool =>
                        $this->hierarchyGroupKey($this->hierarchyLabel($todo->category)) === $categoryKey
                    )
                    ->pluck('section')
                    ->map(fn (mixed $value): string => $this->hierarchyLabel((string) $value));
                $section = $this->nextUniqueGridLabel($sections, '新内容');
            } elseif ($mode === 'todo') {
                $section = trim((string) ($data['section'] ?? ''));
            }
            $category = $category === '' ? null : $category;
            $section = $section === '' ? null : $section;

            if ($mode === 'todo') {
                $siblings = $this->contentSiblings($category, $section);
                $insertOrder = $siblings->isEmpty()
                    ? (int) SystemizationTodo::query()->max('sort_order') + 1
                    : (int) $siblings->max('sort_order') + 1;
            } else {
                $insertOrder = (int) SystemizationTodo::query()->max('sort_order') + 1;
            }
            if ($mode === 'todo') {
                SystemizationTodo::query()
                    ->where('sort_order', '>=', $insertOrder)
                    ->increment('sort_order');
            }

            $created = SystemizationTodo::query()->create([
                'company_id' => (int) company_id(),
                'category' => $category,
                'section' => $section,
                'title' => '新待办',
                ...$filterDefaults,
                'start_note' => null,
                'due_note' => null,
                'progress' => null,
                'notes' => null,
                'sort_order' => $insertOrder,
                'created_by' => user_id(),
                'updated_by' => user_id(),
            ]);
            $this->audit->record(
                'create',
                (int) company_id(),
                (int) $created->id,
                null,
                $this->audit->snapshot($created),
                user_id(),
                null,
                ['source' => 'grid', 'operation' => 'create_' . $mode],
            );

            return (int) $created->id;
        });

        $created = SystemizationTodo::query()->findOrFail($createdId);

        return response()->json([
            'ok' => true,
            'id' => $createdId,
            'clear_filters' => $this->conflictingFilterQueryKeys($created, $filters),
            'message' => '已新增空白待办行。',
        ]);
    }

    private function gridFilterDefaults(array $filters): array
    {
        $status = match (true) {
            $filters['status'] === SystemizationTodo::STATUS_COMPLETED,
            $filters['reminder'] === 'none' => SystemizationTodo::STATUS_COMPLETED,
            default => SystemizationTodo::STATUS_INCOMPLETE,
        };
        $startDate = $filters['start_date'] !== '' ? $filters['start_date'] : null;
        $dueDate = $filters['due_date'] !== '' ? $filters['due_date'] : match ($filters['reminder']) {
            'overdue' => today()->subDay()->toDateString(),
            'today' => today()->toDateString(),
            'upcoming' => today()->addDay()->toDateString(),
            default => null,
        };

        return [
            'owner' => $filters['owners'][0] ?? '待定',
            'assignee' => $filters['assignees'][0] ?? null,
            'start_date' => $startDate,
            'due_date' => $dueDate,
            'status' => $status,
            'completed_at' => $status === SystemizationTodo::STATUS_COMPLETED
                ? ($dueDate ?: today()->toDateString())
                : null,
        ];
    }

    /**
     * @return array<int, string>
     */
    private function conflictingFilterQueryKeys(SystemizationTodo $todo, array $filters): array
    {
        $conflicts = [];
        foreach (self::FILTER_QUERY_KEYS as $filterKey => $queryKey) {
            if ($filters[$filterKey] === '' || $filters[$filterKey] === []) {
                continue;
            }
            $singleFilter = $this->emptyFilters();
            $singleFilter[$filterKey] = $filters[$filterKey];
            if (! $this->todoMatchesFilters($todo, $singleFilter)) {
                $conflicts[] = $queryKey;
            }
        }

        if ($conflicts === [] && ! $this->todoMatchesFilters($todo, $filters)) {
            foreach (self::FILTER_QUERY_KEYS as $filterKey => $queryKey) {
                if ($filters[$filterKey] !== '' && $filters[$filterKey] !== []) {
                    $conflicts[] = $queryKey;
                }
            }
        }

        return array_values(array_unique($conflicts));
    }

    private function todoMatchesFilters(SystemizationTodo $todo, array $filters): bool
    {
        $completed = $todo->statusLabel() === SystemizationTodo::STATUS_COMPLETED;
        $overdue = ! $completed
            && $todo->due_date !== null
            && $todo->due_date->lt(today()->startOfDay());

        if ($filters['status'] === self::OVERDUE_FILTER && ! $overdue) {
            return false;
        }
        if (
            in_array($filters['status'], [
                SystemizationTodo::STATUS_COMPLETED,
                SystemizationTodo::STATUS_INCOMPLETE,
            ], true)
            && $todo->statusLabel() !== $filters['status']
        ) {
            return false;
        }

        $reminderMatches = match ($filters['reminder']) {
            'overdue' => $overdue,
            'today' => ! $completed && $todo->due_date?->isSameDay(today()) === true,
            'upcoming' => ! $completed && $todo->due_date?->gt(today()->startOfDay()) === true,
            'pending' => ! $completed && $todo->due_date === null,
            'none' => $completed,
            default => true,
        };
        if (! $reminderMatches) {
            return false;
        }

        if ($filters['category'] !== '' && (string) $todo->category !== $filters['category']) {
            return false;
        }
        if (
            $filters['owners'] !== []
            && array_intersect($this->ownerNames($todo->owner), $filters['owners']) === []
        ) {
            return false;
        }
        if ($filters['assignees'] !== []) {
            $assignee = (string) ($todo->assignee ?? '');
            $matchedAssignee = collect($filters['assignees'])->contains(
                static fn (string $name): bool => mb_stripos($assignee, $name, 0, 'UTF-8') !== false,
            );
            if (! $matchedAssignee) {
                return false;
            }
        }
        if (
            $filters['start_date'] !== ''
            && $todo->start_date?->format('Y-m-d') !== $filters['start_date']
        ) {
            return false;
        }
        if (
            $filters['due_date'] !== ''
            && $todo->due_date?->format('Y-m-d') !== $filters['due_date']
        ) {
            return false;
        }
        if ($filters['keyword'] !== '') {
            $haystack = implode(' ', [
                (string) ($todo->title ?? ''),
                (string) ($todo->category ?? ''),
                (string) ($todo->section ?? ''),
                (string) ($todo->owner ?? ''),
                (string) ($todo->assignee ?? ''),
                (string) ($todo->progress ?? ''),
            ]);
            if (mb_stripos($haystack, $filters['keyword'], 0, 'UTF-8') === false) {
                return false;
            }
        }

        return true;
    }

    private function emptyFilters(): array
    {
        return [
            'status' => '',
            'reminder' => '',
            'category' => '',
            'owners' => [],
            'assignees' => [],
            'start_date' => '',
            'due_date' => '',
            'keyword' => '',
        ];
    }

    public function uploadGridAttachments(Request $request, SystemizationTodo $todo): JsonResponse
    {
        $request->validate([
            'screenshots' => ['required', 'array', 'min:1', 'max:12'],
            'screenshots.*' => ['file', 'mimes:jpg,jpeg,png,webp', 'max:10240'],
        ]);
        $before = $this->audit->snapshot($todo, true);
        DB::transaction(function () use ($request, $todo): void {
            $this->storeAttachments($request, $todo);
            $todo->update(['updated_by' => user_id()]);
        });
        $todo->refresh();
        $after = $this->audit->snapshot($todo, true);
        $this->audit->record(
            'update',
            (int) company_id(),
            (int) $todo->id,
            $before,
            $after,
            user_id(),
            null,
            ['source' => 'grid', 'operation' => 'upload_attachments'],
        );

        return response()->json([
            'ok' => true,
            'attachment_count' => $after['attachment_count'] ?? 0,
        ]);
    }

    public function destroyGridAttachment(
        SystemizationTodo $todo,
        SystemizationTodoAttachment $attachment,
    ): JsonResponse {
        abort_unless((int) $attachment->systemization_todo_id === (int) $todo->id, 404);
        abort_unless((int) $attachment->company_id === (int) company_id(), 404);

        $before = $this->audit->snapshot($todo, true);
        DB::transaction(function () use ($todo, $attachment): void {
            Storage::disk('uploads')->delete($attachment->path);
            $attachment->delete();
            $todo->update(['updated_by' => user_id()]);
        });
        $todo->refresh();
        $after = $this->audit->snapshot($todo, true);
        $this->audit->record(
            'update',
            (int) company_id(),
            (int) $todo->id,
            $before,
            $after,
            user_id(),
            null,
            ['source' => 'grid', 'operation' => 'delete_attachment'],
        );

        return response()->json([
            'ok' => true,
            'attachment_count' => $after['attachment_count'] ?? 0,
        ]);
    }

    public function history(): JsonResponse
    {
        $from = $this->historyStartAt();
        $events = $this->audit->history(
            (int) company_id(),
            SystemizationTodoAuditLogger::HISTORY_LIMIT,
            $from,
        );

        return response()->json([
            'events' => $events,
            'total' => count($events),
            'limit' => SystemizationTodoAuditLogger::HISTORY_LIMIT,
            'from' => $from,
        ]);
    }

    public function historyExport(Request $request): StreamedResponse
    {
        $action = trim((string) $request->query('action', ''));
        $keyword = trim((string) $request->query('keyword', ''));
        $from = $this->historyStartAt();
        $rows = array_values(array_filter(
            $this->audit->history(
                (int) company_id(),
                SystemizationTodoAuditLogger::HISTORY_LIMIT,
                $from,
            ),
            fn (array $row): bool => $this->historyMatches($row, $action, $keyword),
        ));

        return response()->streamDownload(function () use ($rows): void {
            $handle = fopen('php://output', 'w');
            fwrite($handle, "\xEF\xBB\xBF");
            fputcsv($handle, ['时间', '操作', '类型', '内容', '待办事项', '变更内容', '操作人']);
            foreach ($rows as $row) {
                fputcsv($handle, [
                    $row['at'],
                    $row['action_label'],
                    $row['category'],
                    $row['section'],
                    $row['title'],
                    implode('；', $row['changes']),
                    $row['actor'],
                ]);
            }
            fclose($handle);
        }, '系统化待办_操作记录.csv', [
            'Content-Type' => 'text/csv; charset=UTF-8',
            'Cache-Control' => 'private, no-store',
        ]);
    }

    private function historyStartAt(): string
    {
        return $this->audit->platformNow()->startOfDay()->toDateTimeString();
    }

    private function historyMatches(array $row, string $action, string $keyword): bool
    {
        if ($action !== '' && (string) ($row['action'] ?? '') !== $action) {
            return false;
        }
        if ($keyword === '') {
            return true;
        }

        $haystack = implode(' ', [
            (string) ($row['category'] ?? ''),
            (string) ($row['section'] ?? ''),
            (string) ($row['title'] ?? ''),
            (string) ($row['actor'] ?? ''),
            implode(' ', (array) ($row['changes'] ?? [])),
        ]);

        return mb_stripos($haystack, $keyword, 0, 'UTF-8') !== false;
    }

    public function attachment(SystemizationTodo $todo, SystemizationTodoAttachment $attachment): StreamedResponse
    {
        abort_unless((int) $attachment->systemization_todo_id === (int) $todo->id, 404);
        abort_unless((int) $attachment->company_id === (int) company_id(), 404);

        $disk = Storage::disk('uploads');
        abort_unless($disk->exists($attachment->path), 404, '截图不存在。');

        return $disk->response($attachment->path, $attachment->original_name, [
            'Cache-Control' => 'private, no-store',
            'Content-Type' => $attachment->mime_type,
            'X-Content-Type-Options' => 'nosniff',
        ]);
    }

    public function importWorkbook(
        Request $request,
        SystemizationTodoWorkbookImporter $importer,
    ): RedirectResponse {
        $data = $request->validate([
            'source' => ['required', 'file', 'mimes:xlsx', 'max:20480'],
        ]);

        try {
            $result = $importer->sync(
                $data['source']->getRealPath(),
                (int) company_id(),
                user_id(),
                false,
                $data['source']->getClientOriginalName(),
            );
        } catch (Throwable $exception) {
            report($exception);

            return $this->backToPage('导入失败，请确认工作簿表头、文件格式和内容后重试。', 'error');
        }

        return $this->backToPage(sprintf(
            '同步完成：%s，新增 %d 条，更新 %d 条，保留工作簿外事项 %d 条。',
            $result['sheet'],
            $result['created'],
            $result['updated'],
            $result['retained'],
        ));
    }

    private function filters(): array
    {
        return [
            'status' => $this->normalizeStatusValue(request('status')),
            'reminder' => $this->normalizeReminderValue(request('reminder')),
            'category' => trim((string) request('category', '')),
            'owners' => $this->normalizeOwnerFilterValues($this->peopleFilter('owner')),
            'assignees' => $this->peopleFilter('assignee'),
            'start_date' => $this->normalizeDateValue(request('start_date')),
            'due_date' => $this->normalizeDateValue(request('due_date')),
            'keyword' => trim((string) request('keyword', '')),
        ];
    }

    private function normalizeStatusValue(mixed $value): string
    {
        $status = trim((string) $value);
        if (in_array($status, SystemizationTodo::LEGACY_INCOMPLETE_STATUSES, true)) {
            return SystemizationTodo::STATUS_INCOMPLETE;
        }

        return $status === self::OVERDUE_FILTER
            || in_array($status, SystemizationTodo::STATUSES, true)
            ? $status
            : '';
    }

    private function normalizeReminderValue(mixed $value): string
    {
        $reminder = trim((string) $value);

        return array_key_exists($reminder, self::REMINDER_OPTIONS) ? $reminder : '';
    }

    private function peopleFilter(string $key): array
    {
        return collect((array) request($key, []))
            ->filter(static fn (mixed $value): bool => is_string($value))
            ->map(static fn (string $value): string => trim($value))
            ->filter()
            ->unique()
            ->take(50)
            ->values()
            ->all();
    }

    private function peopleOptions(string $column): Collection
    {
        return SystemizationTodo::query()
            ->whereNotNull($column)
            ->where($column, '<>', '')
            ->pluck($column)
            ->flatMap(static fn (string $value): array => array_map(
                'trim',
                preg_split('/[、,，;；\/]+/u', $value) ?: [],
            ))
            ->filter()
            ->unique()
            ->sort()
            ->values();
    }

    private function assigneeOwnerMap(Collection $assignees): array
    {
        $derived = [];
        SystemizationTodo::query()
            ->whereNotNull('assignee')
            ->where('assignee', '<>', '')
            ->get(['owner', 'assignee'])
            ->each(function (SystemizationTodo $todo) use (&$derived): void {
                $owners = $this->ownerNames($todo->owner);
                foreach ($this->personNames($todo->assignee) as $assignee) {
                    foreach ($owners as $owner) {
                        $derived[$assignee][$owner] = true;
                    }
                }
            });

        $map = [];
        foreach ($assignees as $assignee) {
            if (isset(self::OWNER_ALIASES[$assignee])) {
                $map[$assignee] = [self::OWNER_ALIASES[$assignee]];
                continue;
            }
            $ownerSet = $derived[$assignee] ?? [];
            $map[$assignee] = array_values(array_filter(
                self::OWNER_OPTIONS,
                static fn (string $owner): bool => isset($ownerSet[$owner]),
            ));
        }

        return $map;
    }

    private function personNames(?string $value): array
    {
        return array_values(array_unique(array_filter(
            array_map('trim', preg_split('/[、,，;；\/]+/u', trim((string) $value)) ?: []),
            static fn (string $name): bool => $name !== '' && $name !== '—',
        )));
    }

    private function normalizeOwnerFilterValues(array $owners): array
    {
        return collect($owners)
            ->map(static fn (string $owner): ?string => self::OWNER_ALIASES[$owner] ?? null)
            ->filter()
            ->unique()
            ->values()
            ->all();
    }

    private function applyOwnerFilter($builder, string $owner): void
    {
        $aliases = array_keys(array_filter(
            self::OWNER_ALIASES,
            static fn (string $canonical): bool => $canonical === $owner,
        ));

        if ($aliases !== []) {
            $builder->orWhere(function ($aliasQuery) use ($aliases): void {
                foreach ($aliases as $alias) {
                    $aliasQuery->orWhere(
                        'owner',
                        'like',
                        '%' . addcslashes($alias, '%_\\') . '%',
                    );
                }
            });
        }

        if ($owner !== '待定') {
            return;
        }

        $knownAliases = array_values(array_diff(array_keys(self::OWNER_ALIASES), ['待定']));
        $builder->orWhere(function ($pendingQuery) use ($knownAliases): void {
            $pendingQuery->whereNull('owner')->orWhere('owner', '');
            if ($knownAliases === []) {
                return;
            }

            $pendingQuery->orWhere(function ($unknownQuery) use ($knownAliases): void {
                foreach ($knownAliases as $alias) {
                    $unknownQuery->where(
                        'owner',
                        'not like',
                        '%' . addcslashes($alias, '%_\\') . '%',
                    );
                }
            });
        });
    }

    private function ownerNames(?string $value): array
    {
        $names = collect(preg_split('/[、,，;；\/]+/u', trim((string) $value)) ?: [])
            ->map(static fn (string $name): string => trim($name))
            ->filter(static fn (string $name): bool => $name !== '' && $name !== '—')
            ->map(static fn (string $name): string => self::OWNER_ALIASES[$name] ?? '待定')
            ->unique()
            ->values()
            ->all();

        return $names === [] ? ['待定'] : $names;
    }

    private function normalizeOwnerData(array &$data): void
    {
        if (! array_key_exists('owner', $data)) {
            return;
        }

        $data['owner'] = implode('、', $this->ownerNames($data['owner']));
    }

    private function contentOptions(): array
    {
        $options = [];
        $todos = SystemizationTodo::query()
            ->whereNotNull('section')
            ->where('section', '<>', '')
            ->get(['category', 'section']);
        foreach ($todos as $todo) {
            $category = $this->hierarchyLabel($todo->category);
            $section = $this->hierarchyLabel($todo->section);
            if ($category !== '' && $section !== '') {
                $options[$category][$section] = true;
            }
        }

        foreach ($options as $category => $sections) {
            $labels = array_keys($sections);
            usort($labels, 'strnatcasecmp');
            $options[$category] = $labels;
        }

        return $options;
    }

    private function normalizeDateValue(mixed $value): string
    {
        $value = trim((string) $value);
        if ($value === '') {
            return '';
        }

        $date = \DateTimeImmutable::createFromFormat('!Y-m-d', $value);

        return $date instanceof \DateTimeImmutable && $date->format('Y-m-d') === $value
            ? $value
            : '';
    }

    private function gridFieldSupportsGroupScope(string $field): bool
    {
        return in_array($field, ['category', 'section'], true);
    }

    /**
     * @param  Collection<int, string>  $existing
     */
    private function nextUniqueGridLabel(Collection $existing, string $base): string
    {
        $used = $existing
            ->map(fn (mixed $value): string => $this->hierarchyGroupKey($this->hierarchyLabel((string) $value)))
            ->filter()
            ->flip();
        for ($index = 1; $index <= 10000; $index++) {
            $candidate = $base . ' ' . $index;
            if (! $used->has($this->hierarchyGroupKey($candidate))) {
                return $candidate;
            }
        }

        return $base . ' ' . Str::lower(Str::random(8));
    }

    private function gridOriginalStillMatches(
        SystemizationTodo $todo,
        string $field,
        string $original,
    ): bool {
        $current = match ($field) {
            'category', 'section', 'title' => $this->hierarchyLabel((string) ($todo->{$field} ?? '')),
            'owner' => implode('、', $this->ownerNames($todo->owner)),
            'start_date' => $todo->start_date?->format('Y-m-d') ?? (string) ($todo->start_note ?? ''),
            'due_date' => $todo->due_date?->format('Y-m-d') ?? (string) ($todo->due_note ?? ''),
            'status' => $todo->statusLabel(),
            default => (string) ($todo->{$field} ?? ''),
        };
        $expected = in_array($field, ['category', 'section', 'title'], true)
            ? $this->hierarchyLabel($original)
            : $original;

        return $current === $expected;
    }

    /**
     * @param  Collection<int, SystemizationTodo>  $todos
     * @return array<int, int>
     */
    private function gridGroupIds(
        Collection $todos,
        SystemizationTodo $todo,
        string $field,
    ): array {
        $categoryKey = $this->hierarchyGroupKey($this->hierarchyLabel($todo->category));
        $sectionKey = $this->hierarchyGroupKey($this->hierarchyLabel($todo->section));

        return $todos
            ->filter(function (SystemizationTodo $candidate) use (
                $field,
                $categoryKey,
                $sectionKey,
            ): bool {
                $sameCategory = $this->hierarchyGroupKey(
                    $this->hierarchyLabel($candidate->category)
                ) === $categoryKey;

                return $sameCategory
                    && ($field === 'category'
                        || $this->hierarchyGroupKey(
                            $this->hierarchyLabel($candidate->section)
                        ) === $sectionKey);
            })
            ->keys()
            ->map(static fn (mixed $id): int => (int) $id)
            ->values()
            ->all();
    }

    private function applyGridCellValue(
        SystemizationTodo $todo,
        string $field,
        ?string $value,
    ): ?string {
        $value = str_replace(["\r\n", "\r"], "\n", (string) ($value ?? ''));
        if (in_array($field, ['category', 'section', 'title', 'owner', 'assignee'], true)) {
            $value = trim($value);
        }

        if (in_array($field, ['start_date', 'due_date'], true)) {
            $dateField = $field;
            $noteField = $field === 'start_date' ? 'start_note' : 'due_note';
            $value = trim($value);
            if ($value === '') {
                $todo->{$dateField} = null;
                $todo->{$noteField} = null;
                return null;
            }
            $date = \DateTimeImmutable::createFromFormat('!Y-m-d', $value);
            if ($date instanceof \DateTimeImmutable && $date->format('Y-m-d') === $value) {
                $todo->{$dateField} = $value;
                $todo->{$noteField} = null;
                return null;
            }
            if (preg_match('/^\d{4}-\d{1,2}-\d{1,2}$/', $value) === 1) {
                return $field === 'start_date' ? '开始时间日期格式无效。' : '完成时间日期格式无效。';
            }
            $todo->{$dateField} = null;
            $todo->{$noteField} = $value;
            return null;
        }

        if ($field === 'status') {
            $status = trim($value);
            if (in_array($status, SystemizationTodo::LEGACY_INCOMPLETE_STATUSES, true)) {
                $status = SystemizationTodo::STATUS_INCOMPLETE;
            }
            if (! in_array($status, SystemizationTodo::STATUSES, true)) {
                return '状态只能填写“未完成”或“已完成”。';
            }
            $todo->status = $status;
            return null;
        }

        $todo->{$field} = $value === '' ? null : $value;

        return null;
    }

    private function normalizeGridTodo(SystemizationTodo $todo, int $todoId): ?string
    {
        $title = trim((string) ($todo->title ?? ''));
        if ($title === '') {
            return '待办事项不能为空。';
        }
        $limits = [
            'category' => 100,
            'section' => 255,
            'title' => 5000,
            'owner' => 255,
            'assignee' => 255,
            'progress' => 10000,
            'notes' => 10000,
            'start_note' => 50,
            'due_note' => 50,
        ];
        foreach ($limits as $field => $limit) {
            if (mb_strlen((string) ($todo->{$field} ?? '')) > $limit) {
                return '第 ' . $todoId . ' 条待办的字段内容过长。';
            }
        }

        $todo->title = $title;
        $todo->owner = implode('、', $this->ownerNames($todo->owner));
        $assignees = $this->personNames($todo->assignee);
        $todo->assignee = $assignees === [] ? null : implode('、', $assignees);
        $todo->progress = SystemizationTodo::mergeNotesIntoProgress($todo->progress, $todo->notes);
        $todo->notes = null;

        $startDate = $todo->start_date?->format('Y-m-d');
        $dueDate = $todo->due_date?->format('Y-m-d');
        if ($startDate !== null && $dueDate !== null && $dueDate < $startDate) {
            return '第 ' . $todoId . ' 条待办的完成时间不能早于开始时间。';
        }

        if ($todo->statusLabel() === SystemizationTodo::STATUS_COMPLETED) {
            $todo->status = SystemizationTodo::STATUS_COMPLETED;
            $todo->completed_at = $todo->completed_at?->format('Y-m-d')
                ?: ($dueDate ?: now()->toDateString());
        } else {
            $todo->status = SystemizationTodo::STATUS_INCOMPLETE;
            $todo->completed_at = null;
        }

        return null;
    }

    private function validated(Request $request): array
    {
        return $request->validate([
            'category' => ['nullable', 'string', 'max:100'],
            'section' => ['nullable', 'string', 'max:255'],
            'title' => ['required', 'string', 'max:5000'],
            'position' => ['nullable', 'integer', 'min:1'],
            'owner' => ['nullable', 'string', 'max:255'],
            'assignee' => ['nullable', 'string', 'max:255'],
            'start_date' => ['nullable', 'date_format:Y-m-d'],
            'start_note' => ['nullable', 'string', 'max:50'],
            'start_pending' => ['nullable', 'boolean'],
            'due_date' => ['nullable', 'date_format:Y-m-d', 'after_or_equal:start_date'],
            'due_note' => ['nullable', 'string', 'max:50'],
            'due_pending' => ['nullable', 'boolean'],
            'status' => ['required', Rule::in(SystemizationTodo::STATUSES)],
            'completed_at' => ['nullable', 'date_format:Y-m-d'],
            'progress' => ['nullable', 'string', 'max:10000'],
            'notes' => ['nullable', 'string', 'max:10000'],
            'screenshots' => ['nullable', 'array', 'max:12'],
            'screenshots.*' => ['file', 'mimes:jpg,jpeg,png,webp', 'max:10240'],
            'remove_attachments' => ['nullable', 'array'],
            'remove_attachments.*' => ['integer'],
        ]);
    }

    private function normalizePendingDates(Request $request, array &$data): void
    {
        foreach (['start', 'due'] as $prefix) {
            if ($request->boolean($prefix . '_pending')) {
                $data[$prefix . '_date'] = null;
                $data[$prefix . '_note'] = '待定';
            } elseif (!empty($data[$prefix . '_date'])) {
                $data[$prefix . '_note'] = null;
            }
            unset($data[$prefix . '_pending']);
        }
    }

    private function normalizeCompletionDates(array &$data): void
    {
        $completed = ($data['status'] ?? '') === SystemizationTodo::STATUS_COMPLETED;
        $data['completed_at'] = $completed
            ? (($data['completed_at'] ?? null) ?: ($data['due_date'] ?? null) ?: now()->toDateString())
            : null;
    }

    private function storeAttachments(Request $request, SystemizationTodo $todo): void
    {
        foreach ($request->file('screenshots', []) as $file) {
            $extension = strtolower($file->getClientOriginalExtension());
            $fileName = (string) Str::uuid() . ($extension !== '' ? '.' . $extension : '');
            $path = Storage::disk('uploads')->putFileAs(
                'systemization-todos/' . (int) company_id() . '/' . $todo->id,
                $file,
                $fileName,
            );
            if ($path === false) {
                throw new \RuntimeException('完成截图保存失败。');
            }

            SystemizationTodoAttachment::query()->create([
                'company_id' => (int) company_id(),
                'systemization_todo_id' => $todo->id,
                'path' => $path,
                'original_name' => mb_substr(basename($file->getClientOriginalName()), 0, 240),
                'mime_type' => $file->getMimeType() ?: 'application/octet-stream',
                'size' => $file->getSize() ?: 0,
                'uploaded_by' => user_id(),
            ]);
        }
    }

    private function backToPage(
        string $message,
        string $type = 'success',
        ?SystemizationTodo $focus = null,
        bool $clearConflictingFilters = false,
    ): RedirectResponse
    {
        $parameters = [
            'section' => 'other',
            'page' => 'systemization-todos',
        ];
        $filters = $this->returnedFilters();
        $parameters = array_merge($parameters, $filters);
        if ($focus) {
            $parameters['highlight'] = $focus->id;
            if ($clearConflictingFilters) {
                $conflicts = $this->conflictingFilterQueryKeys(
                    $focus,
                    $this->filtersFromQuery($filters),
                );
                foreach ($conflicts as $conflict) {
                    unset($parameters[$conflict]);
                }
                if ($conflicts !== []) {
                    $message = '新行已创建，为显示它已暂时清除冲突筛选';
                }
            }
        }

        return redirect()
            ->route('business.pages.show', $parameters)
            ->with($type === 'success' ? 'success' : 'error', $message);
    }

    private function filtersFromQuery(array $filters): array
    {
        return [
            'status' => $this->normalizeStatusValue($filters['status'] ?? null),
            'reminder' => $this->normalizeReminderValue($filters['reminder'] ?? null),
            'category' => trim((string) ($filters['category'] ?? '')),
            'owners' => $this->normalizeOwnerFilterValues((array) ($filters['owner'] ?? [])),
            'assignees' => collect((array) ($filters['assignee'] ?? []))
                ->filter(static fn (mixed $value): bool => is_string($value))
                ->map(static fn (string $value): string => trim($value))
                ->filter()
                ->unique()
                ->take(50)
                ->values()
                ->all(),
            'start_date' => $this->normalizeDateValue($filters['start_date'] ?? null),
            'due_date' => $this->normalizeDateValue($filters['due_date'] ?? null),
            'keyword' => trim((string) ($filters['keyword'] ?? '')),
        ];
    }

    private function returnedFilters(): array
    {
        $encoded = request('return_filters');
        if (!is_string($encoded) || $encoded === '') {
            return [];
        }

        $json = base64_decode($encoded, true);
        $filters = $json === false ? null : json_decode($json, true);
        if (!is_array($filters)) {
            return [];
        }

        $category = is_string($filters['category'] ?? null)
            ? trim($filters['category'])
            : '';
        $keyword = is_string($filters['keyword'] ?? null)
            ? trim($filters['keyword'])
            : '';
        $owners = collect((array) ($filters['owners'] ?? []))
            ->filter(static fn (mixed $value): bool => is_string($value))
            ->map(static fn (string $value): string => trim($value))
            ->filter()
            ->unique()
            ->take(50)
            ->values()
            ->all();
        $owners = $this->normalizeOwnerFilterValues($owners);
        $assignees = collect((array) ($filters['assignees'] ?? []))
            ->filter(static fn (mixed $value): bool => is_string($value))
            ->map(static fn (string $value): string => trim($value))
            ->filter()
            ->unique()
            ->take(50)
            ->values()
            ->all();

        return array_filter([
            'status' => $this->normalizeStatusValue($filters['status'] ?? null),
            'reminder' => $this->normalizeReminderValue($filters['reminder'] ?? null),
            'category' => $category,
            'owner' => $owners,
            'assignee' => $assignees,
            'start_date' => $this->normalizeDateValue($filters['start_date'] ?? null),
            'due_date' => $this->normalizeDateValue($filters['due_date'] ?? null),
            'keyword' => $keyword,
        ], static fn (mixed $value): bool => $value !== '' && $value !== []);
    }
}