TenantAtlas/apps/platform/app/Filament/Pages/Monitoring/Operations.php

<?php

declare(strict_types=1);

namespace App\Filament\Pages\Monitoring;

use App\Filament\Resources\OperationRunResource;
use App\Filament\Widgets\Operations\OperationsKpiHeader;
use App\Models\OperationRun;
use App\Models\Tenant;
use App\Support\Filament\CanonicalAdminTenantFilterState;
use App\Support\Navigation\CanonicalNavigationContext;
use App\Support\OperateHub\OperateHubShell;
use App\Support\OperationRunOutcome;
use App\Support\OperationRunStatus;
use App\Support\Operations\OperationLifecyclePolicy;
use App\Support\Ui\ActionSurface\ActionSurfaceDeclaration;
use App\Support\Ui\ActionSurface\ActionSurfaceDefaults;
use App\Support\Ui\ActionSurface\Enums\ActionSurfaceInspectAffordance;
use App\Support\Ui\ActionSurface\Enums\ActionSurfaceProfile;
use App\Support\Ui\ActionSurface\Enums\ActionSurfaceSlot;
use App\Support\Ui\ActionSurface\Enums\ActionSurfaceType;
use App\Support\Workspaces\WorkspaceContext;
use BackedEnum;
use Filament\Actions\Action;
use Filament\Facades\Filament;
use Filament\Forms\Concerns\InteractsWithForms;
use Filament\Forms\Contracts\HasForms;
use Filament\Pages\Page;
use Filament\Tables\Concerns\InteractsWithTable;
use Filament\Tables\Contracts\HasTable;
use Filament\Tables\Table;
use Illuminate\Database\Eloquent\Builder;
use UnitEnum;

class Operations extends Page implements HasForms, HasTable
{
    use InteractsWithForms;
    use InteractsWithTable;

    public string $activeTab = 'all';

    /**
     * @var array<string, mixed>|null
     */
    public ?array $navigationContextPayload = null;

    protected static bool $isDiscovered = false;

    protected static string|BackedEnum|null $navigationIcon = 'heroicon-o-queue-list';

    protected static string|UnitEnum|null $navigationGroup = 'Monitoring';

    protected static ?string $title = 'Operations';

    // Must be non-static
    protected string $view = 'filament.pages.monitoring.operations';

    public static function actionSurfaceDeclaration(): ActionSurfaceDeclaration
    {
        return ActionSurfaceDeclaration::forPage(ActionSurfaceProfile::RunLog, ActionSurfaceType::ReadOnlyRegistryReport)
            ->withDefaults(new ActionSurfaceDefaults(
                moreGroupLabel: 'More',
                exportIsDefaultBulkActionForReadOnly: false,
            ))
            ->satisfy(ActionSurfaceSlot::ListHeader, 'Header actions preserve scope context and return navigation for the monitoring operations list.')
            ->satisfy(ActionSurfaceSlot::InspectAffordance, ActionSurfaceInspectAffordance::ClickableRow->value)
            ->exempt(ActionSurfaceSlot::ListBulkMoreGroup, 'Operation runs remain immutable on the monitoring list and intentionally omit bulk actions.')
            ->satisfy(ActionSurfaceSlot::ListEmptyState, 'The empty state explains when no operation runs exist for the active workspace scope.')
            ->exempt(ActionSurfaceSlot::DetailHeader, 'Row navigation opens the canonical tenantless operation detail page, which owns header actions.');
    }

    public function mount(): void
    {
        $this->navigationContextPayload = is_array(request()->query('nav')) ? request()->query('nav') : null;

        $this->applyRequestedTenantScope();

        app(CanonicalAdminTenantFilterState::class)->sync(
            $this->getTableFiltersSessionKey(),
            ['type', 'initiator_name'],
            request(),
        );

        $this->mountInteractsWithTable();
        $this->applyRequestedDashboardPrefilter();
    }

    protected function getHeaderWidgets(): array
    {
        return [
            OperationsKpiHeader::class,
        ];
    }

    /**
     * @return array<Action>
     */
    protected function getHeaderActions(): array
    {
        $operateHubShell = app(OperateHubShell::class);
        $navigationContext = $this->navigationContext();

        $actions = [
            Action::make('operate_hub_scope_operations')
                ->label($operateHubShell->scopeLabel(request()))
                ->color('gray')
                ->disabled(),
        ];

        $activeTenant = $operateHubShell->activeEntitledTenant(request());

        if ($navigationContext?->backLinkLabel !== null && $navigationContext->backLinkUrl !== null) {
            $actions[] = Action::make('operate_hub_back_to_origin_operations')
                ->label($navigationContext->backLinkLabel)
                ->icon('heroicon-o-arrow-left')
                ->color('gray')
                ->url($navigationContext->backLinkUrl);
        } elseif ($activeTenant instanceof Tenant) {
            $actions[] = Action::make('operate_hub_back_to_tenant_operations')
                ->label('Back to '.$activeTenant->name)
                ->icon('heroicon-o-arrow-left')
                ->color('gray')
                ->url(\App\Filament\Pages\TenantDashboard::getUrl(panel: 'tenant', tenant: $activeTenant));
        }

        if ($activeTenant instanceof Tenant) {
            $actions[] = Action::make('operate_hub_show_all_tenants')
                ->label('Show all tenants')
                ->color('gray')
                ->action(function (): void {
                    Filament::setTenant(null, true);

                    app(WorkspaceContext::class)->clearLastTenantId(request());

                    $this->removeTableFilter('tenant_id');

                    $this->redirect('/admin/operations');
                });
        }

        return $actions;
    }

    /**
     * @return array{
     *     scope_label: string,
     *     scope_body: string,
     *     return_label: ?string,
     *     return_body: ?string,
     *     scope_reset_label: ?string,
     *     scope_reset_body: ?string,
     *     inspect_body: string
     * }
     */
    public function landingHierarchySummary(): array
    {
        $operateHubShell = app(OperateHubShell::class);
        $navigationContext = $this->navigationContext();
        $activeTenant = $operateHubShell->activeEntitledTenant(request());

        $returnLabel = null;
        $returnBody = null;

        if ($navigationContext?->backLinkLabel !== null && $navigationContext->backLinkUrl !== null) {
            $returnLabel = $navigationContext->backLinkLabel;
            $returnBody = 'Return to the originating monitoring surface without competing with the current tab, filters, or row inspection flow.';
        } elseif ($activeTenant instanceof Tenant) {
            $returnLabel = 'Back to '.$activeTenant->name;
            $returnBody = 'Return to the tenant dashboard when you need tenant-specific context outside this workspace monitoring landing.';
        }

        return [
            'scope_label' => $operateHubShell->scopeLabel(request()),
            'scope_body' => $activeTenant instanceof Tenant
                ? 'The landing is currently narrowed to one tenant inside the active workspace.'
                : 'The landing is currently showing workspace-wide monitoring across all entitled tenants.',
            'return_label' => $returnLabel,
            'return_body' => $returnBody,
            'scope_reset_label' => $activeTenant instanceof Tenant ? 'Show all tenants' : null,
            'scope_reset_body' => $activeTenant instanceof Tenant
                ? 'Reset the landing back to workspace-wide monitoring when tenant-specific context is no longer needed.'
                : null,
            'inspect_body' => 'Open a run from the table to enter the canonical monitoring detail viewer.',
        ];
    }

    private function navigationContext(): ?CanonicalNavigationContext
    {
        if (! is_array($this->navigationContextPayload)) {
            return CanonicalNavigationContext::fromRequest(request());
        }

        $request = request()->duplicate(query: ['nav' => $this->navigationContextPayload]);

        return CanonicalNavigationContext::fromRequest($request);
    }

    public function updatedActiveTab(): void
    {
        $this->resetPage();
    }

    public function table(Table $table): Table
    {
        return OperationRunResource::table($table)
            ->query(function (): Builder {
                $workspaceId = app(WorkspaceContext::class)->currentWorkspaceId(request());
                $tenantFilter = data_get($this->tableFilters, 'tenant_id.value');

                if (! is_numeric($tenantFilter)) {
                    $tenantFilter = data_get(session()->get($this->getTableFiltersSessionKey(), []), 'tenant_id.value');
                }

                $query = OperationRun::query()
                    ->with('user')
                    ->latest('id')
                    ->when(
                        $workspaceId,
                        fn (Builder $query): Builder => $query->where('workspace_id', (int) $workspaceId),
                    )
                    ->when(
                        ! $workspaceId,
                        fn (Builder $query): Builder => $query->whereRaw('1 = 0'),
                    )
                    ->when(
                        is_numeric($tenantFilter),
                        fn (Builder $query): Builder => $query->where('tenant_id', (int) $tenantFilter),
                    );

                return $this->applyActiveTab($query);
            });
    }

    private function applyRequestedTenantScope(): void
    {
        if (! $this->shouldForceWorkspaceWideTenantScope()) {
            return;
        }

        Filament::setTenant(null, true);

        app(WorkspaceContext::class)->clearLastTenantId(request());
    }

    /**
     * @return array{likely_stale:int,reconciled:int}
     */
    public function lifecycleVisibilitySummary(): array
    {
        $baseQuery = $this->scopedSummaryQuery();

        if (! $baseQuery instanceof Builder) {
            return [
                'likely_stale' => 0,
                'reconciled' => 0,
            ];
        }

        $reconciled = (clone $baseQuery)
            ->whereNotNull('context->reconciliation->reconciled_at')
            ->count();

        $policy = app(OperationLifecyclePolicy::class);
        $likelyStale = (clone $baseQuery)
            ->likelyStale($policy)
            ->count();

        return [
            'likely_stale' => $likelyStale,
            'reconciled' => $reconciled,
        ];
    }

    private function applyActiveTab(Builder $query): Builder
    {
        return match ($this->activeTab) {
            'active' => $query->healthyActive(),
            OperationRun::PROBLEM_CLASS_ACTIVE_STALE_ATTENTION => $query->activeStaleAttention(),
            OperationRun::PROBLEM_CLASS_TERMINAL_FOLLOW_UP => $query->terminalFollowUp(),
            'blocked' => $query->dashboardNeedsFollowUp(),
            'succeeded' => $query
                ->where('status', OperationRunStatus::Completed->value)
                ->where('outcome', OperationRunOutcome::Succeeded->value),
            'partial' => $query
                ->where('status', OperationRunStatus::Completed->value)
                ->where('outcome', OperationRunOutcome::PartiallySucceeded->value),
            'failed' => $query
                ->where('status', OperationRunStatus::Completed->value)
                ->where('outcome', OperationRunOutcome::Failed->value),
            default => $query,
        };
    }

    private function scopedSummaryQuery(): ?Builder
    {
        $workspaceId = app(WorkspaceContext::class)->currentWorkspaceId(request());

        if (! $workspaceId) {
            return null;
        }

        $tenantFilter = data_get($this->tableFilters, 'tenant_id.value');

        if (! is_numeric($tenantFilter)) {
            $tenantFilter = data_get(session()->get($this->getTableFiltersSessionKey(), []), 'tenant_id.value');
        }

        return OperationRun::query()
            ->where('workspace_id', (int) $workspaceId)
            ->when(
                is_numeric($tenantFilter),
                fn (Builder $query): Builder => $query->where('tenant_id', (int) $tenantFilter),
            );
    }

    private function applyRequestedDashboardPrefilter(): void
    {
        if (! $this->shouldForceWorkspaceWideTenantScope()) {
            $requestedTenantId = request()->query('tenant_id');

            if (is_numeric($requestedTenantId)) {
                $tenantId = (string) $requestedTenantId;
                $this->tableFilters['tenant_id']['value'] = $tenantId;
                $this->tableDeferredFilters['tenant_id']['value'] = $tenantId;
            }
        }

        $requestedProblemClass = request()->query('problemClass');

        if (in_array($requestedProblemClass, [
            OperationRun::PROBLEM_CLASS_ACTIVE_STALE_ATTENTION,
            OperationRun::PROBLEM_CLASS_TERMINAL_FOLLOW_UP,
        ], true)) {
            $this->activeTab = (string) $requestedProblemClass;

            return;
        }

        $requestedTab = request()->query('activeTab');

        if (in_array($requestedTab, [
            'all',
            'active',
            'blocked',
            'succeeded',
            'partial',
            'failed',
            OperationRun::PROBLEM_CLASS_ACTIVE_STALE_ATTENTION,
            OperationRun::PROBLEM_CLASS_TERMINAL_FOLLOW_UP,
        ], true)) {
            $this->activeTab = (string) $requestedTab;
        }
    }

    private function shouldForceWorkspaceWideTenantScope(): bool
    {
        return request()->query('tenant_scope') === 'all';
    }
}