<?php

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\Refactor\Admin\AuthController as AdminAuthController;
use App\Http\Controllers\Refactor\Admin\DashboardController as AdminDashboardController;
use App\Http\Controllers\Refactor\Admin\CustomerController as AdminCustomerController;
use App\Http\Controllers\Refactor\Admin\CustomerDashboardController as AdminCustomerDashboardController;
use App\Http\Controllers\Refactor\Admin\SubscriptionController as AdminSubscriptionController;
use App\Http\Controllers\Refactor\Admin\PlanController as AdminPlanController;
use App\Http\Controllers\Refactor\Admin\SendingServerController as AdminSendingServerController;
use App\Http\Controllers\Refactor\Admin\PaymentGatewayController as AdminPaymentGatewayController;
use App\Http\Controllers\Refactor\Admin\InvoiceController as AdminInvoiceController;
use App\Http\Controllers\Refactor\Admin\CurrencyController as AdminCurrencyController;
use App\Http\Controllers\Refactor\Admin\SendingCreditPlanController as AdminSendingCreditPlanController;
use App\Http\Controllers\Refactor\Admin\AccountController as AdminAccountController;
use App\Http\Controllers\Refactor\Admin\AdminController as AdminAdminController;
use App\Http\Controllers\Refactor\Admin\AdminGroupController as AdminAdminGroupController;
use App\Http\Controllers\Refactor\Admin\BounceHandlerController as AdminBounceHandlerController;
use App\Http\Controllers\Refactor\Admin\FeedbackLoopHandlerController as AdminFeedbackLoopHandlerController;
use App\Http\Controllers\Refactor\Admin\EmailVerificationServerController as AdminEmailVerificationServerController;
use App\Http\Controllers\Refactor\Admin\WarmupStrategyController as AdminWarmupStrategyController;
use App\Http\Controllers\Refactor\Admin\EmailVerificationPlanController as AdminEmailVerificationPlanController;
use App\Http\Controllers\Refactor\Admin\PlanRemoteMappingController as AdminPlanRemoteMappingController;
use App\Http\Controllers\Refactor\Admin\PaymentGatewayRemoteController as AdminPaymentGatewayRemoteController;
use App\Http\Controllers\Refactor\Admin\SettingController as AdminSettingController;
// Admin AI controller imports moved into the acelle/ai plugin's routes.php
// (W4 of the AI-extraction plan).
use App\Http\Controllers\Refactor\Admin\LogController as AdminLogController;
use App\Http\Controllers\Refactor\Admin\NotificationController as AdminNotificationController;
use App\Http\Controllers\Refactor\Admin\SystemEmailTemplateController as AdminSystemEmailTemplateController;
use App\Http\Controllers\Refactor\Admin\FormTemplateController as AdminFormTemplateController;
use App\Http\Controllers\Refactor\Admin\PageTemplateController as AdminPageTemplateController;
use App\Http\Controllers\Refactor\Admin\SystemTemplateController as AdminSystemTemplateController;
use App\Http\Controllers\Refactor\Admin\LanguageController as AdminLanguageController;
use App\Http\Controllers\Refactor\Admin\TemplateController as AdminTemplateController;
use App\Http\Controllers\Refactor\Admin\TranslationController as AdminTranslationController;
use App\Http\Controllers\Refactor\Admin\PluginController as AdminPluginController;
use App\Http\Controllers\Refactor\Admin\GeoIPController as AdminGeoIPController;
use App\Http\Controllers\Refactor\Admin\WebhookController as AdminWebhookController;
use App\Http\Controllers\Refactor\Admin\HttpConfigController as AdminHttpConfigController;
use App\Http\Controllers\Refactor\Admin\SearchController as AdminSearchController;
use App\Http\Controllers\Refactor\Admin\ApiDocController as AdminApiDocController;
use App\Http\Controllers\Refactor\Admin\BlacklistController as AdminBlacklistController;
use App\Http\Controllers\Refactor\Admin\MonitorCampaignController as AdminMonitorCampaignController;
use App\Http\Controllers\Refactor\Admin\VerificationToolController as AdminVerificationToolController;
use App\Http\Controllers\Refactor\Admin\AdminGroup2Controller as AdminAdminGroup2Controller;
use App\Http\Controllers\Refactor\Admin\RoleController as AdminRoleController;
use App\Http\Controllers\Refactor\Admin\Admin2Controller as AdminAdmin2Controller;
use App\Http\Controllers\Refactor\DashboardController;
use App\Http\Controllers\Refactor\CampaignController;
use App\Http\Controllers\Refactor\AccountController;
use App\Http\Controllers\Refactor\MailListController;
use App\Http\Controllers\Refactor\WebsiteController;
use App\Http\Controllers\Refactor\FormController;
use App\Http\Controllers\Refactor\AutomationController;
use App\Http\Controllers\Refactor\SendingController;
use App\Http\Controllers\Refactor\SubscriptionController as RefactorSubscriptionController;
use App\Http\Controllers\Refactor\CheckoutController;
use App\Http\Controllers\Refactor\CustomerPaymentGatewayController;
use App\Http\Controllers\Refactor\FunnelController;
use App\Http\Controllers\Refactor\FunnelStepController;
use App\Http\Controllers\Refactor\FunnelProductController;
use App\Http\Controllers\Refactor\FunnelDomainController;
use App\Http\Controllers\Refactor\FunnelReportController;
use App\Http\Controllers\Refactor\ApiDocController;
use App\Http\Controllers\Refactor\SearchController;
use App\Http\Controllers\Refactor\DemoController;

/*
|--------------------------------------------------------------------------
| Refactor Routes
|--------------------------------------------------------------------------
|
| Routes for the refactored UI. Prefixed with /rui to avoid overriding
| legacy routes. Uses Controllers/Refactor/ namespace — old controllers
| are never modified.
|
*/

// Demo landing page — public/guest (no auth)
Route::group([
    'prefix' => 'rui',
    'middleware' => ['not_installed'],
], function () {
    Route::get('demo', [DemoController::class, 'index'])->name('refactor.demo');
    Route::get('demo/go/{view}', [DemoController::class, 'go'])->name('refactor.demo.go');
});

// Admin login — guest-only (no auth middleware, no subscription check)
// Form still POSTs to /login (existing auth endpoint — no new POST route needed)
Route::group([
    'prefix' => 'admin',
    'middleware' => ['not_installed', 'not_logged_in'],
], function () {
    Route::get('login', [AdminAuthController::class, 'login'])->name('refactor.admin.login');
});

// Login-back — accessible by any authenticated user (customer impersonation return)
// Must NOT require 'backend' middleware since user is logged in as customer
Route::group([
    'prefix' => 'rui',
    'middleware' => ['not_installed', 'auth'],
], function () {
    Route::get('login-back', [\App\Http\Controllers\Refactor\Admin\CustomerController::class, 'loginBack'])->name('refactor.login-back');

    // UI Component Showcase — accessible by both admin-only and customer users
    // (no 'frontend'/'backend' middleware so neither role gets kicked)
    Route::get('ui', function () {
        return view('refactor.pages.ui.showcase');
    })->name('refactor.ui');

    // File Manager UI/UX sample — static mockup for design review, no JS/backend
    Route::get('sample/filebrowser', function () {
        return view('refactor.pages.sample.filebrowser');
    })->name('refactor.sample.filebrowser');

    // Builder RSS proxy — fetches RSS feed server-side to avoid CORS
    // Must be in auth-only group (no frontend/backend) so both admin and customer can use it
    Route::get('builder/rss-proxy', [App\Http\Controllers\Refactor\BuilderRssProxyController::class, 'fetch'])->name('refactor.builder.rss_proxy');

    // QR code renderer (SVG) — generic, reused by mc-deeplink-button (C5
    // messenger W3). Auth-gated; public-facing opt-in waiting pages (W3
    // S3.5/S3.6) will swap to a separate signed-route endpoint.
    Route::get('qr', [App\Http\Controllers\Refactor\QrCodeController::class, 'render'])
        ->middleware('throttle:60,1')
        ->name('refactor.qr');
});

// Sender verify token — public/guest (no auth, email link)
Route::group([
    'prefix' => 'rui',
    'middleware' => ['not_installed'],
], function () {
    Route::get('sending/senders/verify/{token}', [SendingController::class, 'senderVerify'])->name('refactor.sending.sender_verify');
});

// R10 — Ads webhook endpoints.  Public (no auth) — platforms call these.
// Rate-limited to 100/min/IP via `throttle:100,1`.  Signature validation +
// replay protection applied via `ads.verify_webhook_signature` middleware
// on POST routes.  GET verify handshake has no body to sign so skips the
// middleware.
Route::group([
    'prefix' => 'rui/ads/webhooks',
    'middleware' => ['not_installed', 'throttle:100,1'],
], function () {
    Route::get('{platform}/verify', [\App\Http\Controllers\Ads\AdWebhookController::class, 'metaVerify'])
        ->where('platform', 'meta|google|tiktok|linkedin')
        ->name('refactor.ads.webhooks.verify');

    Route::middleware(\App\Http\Middleware\Ads\VerifyAdsWebhookSignature::class)->group(function () {
        Route::post('{platform}/leads', [\App\Http\Controllers\Ads\AdWebhookController::class, 'metaLeadGen'])
            ->where('platform', 'meta')
            ->name('refactor.ads.webhooks.leads');
    });
});

// Embed / public-facing endpoints under /rui/ — must NOT require auth.
// Visitors on a customer's own website load these scripts to render the
// signup popup; forcing them through acelle's login would break every
// embedded form in the wild. Matches the legacy web.php public group
// which had `/websites/{uid}/connect.js` open to everyone.
Route::group([
    'prefix' => 'rui',
    'middleware' => ['not_installed'],
], function () {
    Route::get('websites/{uid}/connect-js', [WebsiteController::class, 'connectJs'])
        ->name('refactor.websites.connect_js');

    // Inactive-website "ping back" handshake — fetched by the script the
    // customer pasted on their site when the website is still inactive.
    // Marks the website connected so the next reload returns the full
    // connect-js payload. Refactor counterpart of legacy
    // `frontend/websites/{uid}/check-js`; full refactor chain — no legacy
    // controller delegation.
    Route::get('websites/{uid}/check-js', [WebsiteController::class, 'checkJs'])
        ->name('refactor.websites.check_js');

    // Settings file (favicon, logo, etc.) — referenced from unauth pages
    // (login layout, builder layout, email). Behind auth it would poison
    // session('url.intended') with an asset URL and strand users on a PNG
    // after login.
    Route::get('settings/file/{filename}', function ($filename) {
        return app(\App\Http\Controllers\SettingController::class)->file(request(), $filename);
    })->name('refactor.settings.file');

    // Visitor-facing subscribe endpoint for embedded HTML forms generated by
    // /rui/lists/{uid}/embedded-form admin page. Customers paste the embed
    // code (form action = this route) into their own website; anonymous
    // visitors POST to it. Was inside the auth group from 2026-03-31 to
    // 2026-05-15 — that 6-week window silently broke every embedded form in
    // production (visitor → 302 /login). Customer identification is derived
    // from $list->customer_id in the controller, so {uid} alone is enough.
    // CSRF exemption: bootstrap/app.php skips `*/embedded-form-*`.
    Route::post('lists/{uid}/embedded-form-subscribe', [MailListController::class, 'embeddedFormSubscribe'])
        ->name('refactor.lists.embedded_form_subscribe');
});

Route::group([
    'prefix' => 'rui',
    'middleware' => ['not_installed', 'auth', 'frontend', 'subscription', '2fa', 'demo_guard'],
], function () {
    // Dashboard moved to no-prefix group below this rui group — paths are
    // /dashboard, /dashboard/chart-data, /dashboard/refresh-cache.

    // Power Search (command palette)
    Route::get('power-search', [SearchController::class, 'search'])->name('refactor.power-search');

    // Flow Library Demo (standalone JS lib showcase — not tied to any automation)
    Route::get('flow-demo', function (\Illuminate\Http\Request $request) {
        $samplesDir = resource_path('fixtures/flow-demo');
        $samples = [];
        foreach (glob($samplesDir . '/data-*.json') as $f) {
            $samples[basename($f, '.json')] = $f;
        }
        ksort($samples);
        if (empty($samples)) abort(500, 'No flow-demo sample fixtures found');

        $current  = isset($samples[$request->sample]) ? $request->sample : 'data-basic';
        $jsonPath = $samples[$current] ?? reset($samples);
        $data     = json_decode(file_get_contents($jsonPath), true);

        return view('refactor.pages.flow-demo', [
            'samples' => array_keys($samples),
            'current' => $current,
            'data'    => $data,
        ]);
    })->name('refactor.flow-demo');

    // Campaigns moved to no-prefix group below this rui group — paths are
    // /campaigns/... not /rui/campaigns/.... See "Campaign Routes (no /rui/ prefix)".

    // Email Templates moved to no-prefix group below — paths are
    // /email-templates/... not /rui/email-templates/....

    // Assets — customer-scope FileBrowser (backed by /api/v1/filemanager/*)
    Route::get('assets', [App\Http\Controllers\Refactor\AssetsController::class, 'index'])->name('refactor.assets.index');

    // AJAX helpers
    Route::get('segments/options', [CampaignController::class, 'segmentOptions'])->name('refactor.segments.options');

    // Account — language switcher
    Route::get('account/languages', [AccountController::class, 'languages'])->name('refactor.account.languages');
    Route::post('account/change-language', [AccountController::class, 'changeLanguage'])->name('refactor.account.changeLanguage');

    // Account — color scheme
    Route::post('account/color-scheme', [AccountController::class, 'saveColorScheme'])->name('refactor.account.color_scheme');

    // Account — tour completion
    Route::post('account/tour-complete', [AccountController::class, 'saveTourComplete'])->name('refactor.account.tour_complete');

    // Account — full settings pages
    Route::match(['get', 'post'], 'account/profile', [AccountController::class, 'profile'])->name('refactor.account.profile');
    Route::match(['get', 'post'], 'account/contact', [AccountController::class, 'contact'])->name('refactor.account.contact');

    // Account — avatar AJAX endpoints (immediate apply, no Save click required)
    Route::post('account/avatar/upload', [AccountController::class, 'avatarUpload'])->name('refactor.account.avatar.upload');
    Route::post('account/avatar/remove', [AccountController::class, 'avatarRemove'])->name('refactor.account.avatar.remove');

    // Account — brand voice (AI inline rewrite, Q10)
    Route::get('account/brand-voice', [\App\Http\Controllers\Refactor\BrandVoiceController::class, 'edit'])->name('refactor.account.brand_voice');
    Route::post('account/brand-voice', [\App\Http\Controllers\Refactor\BrandVoiceController::class, 'update'])->name('refactor.account.brand_voice.update');

    Route::get('account/logs', [AccountController::class, 'logs'])->name('refactor.account.logs');
    Route::get('account/logs/listing', [AccountController::class, 'logsListing'])->name('refactor.account.logs_listing');

    Route::prefix('account/notifications')
        ->name('refactor.account.notifications.')
        ->group(function () {
            $c = \App\Http\Controllers\Refactor\Account\NotificationController::class;
            Route::get('/',          [$c, 'index'])->name('index');
            Route::get('/listing',   [$c, 'listing'])->name('listing');
            Route::get('/dropdown',  [$c, 'dropdown'])->name('dropdown');
            Route::get('/badge',     [$c, 'badge'])->name('badge');
            Route::post('/{id}/read',     [$c, 'markRead'])->name('read');
            Route::post('/{id}/unread',   [$c, 'markUnread'])->name('unread');
            Route::post('/{id}/dismiss',  [$c, 'dismiss'])->name('dismiss');
            Route::post('/read-all',  [$c, 'markAllRead'])->name('read_all');
        });
    Route::get('account/quota', [AccountController::class, 'quota'])->name('refactor.account.quota');
    Route::get('account/billing', [AccountController::class, 'billing'])->name('refactor.account.billing');
    Route::match(['get', 'post'], 'account/billing/edit', [AccountController::class, 'editBillingAddress'])->name('refactor.account.billing_edit');
    Route::get('account/api/renew', [AccountController::class, 'renewToken'])->name('refactor.account.renew_token');

    // Audience overview (must be before lists/{uid} wildcard routes)
    Route::get('audience/overview', [MailListController::class, 'audienceOverview'])->name('refactor.audience.overview');

    // Lists / Audience
    Route::get('lists', [MailListController::class, 'index'])->name('refactor.lists.index');
    Route::get('lists/listing', [MailListController::class, 'listing'])->name('refactor.lists.listing');
    Route::get('lists/perf-stats', [MailListController::class, 'perfStats'])->name('refactor.lists.perf_stats');
    Route::post('lists/{uid}/refresh-cache', [MailListController::class, 'refreshCache'])->name('refactor.lists.refresh_cache');
    Route::match(['get', 'post'], 'lists/copy', [MailListController::class, 'copy'])->name('refactor.lists.copy');
    Route::post('lists/delete', [MailListController::class, 'delete'])->name('refactor.lists.delete');

    // List detail pages
    Route::get('lists/create', [MailListController::class, 'create'])->name('refactor.lists.create');
    Route::post('lists/store', [MailListController::class, 'store'])->name('refactor.lists.store');
    Route::get('lists/{uid}/overview', [MailListController::class, 'overview'])->name('refactor.lists.overview');
    Route::get('lists/{uid}/edit', [MailListController::class, 'edit'])->name('refactor.lists.edit');
    Route::post('lists/{uid}/update', [MailListController::class, 'update'])->name('refactor.lists.update');
    Route::get('lists/{uid}/subscribers', [MailListController::class, 'subscribers'])->name('refactor.lists.subscribers');
    Route::get('lists/{uid}/subscribers/listing', [MailListController::class, 'subscribersListing'])->name('refactor.lists.subscribers_listing');
    // Subscriber bulk actions
    Route::post('lists/{uid}/subscribers/blacklist', [MailListController::class, 'subscriberMoveToBlacklist'])->name('refactor.lists.subscriber_blacklist');
    Route::post('lists/{uid}/subscribers/resend-confirmation', [MailListController::class, 'subscriberResendConfirmation'])->name('refactor.lists.subscriber_resend_confirmation');
    Route::post('lists/{uid}/subscribers/copy', [MailListController::class, 'subscriberCopy'])->name('refactor.lists.subscriber_copy');
    Route::post('lists/{uid}/subscribers/move', [MailListController::class, 'subscriberMove'])->name('refactor.lists.subscriber_move');
    Route::post('lists/{uid}/subscribers/add-tag', [MailListController::class, 'subscriberAddTag'])->name('refactor.lists.subscriber_add_tag');
    Route::post('lists/{uid}/subscribers/remove-tag', [MailListController::class, 'subscriberRemoveTag'])->name('refactor.lists.subscriber_remove_tag');
    Route::post('lists/{uid}/subscribers/assign-values', [MailListController::class, 'subscriberAssignValues'])->name('refactor.lists.subscriber_assign_values');
    Route::post('lists/{uid}/subscribers/bulk-delete', [MailListController::class, 'subscriberBulkDelete'])->name('refactor.lists.subscriber_bulk_delete');
    Route::post('lists/{uid}/subscribers/delete-selected', [MailListController::class, 'subscriberDeleteSelected'])->name('refactor.lists.subscriber_delete_selected');

    // Subscriber CRUD
    Route::get('lists/{uid}/subscribers/create', [MailListController::class, 'subscriberCreate'])->name('refactor.lists.subscriber_create');
    Route::post('lists/{uid}/subscribers/store', [MailListController::class, 'subscriberStore'])->name('refactor.lists.subscriber_store');
    Route::get('lists/{uid}/subscribers/{id}/edit', [MailListController::class, 'subscriberEdit'])->name('refactor.lists.subscriber_edit');
    Route::get('lists/{uid}/subscribers/{id}/card', [MailListController::class, 'subscriberCard'])->name('refactor.lists.subscriber_card');
    Route::post('lists/{uid}/subscribers/{id}/update', [MailListController::class, 'subscriberUpdate'])->name('refactor.lists.subscriber_update');
    Route::post('lists/{uid}/subscribers/{id}/delete', [MailListController::class, 'subscriberDelete'])->name('refactor.lists.subscriber_delete');
    Route::post('lists/{uid}/subscribers/{id}/update-tags', [MailListController::class, 'subscriberUpdateTags'])->name('refactor.lists.subscriber_update_tags');
    Route::post('lists/{uid}/subscribers/{id}/remove-tag', [MailListController::class, 'subscriberRemoveSingleTag'])->name('refactor.lists.subscriber_remove_single_tag');
    Route::post('lists/{uid}/subscribers/{id}/start-verification', [MailListController::class, 'subscriberStartVerification'])->name('refactor.lists.subscriber_start_verification');
    Route::post('lists/{uid}/subscribers/{id}/reset-verification', [MailListController::class, 'subscriberResetVerification'])->name('refactor.lists.subscriber_reset_verification');

    // Subscriber Timeline
    Route::get('lists/{uid}/subscribers/{id}/timeline', [MailListController::class, 'subscriberTimeline'])->name('refactor.lists.subscriber_timeline');
    Route::get('lists/{uid}/subscribers/{id}/timeline/listing', [MailListController::class, 'subscriberTimelineListing'])->name('refactor.lists.subscriber_timeline_listing');

    // Subscriber Export & Import
    Route::get('lists/{uid}/subscribers/export', [MailListController::class, 'subscriberExport'])->name('refactor.lists.subscriber_export');
    Route::get('lists/{uid}/subscribers/import', [MailListController::class, 'subscriberImport'])->name('refactor.lists.subscriber_import');

    // Import wizard popup steps
    Route::get('lists/{uid}/subscribers/import/wizard', [MailListController::class, 'importWizardUpload'])->name('refactor.lists.import_wizard');
    Route::get('lists/{uid}/subscribers/import/mapping', [MailListController::class, 'importWizardMapping'])->name('refactor.lists.import_mapping');
    Route::get('lists/{uid}/subscribers/import/settings', [MailListController::class, 'importWizardSettings'])->name('refactor.lists.import_settings');
    Route::get('lists/{uid}/subscribers/import/progress', [MailListController::class, 'importWizardProgress'])->name('refactor.lists.import_progress');

    Route::get('lists/{uid}/segments', [MailListController::class, 'segments'])->name('refactor.lists.segments');
    Route::get('lists/{uid}/segments/listing', [MailListController::class, 'segmentsListing'])->name('refactor.lists.segments_listing');
    Route::get('lists/{uid}/segments/create', [MailListController::class, 'segmentCreate'])->name('refactor.lists.segment_create');
    Route::post('lists/{uid}/segments/store', [MailListController::class, 'segmentStore'])->name('refactor.lists.segment_store');
    Route::get('lists/{uid}/segments/{seg_uid}/edit', [MailListController::class, 'segmentEdit'])->name('refactor.lists.segment_edit');
    Route::post('lists/{uid}/segments/{seg_uid}/update', [MailListController::class, 'segmentUpdate'])->name('refactor.lists.segment_update');
    Route::post('lists/{uid}/segments/delete', [MailListController::class, 'segmentDelete'])->name('refactor.lists.segment_delete');
    Route::get('lists/{uid}/segments/{seg_uid}/subscribers', [MailListController::class, 'segmentSubscribers'])->name('refactor.lists.segment_subscribers');
    Route::get('lists/{uid}/segments/{seg_uid}/subscribers/listing', [MailListController::class, 'segmentSubscribersListing'])->name('refactor.lists.segment_subscribers_listing');

    // Forms / Pages (list templates)
    Route::get('lists/{uid}/templates', [MailListController::class, 'listTemplates'])->name('refactor.lists.templates');
    Route::get('lists/{uid}/templates/{alias}', [MailListController::class, 'listTemplateUpdate'])->name('refactor.lists.template_update');
    Route::match(['get', 'post'], 'lists/{uid}/embedded-form', [MailListController::class, 'embeddedForm'])->name('refactor.lists.embedded_form');

    // List fields management
    Route::get('lists/{uid}/fields', [MailListController::class, 'fields'])->name('refactor.lists.fields');
    Route::post('lists/{uid}/fields', [MailListController::class, 'fieldsStore'])->name('refactor.lists.fields_store');
    Route::post('lists/{uid}/fields/sort', [MailListController::class, 'fieldsSort'])->name('refactor.lists.fields_sort');
    Route::get('lists/{uid}/fields/{fieldUid}/delete', [MailListController::class, 'fieldDelete'])->name('refactor.lists.field_delete');

    // List email verification
    Route::get('lists/{uid}/verification', [MailListController::class, 'verification'])->name('refactor.lists.verification');

    // Subscriber proxy actions
    Route::post('lists/{uid}/subscribers/subscribe-action', [MailListController::class, 'subscriberSubscribe'])->name('refactor.lists.subscriber_subscribe');
    Route::post('lists/{uid}/subscribers/unsubscribe-action', [MailListController::class, 'subscriberUnsubscribe'])->name('refactor.lists.subscriber_unsubscribe');
    Route::post('subscribers/save-columns', [MailListController::class, 'subscriberSaveColumns'])->name('refactor.lists.subscriber_save_columns');

    // Import proxy
    Route::post('lists/{uid}/subscribers/import-upload', [MailListController::class, 'import2Upload'])->name('refactor.lists.import_upload');
    Route::post('lists/{uid}/subscribers/import-validate', [MailListController::class, 'import2Validate'])->name('refactor.lists.import_validate');
    Route::post('lists/{uid}/subscribers/import-run', [MailListController::class, 'import2Run'])->name('refactor.lists.import_run');
    Route::get('lists/{uid}/subscribers/import-progress', [MailListController::class, 'import2ProgressContent'])->name('refactor.lists.import_progress_content');
    Route::post('lists/subscribers/cancel-import/{job_uid}', [MailListController::class, 'cancelImport'])->name('refactor.lists.cancel_import');
    Route::get('lists/subscribers/download-import-log/{job_uid}', [MailListController::class, 'downloadImportLog'])->name('refactor.lists.download_import_log');

    // Export proxy
    Route::post('lists/{uid}/subscribers/dispatch-export', [MailListController::class, 'dispatchExportJob'])->name('refactor.lists.dispatch_export');
    Route::get('lists/{uid}/subscribers/export-progress/{job_uid}', [MailListController::class, 'exportProgress'])->name('refactor.lists.export_progress');
    Route::post('lists/{uid}/subscribers/cancel-export/{job_uid}', [MailListController::class, 'cancelExport'])->name('refactor.lists.cancel_export');
    Route::get('lists/{uid}/subscribers/download-export/{job_uid}', [MailListController::class, 'downloadExportedFile'])->name('refactor.lists.download_export');

    // List management proxy
    Route::post('lists/{uid}/save-outside-urls', [MailListController::class, 'saveOutsideUrls'])->name('refactor.lists.save_outside_urls');
    Route::post('lists/{uid}/reset-verification', [MailListController::class, 'resetVerification'])->name('refactor.lists.reset_verification');
    Route::post('lists/{uid}/start-verification', [MailListController::class, 'startVerification'])->name('refactor.lists.start_verification');
    // Stray GET (bookmark / paste / browser back-forward) — redirect to the verification page instead of 405
    Route::get('lists/{uid}/start-verification', fn ($uid) => redirect()->route('refactor.lists.verification', ['uid' => $uid]));
    Route::post('lists/{uid}/stop-verification/{job_uid}', [MailListController::class, 'stopVerification'])->name('refactor.lists.stop_verification');
    Route::get('lists/{uid}/verification-progress/{job_uid}', [MailListController::class, 'verificationProgress'])->name('refactor.lists.verification_progress');
    // NOTE: `lists/{uid}/embedded-form-subscribe` is intentionally NOT in this
    // auth group — visitors on customer websites POST anonymously. Defined
    // above in the public /rui/ group (search "refactor.lists.embedded_form_subscribe").

    // Segment proxy
    Route::get('segments/condition-value', [MailListController::class, 'segmentConditionValue'])->name('refactor.lists.segment_condition_value');
    Route::get('lists/{uid}/segments/sample-condition', [MailListController::class, 'segmentSampleCondition'])->name('refactor.lists.segment_sample_condition');

    // MailListTemplate proxy
    Route::get('lists/templates/{uid}/preview', [MailListController::class, 'templatePreview'])->name('refactor.lists.template_preview');
    Route::match(['get', 'post'], 'lists/templates/{uid}/builder', [MailListController::class, 'templateBuilder'])->name('refactor.lists.template_builder');
    Route::match(['get', 'post'], 'lists/templates/{uid}/custom-html', [MailListController::class, 'templateCustomHtml'])->name('refactor.lists.template_custom_html');
    Route::post('lists/templates/{uid}/restore-default', [MailListController::class, 'templateRestoreDefault'])->name('refactor.lists.template_restore_default');

    // Websites
    Route::get('websites', [WebsiteController::class, 'index'])->name('refactor.websites.index');
    Route::get('websites/listing', [WebsiteController::class, 'listing'])->name('refactor.websites.listing');
    Route::get('websites/create', [WebsiteController::class, 'create'])->name('refactor.websites.create');
    Route::post('websites/store', [WebsiteController::class, 'store'])->name('refactor.websites.store');
    Route::get('websites/{uid}/edit', [WebsiteController::class, 'edit'])->name('refactor.websites.edit');
    Route::post('websites/{uid}/update', [WebsiteController::class, 'update'])->name('refactor.websites.update');
    Route::post('websites/delete', [WebsiteController::class, 'delete'])->name('refactor.websites.delete');
    Route::post('websites/{uid}/connect', [WebsiteController::class, 'connect'])->name('refactor.websites.connect');
    Route::post('websites/{uid}/disconnect', [WebsiteController::class, 'disconnect'])->name('refactor.websites.disconnect');
    // NOTE: connect-js route is defined above in the public group — visitors
    // loading the embed script must not be forced through auth middleware.

    // Account — API
    Route::get('account/api', [AccountController::class, 'api'])->name('refactor.account.api');

    // API Documentation (customer)
    Route::get('api-docs', [ApiDocController::class, 'index'])->name('refactor.api-docs');

    // Forms
    Route::get('forms', [FormController::class, 'index'])->name('refactor.forms.index');
    Route::get('forms/listing', [FormController::class, 'listing'])->name('refactor.forms.listing');
    Route::match(['get', 'post'], 'forms/create', [FormController::class, 'create'])->name('refactor.forms.create');
    Route::post('forms/delete', [FormController::class, 'delete'])->name('refactor.forms.delete');
    Route::post('forms/publish', [FormController::class, 'publish'])->name('refactor.forms.publish');
    Route::post('forms/unpublish', [FormController::class, 'unpublish'])->name('refactor.forms.unpublish');
    Route::get('forms/{uid}/preview', [FormController::class, 'preview'])->name('refactor.forms.preview');

    // Automations moved to no-prefix group below this rui group — paths are
    // /automations/... not /rui/automations/.... See "Automation Routes (no /rui/ prefix)".

    // Sending — Servers
    Route::get('sending/servers', [SendingController::class, 'servers'])->name('refactor.sending.servers');
    Route::get('sending/servers/listing', [SendingController::class, 'serversListing'])->name('refactor.sending.servers_listing');
    Route::post('sending/servers/delete', [SendingController::class, 'serversDelete'])->name('refactor.sending.servers_delete');
    Route::get('sending/servers/select', [SendingController::class, 'serverSelect'])->name('refactor.sending.server_select');
    Route::get('sending/servers/create', [SendingController::class, 'serverCreate'])->name('refactor.sending.server_create');
    Route::post('sending/servers/store', [SendingController::class, 'serverStore'])->name('refactor.sending.server_store');
    Route::get('sending/servers/{uid}/edit', [SendingController::class, 'serverEdit'])->name('refactor.sending.server_edit');
    Route::post('sending/servers/{uid}/connection/save', [SendingController::class, 'serverConnectionSave'])->name('refactor.sending.server_connection_save');
    Route::post('sending/servers/{uid}/configuration/save', [SendingController::class, 'serverConfigurationSave'])->name('refactor.sending.server_configuration_save');
    Route::post('sending/servers/{uid}/enable', [SendingController::class, 'serverEnable'])->name('refactor.sending.server_enable');
    Route::post('sending/servers/{uid}/disable', [SendingController::class, 'serverDisable'])->name('refactor.sending.server_disable');
    Route::get('sending/servers/{uid}/test', [SendingController::class, 'serverTest'])->name('refactor.sending.server_test');
    Route::post('sending/servers/{uid}/test-send', [SendingController::class, 'serverTestSend'])->name('refactor.sending.server_test_send');
    Route::post('sending/servers/{uid}/test-connection', [SendingController::class, 'serverTestConnection'])->name('refactor.sending.server_test_connection');

    // Sending — Domains
    Route::get('sending/domains', [SendingController::class, 'domains'])->name('refactor.sending.domains');
    Route::get('sending/domains/listing', [SendingController::class, 'domainsListing'])->name('refactor.sending.domains_listing');
    Route::post('sending/domains/delete', [SendingController::class, 'domainsDelete'])->name('refactor.sending.domains_delete');
    Route::get('sending/domains/create', [SendingController::class, 'domainCreate'])->name('refactor.sending.domain_create');
    Route::post('sending/domains/store', [SendingController::class, 'domainStore'])->name('refactor.sending.domain_store');
    Route::get('sending/domains/{uid}', [SendingController::class, 'domainShow'])->name('refactor.sending.domain_show');
    // Sending domain has no edit/update — value is bound to DKIM keys + DNS records.
    // To change, customer deletes and re-adds.
    Route::post('sending/domains/{uid}/verify', [SendingController::class, 'domainVerify'])->name('refactor.sending.domain_verify');
    Route::get('sending/domains/{uid}/records', [SendingController::class, 'domainRecords'])->name('refactor.sending.domain_records');

    // Sending — Verified Senders
    Route::get('sending/senders', [SendingController::class, 'senders'])->name('refactor.sending.senders');
    Route::get('sending/senders/listing', [SendingController::class, 'sendersListing'])->name('refactor.sending.senders_listing');
    Route::post('sending/senders/delete', [SendingController::class, 'sendersDelete'])->name('refactor.sending.senders_delete');
    Route::get('sending/senders/create', [SendingController::class, 'senderCreate'])->name('refactor.sending.sender_create');
    Route::post('sending/senders/store', [SendingController::class, 'senderStore'])->name('refactor.sending.sender_store');
    Route::get('sending/senders/{uid}', [SendingController::class, 'senderShow'])->name('refactor.sending.sender_show');
    Route::get('sending/senders/{uid}/edit', [SendingController::class, 'senderEdit'])->name('refactor.sending.sender_edit');
    Route::post('sending/senders/{uid}/update', [SendingController::class, 'senderUpdate'])->name('refactor.sending.sender_update');

    // Sending — Tracking Domains
    Route::get('sending/tracking-domains', [SendingController::class, 'trackingDomains'])->name('refactor.sending.tracking_domains');
    Route::get('sending/tracking-domains/listing', [SendingController::class, 'trackingDomainsListing'])->name('refactor.sending.tracking_domains_listing');
    Route::post('sending/tracking-domains/delete', [SendingController::class, 'trackingDomainsDelete'])->name('refactor.sending.tracking_domains_delete');
    Route::get('sending/tracking-domains/create', [SendingController::class, 'trackingDomainCreate'])->name('refactor.sending.tracking_domain_create');
    Route::post('sending/tracking-domains/store', [SendingController::class, 'trackingDomainStore'])->name('refactor.sending.tracking_domain_store');
    Route::get('sending/tracking-domains/{uid}/edit', [SendingController::class, 'trackingDomainEdit'])->name('refactor.sending.tracking_domain_edit');
    Route::post('sending/tracking-domains/{uid}/update', [SendingController::class, 'trackingDomainUpdate'])->name('refactor.sending.tracking_domain_update');
    Route::get('sending/tracking-domains/{uid}/verify', [SendingController::class, 'trackingDomainVerify'])->name('refactor.sending.tracking_domain_verify');
    Route::post('sending/tracking-domains/{uid}/check', [SendingController::class, 'trackingDomainCheck'])->name('refactor.sending.tracking_domain_check');

    // Sending — Email Verification Servers
    Route::get('sending/verification-servers', [SendingController::class, 'verificationServers'])->name('refactor.sending.verification_servers');
    Route::get('sending/verification-servers/listing', [SendingController::class, 'verificationServersListing'])->name('refactor.sending.verification_servers_listing');
    Route::post('sending/verification-servers/delete', [SendingController::class, 'verificationServersDelete'])->name('refactor.sending.verification_servers_delete');
    Route::get('sending/verification-servers/create', [SendingController::class, 'verificationServerCreate'])->name('refactor.sending.verification_server_create');
    Route::post('sending/verification-servers/store', [SendingController::class, 'verificationServerStore'])->name('refactor.sending.verification_server_store');
    Route::get('sending/verification-servers/{uid}/edit', [SendingController::class, 'verificationServerEdit'])->name('refactor.sending.verification_server_edit');
    Route::post('sending/verification-servers/{uid}/update', [SendingController::class, 'verificationServerUpdate'])->name('refactor.sending.verification_server_update');
    Route::post('sending/verification-servers/{uid}/enable', [SendingController::class, 'verificationServerEnable'])->name('refactor.sending.verification_server_enable');
    Route::post('sending/verification-servers/{uid}/disable', [SendingController::class, 'verificationServerDisable'])->name('refactor.sending.verification_server_disable');

    // Sending — Blacklist
    Route::get('sending/blacklist', [SendingController::class, 'blacklist'])->name('refactor.sending.blacklist');
    Route::get('sending/blacklist/listing', [SendingController::class, 'blacklistListing'])->name('refactor.sending.blacklist_listing');
    Route::post('sending/blacklist/delete', [SendingController::class, 'blacklistDelete'])->name('refactor.sending.blacklist_delete');
    Route::post('sending/blacklist/store', [SendingController::class, 'blacklistStore'])->name('refactor.sending.blacklist_store');
    Route::get('sending/blacklist/import', [SendingController::class, 'blacklistImport'])->name('refactor.sending.blacklist_import');
    Route::post('sending/blacklist/start-import', [SendingController::class, 'blacklistStartImport'])->name('refactor.sending.blacklist_start_import');
    Route::get('sending/blacklist/import-progress/{job_uid}', [SendingController::class, 'blacklistImportProgress'])->name('refactor.sending.blacklist_import_progress');
    Route::post('sending/blacklist/cancel-import/{job_uid}', [SendingController::class, 'blacklistCancelImport'])->name('refactor.sending.blacklist_cancel_import');

    // Sending — Signatures
    Route::get('sending/signatures', [SendingController::class, 'signatures'])->name('refactor.sending.signatures');
    Route::get('sending/signatures/listing', [SendingController::class, 'signaturesListing'])->name('refactor.sending.signatures_listing');
    Route::post('sending/signatures/delete', [SendingController::class, 'signaturesDelete'])->name('refactor.sending.signatures_delete');
    Route::get('sending/signatures/create', [SendingController::class, 'signatureCreate'])->name('refactor.sending.signature_create');
    Route::post('sending/signatures/store', [SendingController::class, 'signatureStore'])->name('refactor.sending.signature_store');
    Route::get('sending/signatures/{uid}/edit', [SendingController::class, 'signatureEdit'])->name('refactor.sending.signature_edit');
    Route::post('sending/signatures/{uid}/update', [SendingController::class, 'signatureUpdate'])->name('refactor.sending.signature_update');
    Route::post('sending/signatures/{uid}/set-default', [SendingController::class, 'signatureSetDefault'])->name('refactor.sending.signature_set_default');
    Route::post('sending/signatures/{uid}/enable', [SendingController::class, 'signatureEnable'])->name('refactor.sending.signature_enable');
    Route::post('sending/signatures/{uid}/disable', [SendingController::class, 'signatureDisable'])->name('refactor.sending.signature_disable');

    // Account — Users
    Route::get('account/users', [AccountController::class, 'users'])->name('refactor.account.users');
    Route::get('account/users/listing', [AccountController::class, 'usersListing'])->name('refactor.account.users_listing');
    Route::get('account/users/create', [AccountController::class, 'userCreate'])->name('refactor.account.user_create');
    Route::post('account/users/store', [AccountController::class, 'userStore'])->name('refactor.account.user_store');
    Route::get('account/users/{uid}/edit', [AccountController::class, 'userEdit'])->name('refactor.account.user_edit');
    Route::post('account/users/{uid}/update', [AccountController::class, 'userUpdate'])->name('refactor.account.user_update');
    Route::post('account/users/enable', [AccountController::class, 'userEnable'])->name('refactor.account.user_enable');
    Route::post('account/users/disable', [AccountController::class, 'userDisable'])->name('refactor.account.user_disable');
    Route::post('account/users/delete', [AccountController::class, 'userDelete'])->name('refactor.account.user_delete');

    // Account — Roles
    Route::get('account/roles', [AccountController::class, 'roles'])->name('refactor.account.roles');
    Route::get('account/roles/listing', [AccountController::class, 'rolesListing'])->name('refactor.account.roles_listing');
    Route::get('account/roles/create', [AccountController::class, 'roleCreate'])->name('refactor.account.role_create');
    Route::post('account/roles/store', [AccountController::class, 'roleStore'])->name('refactor.account.role_store');
    Route::get('account/roles/{uid}/edit', [AccountController::class, 'roleEdit'])->name('refactor.account.role_edit');
    Route::post('account/roles/{uid}/update', [AccountController::class, 'roleUpdate'])->name('refactor.account.role_update');
    Route::post('account/roles/delete', [AccountController::class, 'roleDelete'])->name('refactor.account.role_delete');

    // Account — Two-Factor Authentication
    Route::get('account/2fa', [AccountController::class, 'twoFactor'])->name('refactor.account.2fa');
    Route::post('account/2fa/enable', [AccountController::class, 'twoFactorEnable'])->name('refactor.account.2fa_enable');
    Route::post('account/2fa/disable', [AccountController::class, 'twoFactorDisable'])->name('refactor.account.2fa_disable');
    Route::post('account/2fa/google/generate-key', [AccountController::class, 'twoFactorGenerateKey'])->name('refactor.account.2fa_generate_key');
    Route::post('account/2fa/google/save-key', [AccountController::class, 'twoFactorSaveKey'])->name('refactor.account.2fa_save_key');

    // Account — Subscription (overview)
    Route::get('account/subscription', [AccountController::class, 'subscription'])->name('refactor.account.subscription');
    Route::post('account/subscription/refresh-credits', [AccountController::class, 'refreshCredits'])->name('refactor.account.subscription.refresh_credits');

    // Email verification credits
    Route::get('account/email-verification-credits', [AccountController::class, 'emailVerificationCredits'])->name('refactor.account.email_verification_credits');
    Route::get('account/email-verification-credits/select', [AccountController::class, 'emailVerificationSelectPlan'])->name('refactor.account.email_verification_select');
    Route::get('account/email-verification-credits/invoices', [AccountController::class, 'emailVerificationInvoices'])->name('refactor.account.email_verification_invoices');
    Route::get('account/email-verification-credits/payment-intents', [AccountController::class, 'emailVerificationPaymentIntents'])->name('refactor.account.email_verification_payment_intents');

    // Sending credits add-on
    Route::get('account/sending-credits', [AccountController::class, 'sendingCredits'])->name('refactor.account.sending_credits');
    Route::get('account/sending-credits/select', [AccountController::class, 'sendingCreditsSelectPlan'])->name('refactor.account.sending_credits_select');
    Route::get('account/sending-credits/invoices', [AccountController::class, 'sendingCreditsInvoices'])->name('refactor.account.sending_credits_invoices');
    Route::get('account/sending-credits/payment-intents', [AccountController::class, 'sendingCreditsPaymentIntents'])->name('refactor.account.sending_credits_payment_intents');

    // Account proxy actions
    Route::get('account/invoices/{uid}/download', [AccountController::class, 'invoiceDownload'])->name('refactor.account.invoice_download');
    Route::get('account/invoices/{uid}/logs', [AccountController::class, 'invoiceLogs'])->name('refactor.account.invoice_logs');
    Route::post('account/invoices/{uid}/delete', [AccountController::class, 'invoiceDelete'])->name('refactor.account.invoice_delete');
    Route::post('account/email-verification-credits/buy', [AccountController::class, 'buyEmailVerificationPlan'])->name('refactor.account.buy_email_verification');
    Route::post('account/sending-credits/buy', [AccountController::class, 'buySendingCreditPlan'])->name('refactor.account.buy_sending_credit');

    // Subscription Flow — Select plan / Checkout / Change plan
    Route::get('subscription/select-plan', [RefactorSubscriptionController::class, 'selectPlan'])->name('refactor.subscription.select_plan');
    Route::post('subscription/assign-plan', [RefactorSubscriptionController::class, 'assignPlan'])->name('refactor.subscription.assign_plan');
    Route::match(['get','post'], 'subscription/{invoice_uid}/billing-information', [RefactorSubscriptionController::class, 'billingInformation'])->name('refactor.subscription.billing_information');
    Route::get('subscription/payment/{invoice_uid}', [RefactorSubscriptionController::class, 'payment'])->name('refactor.subscription.payment');
    Route::post('subscription/checkout', [RefactorSubscriptionController::class, 'checkout'])->name('refactor.subscription.checkout');
    Route::post('subscription/payment/{invoice_uid}/refresh-price', [RefactorSubscriptionController::class, 'refreshPrice'])->name('refactor.subscription.refresh_price');
    Route::post('subscription/auto-charge', [RefactorSubscriptionController::class, 'autoCharge'])->name('refactor.subscription.auto_charge');
    Route::match(['get','post'], 'subscription/change-plan', [RefactorSubscriptionController::class, 'changePlan'])->name('refactor.subscription.change_plan');
    Route::match(['get','post'], 'subscription/{invoice_uid}/no-payment-confirmation', [RefactorSubscriptionController::class, 'noPaymentConfirmation'])->name('refactor.subscription.no_payment_confirmation');
    Route::post('subscription/disable-recurring', [RefactorSubscriptionController::class, 'disableRecurring'])->name('refactor.subscription.disable_recurring');
    Route::post('subscription/enable-recurring', [RefactorSubscriptionController::class, 'enableRecurring'])->name('refactor.subscription.enable_recurring');
    Route::post('subscription/cancel-now', [RefactorSubscriptionController::class, 'cancelNow'])->name('refactor.subscription.cancel_now');
    Route::post('subscription/invoice/{uid}/cancel', [RefactorSubscriptionController::class, 'cancelInvoice'])->name('refactor.subscription.cancel_invoice');
    Route::get('subscription/order-summary', [RefactorSubscriptionController::class, 'orderSummary'])->name('refactor.subscription.order_summary');

    // Builder export (HTML / ZIP) — generic, auth-gated, no template-type dependency
    Route::post('builder/export/html', [App\Http\Controllers\Refactor\BuilderExportController::class, 'html'])->name('refactor.builder.export.html');
    Route::post('builder/export/zip', [App\Http\Controllers\Refactor\BuilderExportController::class, 'zip'])->name('refactor.builder.export.zip');



    // Builders (clone — views delegate to old builder layouts)
    // email-templates/{uid}/builder + change-template moved to no-prefix group below.
    Route::get('forms/{uid}/builder', [FormController::class, 'builder'])->name('refactor.forms.builder');
    Route::post('forms/{uid}/builder-save', [FormController::class, 'builderSave'])->name('refactor.forms.builder_save');
    Route::post('forms/{uid}/settings', [FormController::class, 'settings'])->name('refactor.forms.settings');
    Route::post('forms/{uid}/change-template', [FormController::class, 'changeTemplate'])->name('refactor.forms.change_template');
    Route::post('forms/{uid}/preview-save', [FormController::class, 'previewSave'])->name('refactor.forms.preview_save');
    Route::get('forms/{uid}/connect', [FormController::class, 'connect'])->name('refactor.forms.connect');
    Route::post('forms/{uid}/connect', [FormController::class, 'connectSave'])->name('refactor.forms.connect.save');
    Route::post('forms/{uid}/disconnect', [FormController::class, 'disconnect'])->name('refactor.forms.disconnect');
    // Automations moved to no-prefix group below this rui group — paths are
    // /automations/... not /rui/automations/.... See "Automation Routes (no /rui/ prefix)".

    // Checkout (verification/sending-credit invoices)
    Route::get('checkout/{invoice_uid}/cart', [CheckoutController::class, 'cart'])->name('refactor.checkout.cart');
    Route::match(['get', 'post'], 'checkout/{invoice_uid}/billing-address', [CheckoutController::class, 'billingAddress'])->name('refactor.checkout.billing_address');
    Route::get('checkout/{invoice_uid}/payment', [CheckoutController::class, 'payment'])->name('refactor.checkout.payment');
    Route::post('checkout/{invoice_uid}/checkout', [CheckoutController::class, 'checkout'])->name('refactor.checkout.checkout');
    Route::post('checkout/{invoice_uid}/cancel', [CheckoutController::class, 'cancel'])->name('refactor.checkout.cancel');

    // Funnels
    Route::get('funnels', [FunnelController::class, 'index'])->name('refactor.funnels.index');
    Route::get('funnels/listing', [FunnelController::class, 'listing'])->name('refactor.funnels.listing');
    Route::get('funnels/create', [FunnelController::class, 'create'])->name('refactor.funnels.create');
    Route::post('funnels/store', [FunnelController::class, 'store'])->name('refactor.funnels.store');
    Route::get('funnels/{uid}/edit', [FunnelController::class, 'edit'])->name('refactor.funnels.edit');
    Route::patch('funnels/{uid}/update', [FunnelController::class, 'update'])->name('refactor.funnels.update');
    Route::post('funnels/{uid}/publish', [FunnelController::class, 'publish'])->name('refactor.funnels.publish');
    Route::post('funnels/{uid}/unpublish', [FunnelController::class, 'unpublish'])->name('refactor.funnels.unpublish');
    Route::post('funnels/{uid}/duplicate', [FunnelController::class, 'duplicate'])->name('refactor.funnels.duplicate');
    Route::post('funnels/delete', [FunnelController::class, 'delete'])->name('refactor.funnels.delete');
    Route::get('funnels/{uid}/report', [FunnelReportController::class, 'show'])->name('refactor.funnels.report');
    Route::get('funnels/{uid}/page-views', [FunnelReportController::class, 'pageViews'])->name('refactor.funnels.page_views');
    Route::get('funnels/{uid}/page-views/listing', [FunnelReportController::class, 'pageViewsListing'])->name('refactor.funnels.page_views_listing');

    // Funnel Steps
    Route::get('funnels/{funnelUid}/steps/create', [FunnelStepController::class, 'create'])->name('refactor.funnels.step_create');
    Route::post('funnels/{funnelUid}/steps/store', [FunnelStepController::class, 'store'])->name('refactor.funnels.step_store');
    Route::get('funnel-steps/{uid}/edit', [FunnelStepController::class, 'edit'])->name('refactor.funnels.step_edit');
    Route::patch('funnel-steps/{uid}/update', [FunnelStepController::class, 'update'])->name('refactor.funnels.step_update');
    Route::get('funnel-steps/{uid}/template', [FunnelStepController::class, 'template'])->name('refactor.funnels.step_template');
    Route::get('funnel-steps/{uid}/template/gallery', [FunnelStepController::class, 'templateGallery'])->name('refactor.funnels.step_template_gallery');
    Route::post('funnel-steps/{uid}/template/choose', [FunnelStepController::class, 'templateChoose'])->name('refactor.funnels.step_template_choose');
    Route::post('funnel-steps/{uid}/template/remove', [FunnelStepController::class, 'templateRemove'])->name('refactor.funnels.step_template_remove');
    Route::match(['get', 'post'], 'funnel-steps/{uid}/builder', [FunnelStepController::class, 'builder'])->name('refactor.funnels.step_builder');
    Route::get('funnel-steps/{uid}/preview', [FunnelStepController::class, 'preview'])->name('refactor.funnels.step_preview');
    Route::post('funnels/{funnelUid}/steps/reorder', [FunnelStepController::class, 'reorder'])->name('refactor.funnels.step_reorder');
    Route::post('funnel-steps/{uid}/duplicate', [FunnelStepController::class, 'duplicate'])->name('refactor.funnels.step_duplicate');
    Route::delete('funnel-steps/{uid}/delete', [FunnelStepController::class, 'delete'])->name('refactor.funnels.step_delete');
    Route::get('funnel-step-templates', [FunnelStepController::class, 'templatesByTag'])->name('refactor.funnels.step_templates');

    // Funnel Products
    Route::get('funnel-products', [FunnelProductController::class, 'index'])->name('refactor.funnel_products.index');
    Route::get('funnel-products/listing', [FunnelProductController::class, 'listing'])->name('refactor.funnel_products.listing');
    Route::get('funnel-products/create', [FunnelProductController::class, 'create'])->name('refactor.funnel_products.create');
    Route::post('funnel-products/store', [FunnelProductController::class, 'store'])->name('refactor.funnel_products.store');
    Route::get('funnel-products/{uid}/edit', [FunnelProductController::class, 'edit'])->name('refactor.funnel_products.edit');
    Route::patch('funnel-products/{uid}/update', [FunnelProductController::class, 'update'])->name('refactor.funnel_products.update');
    Route::post('funnel-products/{uid}/duplicate', [FunnelProductController::class, 'duplicate'])->name('refactor.funnel_products.duplicate');
    Route::post('funnel-products/delete', [FunnelProductController::class, 'delete'])->name('refactor.funnel_products.delete');
    Route::post('funnels/{funnelUid}/products/associate', [FunnelProductController::class, 'associate'])->name('refactor.funnels.product_associate');
    Route::delete('funnels/{funnelUid}/products/{productUid}', [FunnelProductController::class, 'dissociate'])->name('refactor.funnels.product_dissociate');
    Route::get('funnels/{funnelUid}/products', [FunnelProductController::class, 'funnelProducts'])->name('refactor.funnels.products');

    // Funnel Domains
    Route::post('funnels/{funnelUid}/domains/store', [FunnelDomainController::class, 'store'])->name('refactor.funnels.domain_store');
    Route::post('funnel-domains/{uid}/verify', [FunnelDomainController::class, 'verify'])->name('refactor.funnels.domain_verify');
    Route::delete('funnel-domains/{uid}/delete', [FunnelDomainController::class, 'delete'])->name('refactor.funnels.domain_delete');

    // Customer Payment Gateways (customer-scoped, reused across funnels)
    Route::prefix('payment-gateways')->group(function () {
        Route::get('/',                       [CustomerPaymentGatewayController::class, 'index'])->name('refactor.payment_gateways.index');
        Route::get('/listing',                [CustomerPaymentGatewayController::class, 'listing'])->name('refactor.payment_gateways.listing');
        Route::get('/select-type',            [CustomerPaymentGatewayController::class, 'selectType'])->name('refactor.payment_gateways.select_type');
        Route::get('/create/{type}',          [CustomerPaymentGatewayController::class, 'create'])->name('refactor.payment_gateways.create');
        Route::post('/store/{type}',          [CustomerPaymentGatewayController::class, 'store'])->name('refactor.payment_gateways.store');
        Route::get('/{uid}/edit',             [CustomerPaymentGatewayController::class, 'edit'])->name('refactor.payment_gateways.edit');
        Route::match(['post', 'patch'], '/{uid}/update', [CustomerPaymentGatewayController::class, 'update'])->name('refactor.payment_gateways.update');
        Route::post('/enable',                [CustomerPaymentGatewayController::class, 'enable'])->name('refactor.payment_gateways.enable');
        Route::post('/disable',               [CustomerPaymentGatewayController::class, 'disable'])->name('refactor.payment_gateways.disable');
        Route::post('/delete',                [CustomerPaymentGatewayController::class, 'delete'])->name('refactor.payment_gateways.delete');
        Route::post('/{uid}/test-connection', [CustomerPaymentGatewayController::class, 'testConnection'])->name('refactor.payment_gateways.test_connection');
    });

    /*
    |--------------------------------------------------------------------------
    | Ads Campaign Module — /rui/ads/
    |--------------------------------------------------------------------------
    | R11.1 — every customer-facing ads route runs through
    | EmergencyKillSwitchCheck so admin-engaged platform / customer freezes
    | are enforced before any controller logic runs. The middleware also
    | shares the kill-switch snapshot with views so the suspension banner
    | renders on every ads page.
    */
    Route::middleware(\App\Http\Middleware\Ads\EmergencyKillSwitchCheck::class)->group(function () {

    // Ads Dashboard
    Route::get('ads/dashboard', [\App\Http\Controllers\Refactor\Ads\AdDashboardController::class, 'index'])->name('refactor.ads.dashboard.index');

    // Ads Platforms — connections
    Route::get('ads/platforms', [\App\Http\Controllers\Refactor\Ads\AdPlatformController::class, 'index'])->name('refactor.ads.platforms.index');
    Route::get('ads/platforms/listing', [\App\Http\Controllers\Refactor\Ads\AdPlatformController::class, 'listing'])->name('refactor.ads.platforms.listing');
    Route::get('ads/platforms/connect/{platform}', [\App\Http\Controllers\Refactor\Ads\AdPlatformController::class, 'connect'])->name('refactor.ads.platforms.connect');
    Route::get('ads/platforms/callback/{platform}', [\App\Http\Controllers\Refactor\Ads\AdPlatformController::class, 'callback'])->name('refactor.ads.platforms.callback');
    Route::get('ads/platforms/{uid}/accounts', [\App\Http\Controllers\Refactor\Ads\AdPlatformController::class, 'accounts'])->name('refactor.ads.platforms.accounts');
    Route::post('ads/platforms/{uid}/refresh', [\App\Http\Controllers\Refactor\Ads\AdPlatformController::class, 'refresh'])->name('refactor.ads.platforms.refresh');
    Route::post('ads/platforms/{uid}/health-check', [\App\Http\Controllers\Refactor\Ads\AdPlatformController::class, 'healthCheck'])->name('refactor.ads.platforms.health_check');
    Route::post('ads/platforms/{uid}/disconnect', [\App\Http\Controllers\Refactor\Ads\AdPlatformController::class, 'disconnect'])->name('refactor.ads.platforms.disconnect');
    Route::post('ads/platforms/{uid}/set-default-account', [\App\Http\Controllers\Refactor\Ads\AdPlatformController::class, 'setDefaultAccount'])->name('refactor.ads.platforms.set_default_account');

    // Ads Campaigns — CRUD
    Route::get('ads/campaigns', [\App\Http\Controllers\Refactor\Ads\AdCampaignController::class, 'index'])->name('refactor.ads.campaigns.index');
    Route::get('ads/campaigns/listing', [\App\Http\Controllers\Refactor\Ads\AdCampaignController::class, 'listing'])->name('refactor.ads.campaigns.listing');
    Route::get('ads/campaigns/create', [\App\Http\Controllers\Refactor\Ads\AdCampaignController::class, 'create'])->name('refactor.ads.campaigns.create');
    Route::post('ads/campaigns/store', [\App\Http\Controllers\Refactor\Ads\AdCampaignController::class, 'store'])->name('refactor.ads.campaigns.store');
    Route::post('ads/campaigns/delete', [\App\Http\Controllers\Refactor\Ads\AdCampaignController::class, 'delete'])->name('refactor.ads.campaigns.delete');
    Route::get('ads/campaigns/{uid}/overview', [\App\Http\Controllers\Refactor\Ads\AdCampaignController::class, 'overview'])->name('refactor.ads.campaigns.overview');
    Route::get('ads/campaigns/{uid}/edit', [\App\Http\Controllers\Refactor\Ads\AdCampaignController::class, 'edit'])->name('refactor.ads.campaigns.edit');
    Route::post('ads/campaigns/{uid}/update', [\App\Http\Controllers\Refactor\Ads\AdCampaignController::class, 'update'])->name('refactor.ads.campaigns.update');
    Route::post('ads/campaigns/{uid}/copy', [\App\Http\Controllers\Refactor\Ads\AdCampaignController::class, 'copy'])->name('refactor.ads.campaigns.copy');
    Route::post('ads/campaigns/{uid}/pause', [\App\Http\Controllers\Refactor\Ads\AdCampaignController::class, 'pause'])->name('refactor.ads.campaigns.pause');
    Route::post('ads/campaigns/{uid}/resume', [\App\Http\Controllers\Refactor\Ads\AdCampaignController::class, 'resume'])->name('refactor.ads.campaigns.resume');
    Route::post('ads/campaigns/{uid}/archive', [\App\Http\Controllers\Refactor\Ads\AdCampaignController::class, 'archive'])->name('refactor.ads.campaigns.archive');
    Route::post('ads/campaigns/{uid}/publish', [\App\Http\Controllers\Refactor\Ads\AdCampaignController::class, 'publish'])->name('refactor.ads.campaigns.publish');
    Route::get('ads/campaigns/{uid}/publish-logs', [\App\Http\Controllers\Refactor\Ads\AdCampaignController::class, 'publishLogs'])->name('refactor.ads.campaigns.publish_logs');

    // Ads Templates (Ad Builder Gallery) — Phase O: full CRUD + BuilderJS editor
    Route::get('ads/templates', [\App\Http\Controllers\Refactor\Ads\AdTemplateController::class, 'index'])->name('refactor.ads.templates.index');
    Route::get('ads/templates/listing', [\App\Http\Controllers\Refactor\Ads\AdTemplateController::class, 'listing'])->name('refactor.ads.templates.listing');
    Route::get('ads/templates/create', [\App\Http\Controllers\Refactor\Ads\AdTemplateController::class, 'create'])->name('refactor.ads.templates.create');
    Route::post('ads/templates/store', [\App\Http\Controllers\Refactor\Ads\AdTemplateController::class, 'store'])->name('refactor.ads.templates.store');
    Route::get('ads/templates/{uid}/builder', [\App\Http\Controllers\Refactor\Ads\AdTemplateController::class, 'builder'])->name('refactor.ads.templates.builder');
    Route::post('ads/templates/{uid}/builder', [\App\Http\Controllers\Refactor\Ads\AdTemplateController::class, 'builderSave'])->name('refactor.ads.templates.builder_save');
    Route::post('ads/templates/{uid}/update-meta', [\App\Http\Controllers\Refactor\Ads\AdTemplateController::class, 'updateMeta'])->name('refactor.ads.templates.update_meta');
    Route::post('ads/templates/{uid}/use', [\App\Http\Controllers\Refactor\Ads\AdTemplateController::class, 'useTemplate'])->name('refactor.ads.templates.use');
    Route::get('ads/templates/{uid}/preview', [\App\Http\Controllers\Refactor\Ads\AdTemplateController::class, 'preview'])->name('refactor.ads.templates.preview');
    Route::post('ads/templates/delete', [\App\Http\Controllers\Refactor\Ads\AdTemplateController::class, 'delete'])->name('refactor.ads.templates.delete');

    // Ads Creatives (Phase O) — author ad content with BuilderJS, attach to campaigns
    Route::get('ads/creatives', [\App\Http\Controllers\Refactor\Ads\AdCreativeController::class, 'index'])->name('refactor.ads.creatives.index');
    Route::get('ads/creatives/listing', [\App\Http\Controllers\Refactor\Ads\AdCreativeController::class, 'listing'])->name('refactor.ads.creatives.listing');
    Route::get('ads/creatives/create', [\App\Http\Controllers\Refactor\Ads\AdCreativeController::class, 'create'])->name('refactor.ads.creatives.create');
    Route::post('ads/creatives/store', [\App\Http\Controllers\Refactor\Ads\AdCreativeController::class, 'store'])->name('refactor.ads.creatives.store');
    Route::get('ads/creatives/{uid}/builder', [\App\Http\Controllers\Refactor\Ads\AdCreativeController::class, 'builder'])->name('refactor.ads.creatives.builder');
    Route::post('ads/creatives/{uid}/builder', [\App\Http\Controllers\Refactor\Ads\AdCreativeController::class, 'builderSave'])->name('refactor.ads.creatives.builder_save');
    Route::post('ads/creatives/{uid}/update-meta', [\App\Http\Controllers\Refactor\Ads\AdCreativeController::class, 'updateMeta'])->name('refactor.ads.creatives.update_meta');
    Route::get('ads/creatives/{uid}/preview', [\App\Http\Controllers\Refactor\Ads\AdCreativeController::class, 'preview'])->name('refactor.ads.creatives.preview');
    Route::post('ads/creatives/delete', [\App\Http\Controllers\Refactor\Ads\AdCreativeController::class, 'delete'])->name('refactor.ads.creatives.delete');

    // Ads Lead Forms
    Route::get('ads/lead-forms', [\App\Http\Controllers\Refactor\Ads\AdLeadFormController::class, 'index'])->name('refactor.ads.lead_forms.index');
    Route::get('ads/lead-forms/listing', [\App\Http\Controllers\Refactor\Ads\AdLeadFormController::class, 'listing'])->name('refactor.ads.lead_forms.listing');
    Route::get('ads/lead-forms/create', [\App\Http\Controllers\Refactor\Ads\AdLeadFormController::class, 'create'])->name('refactor.ads.lead_forms.create');
    Route::post('ads/lead-forms/store', [\App\Http\Controllers\Refactor\Ads\AdLeadFormController::class, 'store'])->name('refactor.ads.lead_forms.store');
    Route::post('ads/lead-forms/delete', [\App\Http\Controllers\Refactor\Ads\AdLeadFormController::class, 'delete'])->name('refactor.ads.lead_forms.delete');
    Route::post('ads/lead-forms/{uid}/sync', [\App\Http\Controllers\Refactor\Ads\AdLeadFormController::class, 'sync'])->name('refactor.ads.lead_forms.sync');

    // Ads Product Catalogs (E-commerce)
    Route::get('ads/catalogs', [\App\Http\Controllers\Refactor\Ads\AdProductCatalogController::class, 'index'])->name('refactor.ads.catalogs.index');
    Route::get('ads/catalogs/listing', [\App\Http\Controllers\Refactor\Ads\AdProductCatalogController::class, 'listing'])->name('refactor.ads.catalogs.listing');
    Route::get('ads/catalogs/create', [\App\Http\Controllers\Refactor\Ads\AdProductCatalogController::class, 'create'])->name('refactor.ads.catalogs.create');
    Route::post('ads/catalogs/store', [\App\Http\Controllers\Refactor\Ads\AdProductCatalogController::class, 'store'])->name('refactor.ads.catalogs.store');
    Route::post('ads/catalogs/delete', [\App\Http\Controllers\Refactor\Ads\AdProductCatalogController::class, 'delete'])->name('refactor.ads.catalogs.delete');
    Route::post('ads/catalogs/{uid}/sync', [\App\Http\Controllers\Refactor\Ads\AdProductCatalogController::class, 'sync'])->name('refactor.ads.catalogs.sync');
    Route::get('ads/catalogs/{uid}/errors', [\App\Http\Controllers\Refactor\Ads\AdProductCatalogController::class, 'errors'])->name('refactor.ads.catalogs.errors');

    // Ads A/B Tests
    Route::get('ads/ab-tests', [\App\Http\Controllers\Refactor\Ads\AdAbTestController::class, 'index'])->name('refactor.ads.ab_tests.index');
    Route::get('ads/ab-tests/listing', [\App\Http\Controllers\Refactor\Ads\AdAbTestController::class, 'listing'])->name('refactor.ads.ab_tests.listing');
    Route::get('ads/ab-tests/create', [\App\Http\Controllers\Refactor\Ads\AdAbTestController::class, 'create'])->name('refactor.ads.ab_tests.create');
    Route::post('ads/ab-tests/store', [\App\Http\Controllers\Refactor\Ads\AdAbTestController::class, 'store'])->name('refactor.ads.ab_tests.store');
    Route::post('ads/ab-tests/delete', [\App\Http\Controllers\Refactor\Ads\AdAbTestController::class, 'delete'])->name('refactor.ads.ab_tests.delete');
    Route::post('ads/ab-tests/{uid}/start', [\App\Http\Controllers\Refactor\Ads\AdAbTestController::class, 'start'])->name('refactor.ads.ab_tests.start');
    Route::post('ads/ab-tests/{uid}/winner/{variantUid}', [\App\Http\Controllers\Refactor\Ads\AdAbTestController::class, 'declareWinner'])->name('refactor.ads.ab_tests.winner');

    // Ads Automations
    Route::get('ads/automations', [\App\Http\Controllers\Refactor\Ads\AdAutomationController::class, 'index'])->name('refactor.ads.automations.index');
    Route::get('ads/automations/listing', [\App\Http\Controllers\Refactor\Ads\AdAutomationController::class, 'listing'])->name('refactor.ads.automations.listing');
    Route::get('ads/automations/create', [\App\Http\Controllers\Refactor\Ads\AdAutomationController::class, 'create'])->name('refactor.ads.automations.create');
    Route::post('ads/automations/store', [\App\Http\Controllers\Refactor\Ads\AdAutomationController::class, 'store'])->name('refactor.ads.automations.store');
    Route::post('ads/automations/delete', [\App\Http\Controllers\Refactor\Ads\AdAutomationController::class, 'delete'])->name('refactor.ads.automations.delete');
    Route::post('ads/automations/{uid}/pause', [\App\Http\Controllers\Refactor\Ads\AdAutomationController::class, 'pause'])->name('refactor.ads.automations.pause');
    Route::post('ads/automations/{uid}/activate', [\App\Http\Controllers\Refactor\Ads\AdAutomationController::class, 'activate'])->name('refactor.ads.automations.activate');

    // Ads Pixels (Conversion Tracking)
    Route::get('ads/pixels', [\App\Http\Controllers\Refactor\Ads\AdPixelController::class, 'index'])->name('refactor.ads.pixels.index');
    Route::get('ads/pixels/listing', [\App\Http\Controllers\Refactor\Ads\AdPixelController::class, 'listing'])->name('refactor.ads.pixels.listing');
    Route::get('ads/pixels/create', [\App\Http\Controllers\Refactor\Ads\AdPixelController::class, 'create'])->name('refactor.ads.pixels.create');
    Route::post('ads/pixels/store', [\App\Http\Controllers\Refactor\Ads\AdPixelController::class, 'store'])->name('refactor.ads.pixels.store');
    Route::post('ads/pixels/delete', [\App\Http\Controllers\Refactor\Ads\AdPixelController::class, 'delete'])->name('refactor.ads.pixels.delete');
    Route::post('ads/pixels/{uid}/verify', [\App\Http\Controllers\Refactor\Ads\AdPixelController::class, 'verify'])->name('refactor.ads.pixels.verify');

    // Ads Audiences
    Route::get('ads/audiences', [\App\Http\Controllers\Refactor\Ads\AdAudienceController::class, 'index'])->name('refactor.ads.audiences.index');
    Route::get('ads/audiences/listing', [\App\Http\Controllers\Refactor\Ads\AdAudienceController::class, 'listing'])->name('refactor.ads.audiences.listing');
    Route::get('ads/audiences/create', [\App\Http\Controllers\Refactor\Ads\AdAudienceController::class, 'create'])->name('refactor.ads.audiences.create');
    Route::post('ads/audiences/store', [\App\Http\Controllers\Refactor\Ads\AdAudienceController::class, 'store'])->name('refactor.ads.audiences.store');
    Route::post('ads/audiences/delete', [\App\Http\Controllers\Refactor\Ads\AdAudienceController::class, 'delete'])->name('refactor.ads.audiences.delete');
    Route::post('ads/audiences/{uid}/sync', [\App\Http\Controllers\Refactor\Ads\AdAudienceController::class, 'sync'])->name('refactor.ads.audiences.sync');

    // Ads Activity Log
    Route::get('ads/activity', [\App\Http\Controllers\Refactor\Ads\AdActivityController::class, 'index'])->name('refactor.ads.activity.index');
    Route::get('ads/activity/listing', [\App\Http\Controllers\Refactor\Ads\AdActivityController::class, 'listing'])->name('refactor.ads.activity.listing');
    Route::post('ads/activity/mark-read', [\App\Http\Controllers\Refactor\Ads\AdActivityController::class, 'markRead'])->name('refactor.ads.activity.mark_read');

    }); // end EmergencyKillSwitchCheck group

    // GDPR — purge a subscriber from every connected ad audience (R11.2).
    // Outside the kill-switch group on purpose: the cascade is GDPR-mandated
    // and must keep working even when the customer is frozen for billing /
    // policy reasons.
    Route::post('lists/{uid}/subscribers/{id}/purge-from-ads', [\App\Http\Controllers\Refactor\MailListController::class, 'subscriberPurgeFromAds'])->name('refactor.lists.subscriber_purge_from_ads');
});

/*
|--------------------------------------------------------------------------
| Customer Routes (migrated off /rui/ prefix)
|--------------------------------------------------------------------------
|
| Customer-area routes that opted out of /rui/ prefix. Same controllers and
| same middleware as the rui group above; only the URL prefix differs. Module
| migrations land here one at a time — campaigns, dashboard, ... .
|
*/
Route::group([
    'middleware' => ['not_installed', 'auth', 'frontend', 'subscription', '2fa', 'demo_guard'],
], function () {
    // Dashboard
    Route::get('dashboard', [DashboardController::class, 'index'])->name('refactor.dashboard');
    Route::get('dashboard/chart-data', [DashboardController::class, 'chartData'])->name('refactor.dashboard.chart-data');
    Route::post('dashboard/refresh-cache', [DashboardController::class, 'refreshChart'])->name('refactor.dashboard.refresh-cache');

    // Email Templates
    Route::get('email-templates', [App\Http\Controllers\Refactor\EmailTemplateController::class, 'index'])->name('refactor.templates.index');
    Route::get('email-templates/listing', [App\Http\Controllers\Refactor\EmailTemplateController::class, 'listing'])->name('refactor.templates.listing');
    Route::match(['get', 'post'], 'email-templates/create', [App\Http\Controllers\Refactor\EmailTemplateController::class, 'create'])->name('refactor.templates.create');
    Route::get('email-templates/gallery', [App\Http\Controllers\Refactor\EmailTemplateController::class, 'gallery'])->name('refactor.templates.gallery');
    Route::get('email-templates/{uid}/preview', [App\Http\Controllers\Refactor\EmailTemplateController::class, 'preview'])->name('refactor.templates.preview');
    Route::match(['get', 'post'], 'email-templates/{uid}/rename', [App\Http\Controllers\Refactor\EmailTemplateController::class, 'rename'])->name('refactor.templates.rename');
    Route::match(['get', 'post'], 'email-templates/{uid}/copy', [App\Http\Controllers\Refactor\EmailTemplateController::class, 'copy'])->name('refactor.templates.copy');
    Route::post('email-templates/delete', [App\Http\Controllers\Refactor\EmailTemplateController::class, 'delete'])->name('refactor.templates.delete');
    Route::match(['get', 'post'], 'email-templates/{uid}/builder', [App\Http\Controllers\Refactor\EmailTemplateController::class, 'builder'])->name('refactor.templates.builder');
    Route::post('email-templates/{uid}/change-template', [App\Http\Controllers\Refactor\EmailTemplateController::class, 'changeTemplate'])->name('refactor.templates.change_template');

    // Automations — index listing
    Route::get('automations', [AutomationController::class, 'index'])->name('refactor.automations.index');
    Route::get('automations/listing', [AutomationController::class, 'listing'])->name('refactor.automations.listing');
    Route::post('automations/delete', [AutomationController::class, 'delete'])->name('refactor.automations.delete');
    Route::get('automations/create', [AutomationController::class, 'create'])->name('refactor.automations.create');
    Route::post('automations/create', [AutomationController::class, 'store'])->name('refactor.automations.store');
    Route::get('automations/create/options', [AutomationController::class, 'triggerOptions'])->name('refactor.automations.trigger_options');
    Route::get('automations/segments', [AutomationController::class, 'segmentSelect'])->name('refactor.automations.segment_select');
    Route::get('automations/fields', [AutomationController::class, 'fieldSelect'])->name('refactor.automations.field_select');

    // Automations — edit + settings
    Route::get('automations/{uid}/edit', [AutomationController::class, 'edit'])->name('refactor.automations.edit');
    Route::get('automations/{uid}/settings',   [AutomationController::class, 'settingsShow'])  ->name('refactor.automations.settings.show');
    Route::patch('automations/{uid}/settings', [AutomationController::class, 'settingsUpdate'])->name('refactor.automations.settings.update');

    // Automations — subscribers / contacts panel
    Route::get('automations/{uid}/contacts',                          [AutomationController::class, 'contacts'])      ->name('refactor.automations.contacts');
    Route::get('automations/{uid}/contacts/listing',                  [AutomationController::class, 'contactsListing'])->name('refactor.automations.contacts.listing');
    Route::post('automations/{uid}/contacts/{subscriber_uid}/trigger',   [AutomationController::class, 'contactsTrigger'])      ->name('refactor.automations.contacts.trigger');
    Route::delete('automations/{uid}/contacts/{subscriber_uid}/trigger', [AutomationController::class, 'contactsDeleteTrigger'])->name('refactor.automations.contacts.delete_trigger');
    Route::post('automations/{uid}/contacts/{subscriber_uid}/hold',    [AutomationController::class, 'contactsHold'])  ->name('refactor.automations.contacts.hold');
    Route::post('automations/{uid}/contacts/{subscriber_uid}/unhold',  [AutomationController::class, 'contactsUnhold'])->name('refactor.automations.contacts.unhold');
    Route::get('automations/{uid}/contacts/{subscriber_uid}/progress', [AutomationController::class, 'contactsProgress'])->name('refactor.automations.contacts.progress');
    Route::post('automations/{uid}/contacts/{subscriber_uid}/advance', [AutomationController::class, 'contactsAdvance'])->name('refactor.automations.contacts.advance');
    Route::post('automations/{uid}/contacts/{subscriber_uid}/retry',   [AutomationController::class, 'contactsRetry'])  ->name('refactor.automations.contacts.retry');
    Route::post('automations/{uid}/contacts/retry-all',                [AutomationController::class, 'contactsRetryAll'])->name('refactor.automations.contacts.retry_all');
    Route::get('automations/{uid}/contacts/node-performance',          [AutomationController::class, 'contactsNodePerformance'])->name('refactor.automations.contacts.node_performance');

    // Automations — send-node deep-dive report (overview + log views). nodeId-bound so URL
    // survives the bound email being swapped via the editor.
    Route::get('automations/{uid}/nodes/{nodeId}/email-report',                  [AutomationController::class, 'emailReport'])               ->name('refactor.automations.email_report');
    Route::get('automations/{uid}/nodes/{nodeId}/email-report/insights',         [AutomationController::class, 'emailReportInsights'])       ->name('refactor.automations.email_report.insights');
    Route::get('automations/{uid}/nodes/{nodeId}/email-report/insights/listing', [AutomationController::class, 'emailReportInsightsListing'])->name('refactor.automations.email_report.insights_listing');
    Route::get('automations/{uid}/nodes/{nodeId}/email-report/open-log',   [AutomationController::class, 'emailReportOpenLog'])  ->name('refactor.automations.email_report.open_log');
    Route::get('automations/{uid}/nodes/{nodeId}/email-report/click-log',  [AutomationController::class, 'emailReportClickLog']) ->name('refactor.automations.email_report.click_log');
    Route::get('automations/{uid}/nodes/{nodeId}/email-report/open-map',   [AutomationController::class, 'emailReportOpenMap'])  ->name('refactor.automations.email_report.open_map');
    Route::get('automations/{uid}/nodes/{nodeId}/email-report/click-map',  [AutomationController::class, 'emailReportClickMap']) ->name('refactor.automations.email_report.click_map');
    Route::get('automations/{uid}/nodes/{nodeId}/email-report/bounce-log', [AutomationController::class, 'emailReportBounceLog'])->name('refactor.automations.email_report.bounce_log');
    Route::post('automations/{uid}/nodes/{nodeId}/email-report/refresh',   [AutomationController::class, 'emailReportRefresh'])  ->name('refactor.automations.email_report.refresh');
    Route::post('automations/{uid}/mail-list',                         [AutomationController::class, 'changeMailList'])->name('refactor.automations.change_mail_list');

    // Automations — graph-normalized flow editor REST endpoints (replaces legacy *Save AJAX).
    Route::get('automations/{uid}/flow',              [\App\Http\Controllers\Refactor\AutomationFlowController::class, 'show'])         ->name('refactor.automations.flow.show');
    Route::post('automations/{uid}/nodes/new/{type}', [\App\Http\Controllers\Refactor\AutomationFlowController::class, 'createNode'])   ->name('refactor.automations.nodes.create')
        ->where('type', 'send|wait|wait_until|condition|operation|webhook');
    Route::patch('automations/{uid}/nodes/{nodeId}',  [\App\Http\Controllers\Refactor\AutomationFlowController::class, 'updateNode'])   ->name('refactor.automations.nodes.update');
    Route::delete('automations/{uid}/nodes/{nodeId}', [\App\Http\Controllers\Refactor\AutomationFlowController::class, 'deleteNode'])   ->name('refactor.automations.nodes.delete');
    Route::patch('automations/{uid}/trigger',         [\App\Http\Controllers\Refactor\AutomationFlowController::class, 'updateTrigger'])->name('refactor.automations.trigger.update');
    Route::post('automations/{uid}/nodes/{nodeId}/email',                [\App\Http\Controllers\Refactor\AutomationFlowController::class, 'createEmailForNode'])->name('refactor.automations.nodes.email_create');
    Route::get('automations/{uid}/nodes/{nodeId}/email/preview',         [\App\Http\Controllers\Refactor\AutomationFlowController::class, 'previewEmail'])->name('refactor.automations.nodes.email_preview');
    Route::get('automations/{uid}/nodes/{nodeId}/email/settings',        [\App\Http\Controllers\Refactor\AutomationFlowController::class, 'showEmailSettings'])->name('refactor.automations.nodes.email_settings_show');
    Route::patch('automations/{uid}/nodes/{nodeId}/email/settings',      [\App\Http\Controllers\Refactor\AutomationFlowController::class, 'updateEmailSettings'])->name('refactor.automations.nodes.email_settings_update');
    Route::post('automations/{uid}/nodes/{nodeId}/email/test',           [\App\Http\Controllers\Refactor\AutomationFlowController::class, 'sendTestEmail'])->name('refactor.automations.nodes.email_test');
    Route::get('automations/{uid}/nodes/{nodeId}/email/template-gallery',[\App\Http\Controllers\Refactor\AutomationFlowController::class, 'templateGallery'])->name('refactor.automations.nodes.email_template_gallery');
    Route::post('automations/{uid}/nodes/{nodeId}/email/template-choose',[\App\Http\Controllers\Refactor\AutomationFlowController::class, 'templateChoose'])->name('refactor.automations.nodes.email_template_choose');
    Route::post('automations/{uid}/nodes/{nodeId}/email/custom-html',    [\App\Http\Controllers\Refactor\AutomationFlowController::class, 'templateCustomHtml'])->name('refactor.automations.nodes.email_custom_html');

    // Automations — email template editor (builder + custom HTML)
    Route::match(['get', 'post'], 'automations/{uid}/template/{email_uid}/edit', [AutomationController::class, 'templateEdit'])->name('refactor.automations.template_edit');
    Route::match(['get', 'post'], 'automations/{uid}/template/{email_uid}/custom-html', [AutomationController::class, 'customHtml'])->name('refactor.automations.custom_html');

    // Automations — proxy actions
    Route::match(['get', 'post'], 'automations/{uid}/copy', [AutomationController::class, 'copy'])->name('refactor.automations.copy');
    Route::post('automations/enable', [AutomationController::class, 'enable'])->name('refactor.automations.enable');
    Route::post('automations/disable', [AutomationController::class, 'disable'])->name('refactor.automations.disable');

    // Campaigns — index listing
    Route::get('campaigns', [CampaignController::class, 'index'])->name('refactor.campaigns.index');
    Route::get('campaigns/listing', [CampaignController::class, 'listing'])->name('refactor.campaigns.listing');
    Route::get('campaigns/{uid}/last-error', [CampaignController::class, 'lastError'])->name('refactor.campaigns.last_error');

    // Campaigns — report tabs
    Route::match(['get', 'post'], 'campaigns/copy', [CampaignController::class, 'copy'])->name('refactor.campaigns.copy');
    Route::get('campaigns/{uid}/overview', [CampaignController::class, 'overview'])->name('refactor.campaigns.overview');
    Route::get('campaigns/{uid}/links', [CampaignController::class, 'links'])->name('refactor.campaigns.links');
    Route::get('campaigns/{uid}/open-map', [CampaignController::class, 'openMap'])->name('refactor.campaigns.open_map');
    Route::get('campaigns/{uid}/click-map', [CampaignController::class, 'clickMap'])->name('refactor.campaigns.click_map');
    Route::get('campaigns/{uid}/subscribers', [CampaignController::class, 'subscribers'])->name('refactor.campaigns.subscribers');
    Route::get('campaigns/{uid}/subscribers/listing', [CampaignController::class, 'subscribersListing'])->name('refactor.campaigns.subscribers_listing');
    Route::get('campaigns/{uid}/tracking-log', [CampaignController::class, 'trackingLog'])->name('refactor.campaigns.tracking_log');
    Route::get('campaigns/{uid}/tracking-log/listing', [CampaignController::class, 'trackingLogListing'])->name('refactor.campaigns.tracking_log_listing');
    Route::get('campaigns/{uid}/bounce-log', [CampaignController::class, 'bounceLog'])->name('refactor.campaigns.bounce_log');
    Route::get('campaigns/{uid}/bounce-log/listing', [CampaignController::class, 'bounceLogListing'])->name('refactor.campaigns.bounce_log_listing');
    Route::get('campaigns/{uid}/feedback-log', [CampaignController::class, 'feedbackLog'])->name('refactor.campaigns.feedback_log');
    Route::get('campaigns/{uid}/feedback-log/listing', [CampaignController::class, 'feedbackLogListing'])->name('refactor.campaigns.feedback_log_listing');
    Route::get('campaigns/{uid}/open-log', [CampaignController::class, 'openLog'])->name('refactor.campaigns.open_log');
    Route::get('campaigns/{uid}/open-log/listing', [CampaignController::class, 'openLogListing'])->name('refactor.campaigns.open_log_listing');
    Route::get('campaigns/{uid}/click-log', [CampaignController::class, 'clickLog'])->name('refactor.campaigns.click_log');
    Route::get('campaigns/{uid}/click-log/listing', [CampaignController::class, 'clickLogListing'])->name('refactor.campaigns.click_log_listing');
    Route::get('campaigns/{uid}/unsubscribe-log', [CampaignController::class, 'unsubscribeLog'])->name('refactor.campaigns.unsubscribe_log');
    Route::get('campaigns/{uid}/unsubscribe-log/listing', [CampaignController::class, 'unsubscribeLogListing'])->name('refactor.campaigns.unsubscribe_log_listing');

    // Campaigns — creation wizard
    Route::get('campaigns/select-type', [CampaignController::class, 'selectType'])->name('refactor.campaigns.select_type');
    Route::get('campaigns/create', [CampaignController::class, 'create'])->name('refactor.campaigns.create');
    Route::get('campaigns/identity-dropbox', [CampaignController::class, 'identityDropbox'])->name('refactor.campaigns.identity_dropbox');
    Route::match(['get', 'post'], 'campaigns/{uid}/recipients', [CampaignController::class, 'recipients'])->name('refactor.campaigns.recipients');
    Route::get('campaigns/{uid}/list-segment-form', [CampaignController::class, 'listSegmentForm'])->name('refactor.campaigns.list_segment_form');
    Route::match(['get', 'post'], 'campaigns/{uid}/setup', [CampaignController::class, 'setup'])->name('refactor.campaigns.setup');
    Route::match(['get', 'post'], 'campaigns/{uid}/template', [CampaignController::class, 'template'])->name('refactor.campaigns.template');
    Route::get('campaigns/{uid}/template/gallery', [CampaignController::class, 'templateGallery'])->name('refactor.campaigns.template_gallery');
    Route::post('campaigns/{uid}/template/choose', [CampaignController::class, 'templateChoose'])->name('refactor.campaigns.template_choose');
    Route::match(['get', 'post'], 'campaigns/{uid}/custom-html', [CampaignController::class, 'customHtml'])->name('refactor.campaigns.custom_html');
    Route::match(['get', 'post'], 'campaigns/{uid}/schedule', [CampaignController::class, 'schedule'])->name('refactor.campaigns.schedule');
    Route::match(['get', 'post'], 'campaigns/{uid}/confirm', [CampaignController::class, 'confirm'])->name('refactor.campaigns.confirm');

    // Campaigns — A/B Test wizard
    Route::get('campaigns/{uid}/ab-test/setup', [CampaignController::class, 'abTestSetup'])->name('refactor.campaigns.ab_test_setup');
    Route::post('campaigns/{uid}/ab-test/save-config', [CampaignController::class, 'abTestSaveConfig'])->name('refactor.campaigns.ab_test_save_config');
    Route::post('campaigns/{uid}/ab-test/save-winner-rules', [CampaignController::class, 'abTestSaveWinnerRules'])->name('refactor.campaigns.ab_test_save_winner_rules');
    Route::post('campaigns/{uid}/ab-test/variants', [CampaignController::class, 'abTestStoreVariant'])->name('refactor.campaigns.ab_test_store_variant');
    Route::post('campaigns/{uid}/ab-test/ai-apply-variants', [CampaignController::class, 'abTestAiApplyVariants'])->name('refactor.campaigns.ab_test_ai_apply_variants'); // F4.5
    Route::post('campaigns/{uid}/ab-test/variants/{variantUid}/delete', [CampaignController::class, 'abTestDeleteVariant'])->name('refactor.campaigns.ab_test_delete_variant');
    Route::get('campaigns/{uid}/ab-test/variants/{variantUid}/panel', [CampaignController::class, 'abTestVariantPanel'])->name('refactor.campaigns.ab_test_variant_panel');
    Route::post('campaigns/{uid}/ab-test/variants/{variantUid}/update', [CampaignController::class, 'abTestUpdateVariant'])->name('refactor.campaigns.ab_test_update_variant');
    Route::get('campaigns/{uid}/ab-test/variants/{variantUid}/template-gallery', [CampaignController::class, 'abTestVariantTemplateGallery'])->name('refactor.campaigns.ab_test_variant_template_gallery');
    Route::post('campaigns/{uid}/ab-test/variants/{variantUid}/select-template', [CampaignController::class, 'abTestVariantSelectTemplate'])->name('refactor.campaigns.ab_test_variant_select_template');
    Route::get('campaigns/{uid}/ab-report', [CampaignController::class, 'abTestReport'])->name('refactor.campaigns.ab_test_report');
    Route::get('campaigns/{uid}/ab-report/data', [CampaignController::class, 'abTestReportData'])->name('refactor.campaigns.ab_test_report_data');
    Route::post('campaigns/{uid}/ab-test/choose-winner', [CampaignController::class, 'abTestChooseWinner'])->name('refactor.campaigns.ab_test_choose_winner');
    Route::get('campaigns/{uid}/ab-report/variants/{variantUid}', [CampaignController::class, 'abTestVariantReport'])->name('refactor.campaigns.ab_test_variant_report');
    Route::get('campaigns/{uid}/ab-test/confirm', [CampaignController::class, 'abTestConfirm'])->name('refactor.campaigns.ab_test_confirm');
    Route::post('campaigns/{uid}/ab-test/send', [CampaignController::class, 'abTestSend'])->name('refactor.campaigns.ab_test_send');

    // Campaign wizard — template extras
    Route::post('campaigns/{uid}/upload-attachment', [CampaignController::class, 'uploadAttachment'])->name('refactor.campaigns.upload_attachment');
    Route::post('campaigns/{uid}/remove-attachment', [CampaignController::class, 'removeAttachment'])->name('refactor.campaigns.remove_attachment');
    Route::get('campaigns/{uid}/download-attachment', [CampaignController::class, 'downloadAttachment'])->name('refactor.campaigns.download_attachment');
    Route::match(['get', 'post'], 'campaigns/{uid}/preheader', [CampaignController::class, 'preheader'])->name('refactor.campaigns.preheader');
    Route::match(['get', 'post'], 'campaigns/{uid}/send-test-email', [CampaignController::class, 'sendTestEmail'])->name('refactor.campaigns.send_test_email');

    // Campaign wizard — webhooks
    Route::get('campaigns/{uid}/webhooks', [CampaignController::class, 'webhooks'])->name('refactor.campaigns.webhooks');
    Route::match(['get', 'post'], 'campaigns/{uid}/webhooks/add', [CampaignController::class, 'webhooksAdd'])->name('refactor.campaigns.webhooks_add');
    Route::post('campaigns/{uid}/webhooks/{webhook_uid}/delete', [CampaignController::class, 'webhooksDelete'])->name('refactor.campaigns.webhooks_delete');

    // Campaign tracking log download
    Route::get('campaigns/{uid}/tracking-log-download', [CampaignController::class, 'trackingLogDownload'])->name('refactor.campaigns.tracking_log_download');

    // Campaign proxy actions
    Route::post('campaigns/pause', [CampaignController::class, 'pause'])->name('refactor.campaigns.pause');
    Route::post('campaigns/resume', [CampaignController::class, 'resume'])->name('refactor.campaigns.resume');
    Route::post('campaigns/delete-campaigns', [CampaignController::class, 'deleteCampaigns'])->name('refactor.campaigns.delete_campaigns');
    Route::post('campaigns/archive', [CampaignController::class, 'archive'])->name('refactor.campaigns.archive');
    Route::match(['get', 'post'], 'campaigns/{uid}/resend', [CampaignController::class, 'resend'])->name('refactor.campaigns.resend');
    Route::post('campaigns/{uid}/update-statistics', [CampaignController::class, 'updateStatistics'])->name('refactor.campaigns.update_statistics');
    Route::get('campaigns/{uid}/preview', [CampaignController::class, 'preview'])->name('refactor.campaigns.preview');
    Route::get('campaigns/{uid}/preview/content/{subscriber_id?}', [CampaignController::class, 'previewContent'])->name('refactor.campaigns.preview_content');
    Route::get('campaigns/{uid}/preview-as', [CampaignController::class, 'previewAs'])->name('refactor.campaigns.preview_as');
    Route::get('campaigns/{uid}/preview-as/list', [CampaignController::class, 'previewAsList'])->name('refactor.campaigns.preview_as_list');
    Route::get('campaigns/{uid}/preview-as/{subscriber_id}/content', [CampaignController::class, 'previewAsContent'])->name('refactor.campaigns.preview_as_content');
    Route::get('campaigns/{uid}/preview-as/{subscriber_id}/download', [CampaignController::class, 'previewAsDownload'])->name('refactor.campaigns.preview_as_download');
    Route::get('campaigns/{uid}/chart24h', [CampaignController::class, 'chart24h'])->name('refactor.campaigns.chart24h');
    Route::get('campaigns/{uid}/chart-country', [CampaignController::class, 'chartCountry'])->name('refactor.campaigns.chart_country');
    Route::get('campaigns/{uid}/chart-click-country', [CampaignController::class, 'chartClickCountry'])->name('refactor.campaigns.chart_click_country');
    Route::match(['get', 'post'], 'campaigns/{uid}/template-edit', [CampaignController::class, 'templateEdit'])->name('refactor.campaigns.template_edit');
    Route::match(['get', 'post'], 'campaigns/{uid}/ab-test/{variant_uid}/template-edit', [CampaignController::class, 'abTestVariantTemplateEdit'])->name('refactor.campaigns.ab_variant_template_edit');
    Route::get('campaigns/{uid}/ab-test/{variantUid}/preview', [CampaignController::class, 'abTestVariantPreview'])->name('refactor.campaigns.ab_variant_preview');
    Route::get('campaigns/export-progress/{uid}', [CampaignController::class, 'trackingLogExportProgress'])->name('refactor.campaigns.export_progress');
    Route::get('campaigns/download/{uid}', [CampaignController::class, 'downloadExport'])->name('refactor.campaigns.download_export');

    // Web view preview-as-subscriber (preview before campaign sends — migrated
    // from the legacy /campaigns/... block in routes/web.php).
    Route::get('campaigns/{campaign_uid}/webview/{subscriber_id}/preview', [CampaignController::class, 'webViewPreview'])->name('webViewerPreviewUrl');
});

/*
|--------------------------------------------------------------------------
| Admin Routes — /rui/admin/
|--------------------------------------------------------------------------
|
| All admin panel routes. Requires authentication + backend (admin) middleware.
| Controllers in App\Http\Controllers\Refactor\Admin\
| Views in resources/views/refactor/pages/admin/
|
*/
Route::group([
    'prefix' => 'rui/admin',
    'middleware' => ['not_installed', 'auth', 'backend', '2fa', 'demo_guard'],
], function () {
    // Dashboard — canonical URL moved to /admin (see routes/web.php). These legacy
    // /rui/admin/ entry URLs redirect so old bookmarks still land on the dashboard.
    Route::get('/', fn () => redirect('/admin'));
    Route::get('dashboard', fn () => redirect('/admin'));
    Route::get('dashboard/chart-data', [AdminDashboardController::class, 'chartData'])->name('refactor.admin.dashboard.chart-data');
    Route::post('dashboard/refresh-cache', [AdminDashboardController::class, 'refreshChart'])->name('refactor.admin.dashboard.refresh-cache');

    // === STUB ROUTES — will be replaced by real controllers per module ===
    // These exist so the sidebar links don't crash before modules are built.

    // Customers — canonical URL moved to /admin/customers (see /admin group below).
    // GET bookmarks of the old /rui/admin/customers/* URLs land softly via this redirect.
    // Query string is preserved (?keyword=, ?page=, etc.).
    Route::get('customers/{path?}', function (Request $request, string $path = '') {
        $qs = $request->getQueryString();
        return redirect('/admin/customers' . ($path === '' ? '' : '/' . $path) . ($qs ? '?' . $qs : ''));
    })->where('path', '.*');

    // Subscriptions — canonical URL moved to /admin/subscriptions (see /admin group below).
    Route::get('subscriptions/{path?}', function (Request $request, string $path = '') {
        $qs = $request->getQueryString();
        return redirect('/admin/subscriptions' . ($path === '' ? '' : '/' . $path) . ($qs ? '?' . $qs : ''));
    })->where('path', '.*');

    // Invoices — canonical URL moved to /admin/invoices (see /admin group below).
    Route::get('invoices/{path?}', function (Request $request, string $path = '') {
        $qs = $request->getQueryString();
        return redirect('/admin/invoices' . ($path === '' ? '' : '/' . $path) . ($qs ? '?' . $qs : ''));
    })->where('path', '.*');

    // Plans — canonical URL moved to /admin/plans (see /admin group below).
    Route::get('plans/{path?}', function (Request $request, string $path = '') {
        $qs = $request->getQueryString();
        return redirect('/admin/plans' . ($path === '' ? '' : '/' . $path) . ($qs ? '?' . $qs : ''));
    })->where('path', '.*');

    // Currencies
    Route::get('currencies', [AdminCurrencyController::class, 'index'])->name('refactor.admin.currencies.index');
    Route::get('currencies/listing', [AdminCurrencyController::class, 'listing'])->name('refactor.admin.currencies.listing');
    Route::get('currencies/create', [AdminCurrencyController::class, 'create'])->name('refactor.admin.currencies.create');
    Route::post('currencies/store', [AdminCurrencyController::class, 'store'])->name('refactor.admin.currencies.store');
    Route::get('currencies/{uid}/edit', [AdminCurrencyController::class, 'edit'])->name('refactor.admin.currencies.edit');
    Route::post('currencies/{uid}/update', [AdminCurrencyController::class, 'update'])->name('refactor.admin.currencies.update');
    Route::post('currencies/enable', [AdminCurrencyController::class, 'enable'])->name('refactor.admin.currencies.enable');
    Route::post('currencies/disable', [AdminCurrencyController::class, 'disable'])->name('refactor.admin.currencies.disable');
    Route::post('currencies/delete', [AdminCurrencyController::class, 'delete'])->name('refactor.admin.currencies.delete');

    // Sending Credit Plans
    Route::get('sending-credit-plans', [AdminSendingCreditPlanController::class, 'index'])->name('refactor.admin.sending-credit-plans.index');
    Route::get('sending-credit-plans/listing', [AdminSendingCreditPlanController::class, 'listing'])->name('refactor.admin.sending-credit-plans.listing');
    Route::get('sending-credit-plans/create', [AdminSendingCreditPlanController::class, 'create'])->name('refactor.admin.sending-credit-plans.create');
    Route::post('sending-credit-plans/store', [AdminSendingCreditPlanController::class, 'store'])->name('refactor.admin.sending-credit-plans.store');
    Route::get('sending-credit-plans/{uid}/edit', [AdminSendingCreditPlanController::class, 'edit'])->name('refactor.admin.sending-credit-plans.edit');
    Route::post('sending-credit-plans/{uid}/update', [AdminSendingCreditPlanController::class, 'update'])->name('refactor.admin.sending-credit-plans.update');
    Route::post('sending-credit-plans/delete', [AdminSendingCreditPlanController::class, 'delete'])->name('refactor.admin.sending-credit-plans.delete');
    Route::post('sending-credit-plans/{uid}/visibility-on', [AdminSendingCreditPlanController::class, 'visibilityOn'])->name('refactor.admin.sending-credit-plans.visibility-on');
    Route::post('sending-credit-plans/{uid}/visibility-off', [AdminSendingCreditPlanController::class, 'visibilityOff'])->name('refactor.admin.sending-credit-plans.visibility-off');

    // Payment Gateways
    Route::get('payment-gateways', [AdminPaymentGatewayController::class, 'index'])->name('refactor.admin.payment-gateways.index');
    Route::get('payment-gateways/listing', [AdminPaymentGatewayController::class, 'listing'])->name('refactor.admin.payment-gateways.listing');
    Route::get('payment-gateways/select-type', [AdminPaymentGatewayController::class, 'selectType'])->name('refactor.admin.payment-gateways.select-type');
    Route::get('payment-gateways/create/{type}', [AdminPaymentGatewayController::class, 'create'])->name('refactor.admin.payment-gateways.create');
    Route::post('payment-gateways/store/{type}', [AdminPaymentGatewayController::class, 'store'])->name('refactor.admin.payment-gateways.store');
    Route::get('payment-gateways/{uid}/edit', [AdminPaymentGatewayController::class, 'edit'])->name('refactor.admin.payment-gateways.edit');
    Route::patch('payment-gateways/{uid}/update', [AdminPaymentGatewayController::class, 'update'])->name('refactor.admin.payment-gateways.update');
    Route::post('payment-gateways/enable', [AdminPaymentGatewayController::class, 'enable'])->name('refactor.admin.payment-gateways.enable');
    Route::post('payment-gateways/disable', [AdminPaymentGatewayController::class, 'disable'])->name('refactor.admin.payment-gateways.disable');
    Route::post('payment-gateways/delete', [AdminPaymentGatewayController::class, 'delete'])->name('refactor.admin.payment-gateways.delete');
    Route::post('payment-gateways/{uid}/test-connection', [AdminPaymentGatewayController::class, 'testConnection'])->name('refactor.admin.payment-gateways.test-connection');
    Route::get('payment-gateways/settings', [AdminPaymentGatewayController::class, 'settings'])->name('refactor.admin.payment-gateways.settings');
    Route::post('payment-gateways/settings', [AdminPaymentGatewayController::class, 'settingsSave'])->name('refactor.admin.payment-gateways.settings.save');
    Route::get('payment-gateways/{uid}/remote', [AdminPaymentGatewayRemoteController::class, 'index'])->name('refactor.admin.payment-gateways.remote');
    Route::get('payment-gateways/{uid}/remote/plan/{plan_id}', [AdminPaymentGatewayRemoteController::class, 'planDetail'])->name('refactor.admin.payment-gateways.remote.plan');
    Route::get('payment-gateways/{uid}/remote/subscription/{remote_sub_id}', [AdminPaymentGatewayRemoteController::class, 'subscriptionDetail'])
        ->where('remote_sub_id', '[A-Za-z0-9_]+')
        ->name('refactor.admin.payment-gateways.remote.subscription');

    // Sending Servers
    Route::get('sending-servers', [AdminSendingServerController::class, 'index'])->name('refactor.admin.sending-servers.index');
    Route::get('sending-servers/listing', [AdminSendingServerController::class, 'listing'])->name('refactor.admin.sending-servers.listing');
    Route::get('sending-servers/select', [AdminSendingServerController::class, 'select'])->name('refactor.admin.sending-servers.select');
    Route::get('sending-servers/create/{type}', [AdminSendingServerController::class, 'create'])->name('refactor.admin.sending-servers.create');
    Route::post('sending-servers/store/{type}', [AdminSendingServerController::class, 'store'])->name('refactor.admin.sending-servers.store');
    Route::get('sending-servers/{uid}/edit', [AdminSendingServerController::class, 'edit'])->name('refactor.admin.sending-servers.edit');
    Route::patch('sending-servers/{uid}/connection/save', [AdminSendingServerController::class, 'connectionSave'])->name('refactor.admin.sending-servers.connection-save');
    Route::post('sending-servers/enable', [AdminSendingServerController::class, 'enable'])->name('refactor.admin.sending-servers.enable');
    Route::post('sending-servers/disable', [AdminSendingServerController::class, 'disable'])->name('refactor.admin.sending-servers.disable');
    Route::post('sending-servers/delete', [AdminSendingServerController::class, 'delete'])->name('refactor.admin.sending-servers.delete');
    Route::post('sending-servers/{uid}/test-connection', [AdminSendingServerController::class, 'testConnection'])->name('refactor.admin.sending-servers.test-connection');
    Route::match(['get', 'post'], 'sending-servers/{uid}/test', [AdminSendingServerController::class, 'test'])->name('refactor.admin.sending-servers.test');
    Route::match(['get', 'post'], 'sending-servers/sending-limit', [AdminSendingServerController::class, 'sendingLimit'])->name('refactor.admin.sending-servers.sending-limit');
    Route::post('sending-servers/{uid}/configuration/save', [AdminSendingServerController::class, 'configurationSave'])->name('refactor.admin.sending-servers.configuration-save');
    Route::post('sending-servers/{uid}/identity/save', [AdminSendingServerController::class, 'identitySave'])->name('refactor.admin.sending-servers.identity-save');
    Route::match(['get', 'post'], 'sending-servers/{uid}/add-domain', [AdminSendingServerController::class, 'addDomain'])->name('refactor.admin.sending-servers.add-domain');
    Route::post('sending-servers/{uid}/remove-domain/{domain}', [AdminSendingServerController::class, 'removeDomain'])->name('refactor.admin.sending-servers.remove-domain');
    Route::get('sending-servers/{uid}/senders/dropbox', [AdminSendingServerController::class, 'fromDropbox'])->name('refactor.admin.sending-servers.dropbox');
    Route::get('sending-servers/aws-region-host', [AdminSendingServerController::class, 'awsRegionHost'])->name('refactor.admin.sending-servers.aws-region-host');
    Route::get('sending-servers/{uid}/warmup-stats', [AdminSendingServerController::class, 'warmupStats'])->name('refactor.admin.sending-servers.warmup-stats');
    Route::post('sending-servers/{uid}/warmup/save', [AdminSendingServerController::class, 'warmupSave'])->name('refactor.admin.sending-servers.warmup-save');
    Route::post('sending-servers/{uid}/warmup/reset', [AdminSendingServerController::class, 'warmupReset'])->name('refactor.admin.sending-servers.warmup-reset');
    Route::get('sending-servers/{uid}/gmail-oauth/setup', [AdminSendingServerController::class, 'gmailOAuthSetup'])->name('refactor.admin.sending-servers.gmail-oauth-setup');
    Route::get('sending-servers/{uid}/gmail-oauth/redirect', [AdminSendingServerController::class, 'gmailOAuthRedirect'])->name('refactor.admin.sending-servers.gmail-oauth-redirect');
    Route::get('sending-servers/gmail-oauth/callback', [AdminSendingServerController::class, 'gmailOAuthCallback'])->name('refactor.admin.sending-servers.gmail-oauth-callback');
    Route::get('sending-servers/type-chart', [AdminSendingServerController::class, 'typeChart'])->name('refactor.admin.sending-servers.type-chart');

    // Bounce Handlers
    Route::get('bounce-handlers', [AdminBounceHandlerController::class, 'index'])->name('refactor.admin.bounce-handlers.index');
    Route::get('bounce-handlers/listing', [AdminBounceHandlerController::class, 'listing'])->name('refactor.admin.bounce-handlers.listing');
    Route::get('bounce-handlers/create', [AdminBounceHandlerController::class, 'create'])->name('refactor.admin.bounce-handlers.create');
    Route::post('bounce-handlers/store', [AdminBounceHandlerController::class, 'store'])->name('refactor.admin.bounce-handlers.store');
    Route::get('bounce-handlers/{uid}/edit', [AdminBounceHandlerController::class, 'edit'])->name('refactor.admin.bounce-handlers.edit');
    Route::post('bounce-handlers/{uid}/update', [AdminBounceHandlerController::class, 'update'])->name('refactor.admin.bounce-handlers.update');
    Route::post('bounce-handlers/delete', [AdminBounceHandlerController::class, 'delete'])->name('refactor.admin.bounce-handlers.delete');
    Route::post('bounce-handlers/{uid}/test', [AdminBounceHandlerController::class, 'test'])->name('refactor.admin.bounce-handlers.test');
    Route::post('bounce-handlers/{uid}/run', [AdminBounceHandlerController::class, 'run'])->name('refactor.admin.bounce-handlers.run');

    // FBL Handlers
    Route::get('fbl-handlers', [AdminFeedbackLoopHandlerController::class, 'index'])->name('refactor.admin.fbl-handlers.index');
    Route::get('fbl-handlers/listing', [AdminFeedbackLoopHandlerController::class, 'listing'])->name('refactor.admin.fbl-handlers.listing');
    Route::get('fbl-handlers/create', [AdminFeedbackLoopHandlerController::class, 'create'])->name('refactor.admin.fbl-handlers.create');
    Route::post('fbl-handlers/store', [AdminFeedbackLoopHandlerController::class, 'store'])->name('refactor.admin.fbl-handlers.store');
    Route::get('fbl-handlers/{uid}/edit', [AdminFeedbackLoopHandlerController::class, 'edit'])->name('refactor.admin.fbl-handlers.edit');
    Route::post('fbl-handlers/{uid}/update', [AdminFeedbackLoopHandlerController::class, 'update'])->name('refactor.admin.fbl-handlers.update');
    Route::post('fbl-handlers/delete', [AdminFeedbackLoopHandlerController::class, 'delete'])->name('refactor.admin.fbl-handlers.delete');
    Route::post('fbl-handlers/{uid}/test', [AdminFeedbackLoopHandlerController::class, 'test'])->name('refactor.admin.fbl-handlers.test');

    // Verification Servers
    Route::get('verification-servers', [AdminEmailVerificationServerController::class, 'index'])->name('refactor.admin.verification-servers.index');
    Route::get('verification-servers/listing', [AdminEmailVerificationServerController::class, 'listing'])->name('refactor.admin.verification-servers.listing');
    Route::get('verification-servers/create', [AdminEmailVerificationServerController::class, 'create'])->name('refactor.admin.verification-servers.create');
    Route::post('verification-servers/store', [AdminEmailVerificationServerController::class, 'store'])->name('refactor.admin.verification-servers.store');
    Route::get('verification-servers/{uid}/edit', [AdminEmailVerificationServerController::class, 'edit'])->name('refactor.admin.verification-servers.edit');
    Route::post('verification-servers/{uid}/update', [AdminEmailVerificationServerController::class, 'update'])->name('refactor.admin.verification-servers.update');
    Route::post('verification-servers/enable', [AdminEmailVerificationServerController::class, 'enable'])->name('refactor.admin.verification-servers.enable');
    Route::post('verification-servers/disable', [AdminEmailVerificationServerController::class, 'disable'])->name('refactor.admin.verification-servers.disable');
    Route::post('verification-servers/delete', [AdminEmailVerificationServerController::class, 'delete'])->name('refactor.admin.verification-servers.delete');
    Route::get('verification-servers/options', [AdminEmailVerificationServerController::class, 'options'])->name('refactor.admin.verification-servers.options');

    // Warmup Strategies
    Route::get('warmup-strategies', [AdminWarmupStrategyController::class, 'index'])->name('refactor.admin.warmup-strategies.index');
    Route::get('warmup-strategies/listing', [AdminWarmupStrategyController::class, 'listing'])->name('refactor.admin.warmup-strategies.listing');
    Route::get('warmup-strategies/create', [AdminWarmupStrategyController::class, 'create'])->name('refactor.admin.warmup-strategies.create');
    Route::post('warmup-strategies/store', [AdminWarmupStrategyController::class, 'store'])->name('refactor.admin.warmup-strategies.store');
    Route::get('warmup-strategies/{uid}/edit', [AdminWarmupStrategyController::class, 'edit'])->name('refactor.admin.warmup-strategies.edit');
    Route::post('warmup-strategies/{uid}/update', [AdminWarmupStrategyController::class, 'update'])->name('refactor.admin.warmup-strategies.update');
    Route::post('warmup-strategies/enable', [AdminWarmupStrategyController::class, 'enable'])->name('refactor.admin.warmup-strategies.enable');
    Route::post('warmup-strategies/disable', [AdminWarmupStrategyController::class, 'disable'])->name('refactor.admin.warmup-strategies.disable');
    Route::post('warmup-strategies/delete', [AdminWarmupStrategyController::class, 'delete'])->name('refactor.admin.warmup-strategies.delete');
    Route::post('warmup-strategies/preview', [AdminWarmupStrategyController::class, 'preview'])->name('refactor.admin.warmup-strategies.preview');

    // Remote Plan Mappings
    Route::get('remote-plan-mappings', [AdminPlanRemoteMappingController::class, 'index'])->name('refactor.admin.remote-plan-mappings.index');
    Route::get('remote-plan-mappings/remote-plans', [AdminPlanRemoteMappingController::class, 'remotePlans'])->name('refactor.admin.remote-plan-mappings.remote-plans');
    Route::post('remote-plan-mappings/store', [AdminPlanRemoteMappingController::class, 'store'])->name('refactor.admin.remote-plan-mappings.store');
    Route::delete('remote-plan-mappings/destroy', [AdminPlanRemoteMappingController::class, 'destroy'])->name('refactor.admin.remote-plan-mappings.destroy');
    Route::post('remote-plan-mappings/sync-one', [AdminPlanRemoteMappingController::class, 'syncOne'])->name('refactor.admin.remote-plan-mappings.sync-one');
    Route::post('remote-plan-mappings/sync-all', [AdminPlanRemoteMappingController::class, 'syncAll'])->name('refactor.admin.remote-plan-mappings.sync-all');

    // Email Verification Plans
    Route::get('email-verification-plans', [AdminEmailVerificationPlanController::class, 'index'])->name('refactor.admin.email-verification-plans.index');
    Route::get('email-verification-plans/listing', [AdminEmailVerificationPlanController::class, 'listing'])->name('refactor.admin.email-verification-plans.listing');
    Route::get('email-verification-plans/create', [AdminEmailVerificationPlanController::class, 'create'])->name('refactor.admin.email-verification-plans.create');
    Route::post('email-verification-plans/store', [AdminEmailVerificationPlanController::class, 'store'])->name('refactor.admin.email-verification-plans.store');
    Route::get('email-verification-plans/{uid}/edit', [AdminEmailVerificationPlanController::class, 'edit'])->name('refactor.admin.email-verification-plans.edit');
    Route::post('email-verification-plans/{uid}/update', [AdminEmailVerificationPlanController::class, 'update'])->name('refactor.admin.email-verification-plans.update');
    Route::post('email-verification-plans/delete', [AdminEmailVerificationPlanController::class, 'delete'])->name('refactor.admin.email-verification-plans.delete');
    Route::post('email-verification-plans/{uid}/visibility-on', [AdminEmailVerificationPlanController::class, 'visibilityOn'])->name('refactor.admin.email-verification-plans.visibility-on');
    Route::post('email-verification-plans/{uid}/visibility-off', [AdminEmailVerificationPlanController::class, 'visibilityOff'])->name('refactor.admin.email-verification-plans.visibility-off');

    // Email Templates
    Route::get('email-templates', [AdminSystemEmailTemplateController::class, 'index'])->name('refactor.admin.email-templates.index');
    Route::get('email-templates/listing', [AdminSystemEmailTemplateController::class, 'listing'])->name('refactor.admin.email-templates.listing');
    Route::get('email-templates/gallery', [AdminSystemEmailTemplateController::class, 'gallery'])->name('refactor.admin.email-templates.gallery');
    Route::get('email-templates/add', [AdminSystemEmailTemplateController::class, 'add'])->name('refactor.admin.email-templates.add');
    Route::post('email-templates/store', [AdminSystemEmailTemplateController::class, 'store'])->name('refactor.admin.email-templates.store');
    Route::get('email-templates/{uid}/copy', [AdminSystemEmailTemplateController::class, 'copy'])->name('refactor.admin.email-templates.copy');
    Route::post('email-templates/{uid}/store-copy', [AdminSystemEmailTemplateController::class, 'storeCopy'])->name('refactor.admin.email-templates.store-copy');
    Route::get('email-templates/{uid}/change-name', [AdminSystemEmailTemplateController::class, 'changeName'])->name('refactor.admin.email-templates.change-name');
    Route::post('email-templates/{uid}/update-name', [AdminSystemEmailTemplateController::class, 'updateName'])->name('refactor.admin.email-templates.update-name');
    Route::post('email-templates/delete', [AdminSystemEmailTemplateController::class, 'delete'])->name('refactor.admin.email-templates.delete');
    Route::get('email-templates/{uid}/preview', [AdminSystemEmailTemplateController::class, 'preview'])->name('refactor.admin.email-templates.preview');

    // Form Templates
    Route::get('form-templates', [AdminFormTemplateController::class, 'index'])->name('refactor.admin.form-templates.index');
    Route::get('form-templates/listing', [AdminFormTemplateController::class, 'listing'])->name('refactor.admin.form-templates.listing');
    Route::get('form-templates/gallery', [AdminFormTemplateController::class, 'gallery'])->name('refactor.admin.form-templates.gallery');
    Route::get('form-templates/add', [AdminFormTemplateController::class, 'add'])->name('refactor.admin.form-templates.add');
    Route::post('form-templates/store', [AdminFormTemplateController::class, 'store'])->name('refactor.admin.form-templates.store');
    Route::get('form-templates/{uid}/copy', [AdminFormTemplateController::class, 'copy'])->name('refactor.admin.form-templates.copy');
    Route::post('form-templates/{uid}/store-copy', [AdminFormTemplateController::class, 'storeCopy'])->name('refactor.admin.form-templates.store-copy');
    Route::get('form-templates/{uid}/change-name', [AdminFormTemplateController::class, 'changeName'])->name('refactor.admin.form-templates.change-name');
    Route::post('form-templates/{uid}/update-name', [AdminFormTemplateController::class, 'updateName'])->name('refactor.admin.form-templates.update-name');
    Route::post('form-templates/delete', [AdminFormTemplateController::class, 'delete'])->name('refactor.admin.form-templates.delete');
    Route::get('form-templates/{uid}/preview', [AdminFormTemplateController::class, 'preview'])->name('refactor.admin.form-templates.preview');

    // Page Templates (funnel / commerce / landing page templates — multi-instance wrapper over Template).
    // 11-method CRUD mirror of form-templates (+ separate `builder` route in the admin builder group below).
    Route::get('page-templates', [AdminPageTemplateController::class, 'index'])->name('refactor.admin.page-templates.index');
    Route::get('page-templates/listing', [AdminPageTemplateController::class, 'listing'])->name('refactor.admin.page-templates.listing');
    Route::get('page-templates/gallery', [AdminPageTemplateController::class, 'gallery'])->name('refactor.admin.page-templates.gallery');
    Route::get('page-templates/add', [AdminPageTemplateController::class, 'add'])->name('refactor.admin.page-templates.add');
    Route::post('page-templates/store', [AdminPageTemplateController::class, 'store'])->name('refactor.admin.page-templates.store');
    Route::get('page-templates/{uid}/copy', [AdminPageTemplateController::class, 'copy'])->name('refactor.admin.page-templates.copy');
    Route::post('page-templates/{uid}/store-copy', [AdminPageTemplateController::class, 'storeCopy'])->name('refactor.admin.page-templates.store-copy');
    Route::get('page-templates/{uid}/change-name', [AdminPageTemplateController::class, 'changeName'])->name('refactor.admin.page-templates.change-name');
    Route::post('page-templates/{uid}/update-name', [AdminPageTemplateController::class, 'updateName'])->name('refactor.admin.page-templates.update-name');
    Route::post('page-templates/delete', [AdminPageTemplateController::class, 'delete'])->name('refactor.admin.page-templates.delete');
    Route::get('page-templates/{uid}/preview', [AdminPageTemplateController::class, 'preview'])->name('refactor.admin.page-templates.preview');

    // System Pages (pricing, invoice, terms, signup — system singletons).
    // Renamed from `page-templates` on 2026-04-24 (Wave 1 Step 0 of PAGE_PLAN) to free that URL for the funnel PageTemplate module.
    Route::get('system-pages', [AdminSystemTemplateController::class, 'index'])->name('refactor.admin.system-pages.index');
    Route::get('system-pages/listing', [AdminSystemTemplateController::class, 'listing'])->name('refactor.admin.system-pages.listing');
    Route::get('system-pages/pricing-page/builder', [AdminSystemTemplateController::class, 'pricingPageBuilder'])->name('refactor.admin.system-pages.pricing-page-builder');
    Route::get('system-pages/{uid}/edit', [AdminSystemTemplateController::class, 'edit'])->name('refactor.admin.system-pages.edit');
    Route::get('system-pages/{uid}/builder', [AdminSystemTemplateController::class, 'builder'])->name('refactor.admin.system-pages.builder');
    Route::match(['get', 'post'], 'system-pages/{uid}/custom-html', [AdminSystemTemplateController::class, 'customHtml'])->name('refactor.admin.system-pages.custom_html');
    Route::post('system-pages/{uid}/save', [AdminSystemTemplateController::class, 'save'])->name('refactor.admin.system-pages.save');

    // Admins
    Route::get('admins', [AdminAdminController::class, 'index'])->name('refactor.admin.admins.index');
    Route::get('admins/listing', [AdminAdminController::class, 'listing'])->name('refactor.admin.admins.listing');
    Route::get('admins/create', [AdminAdminController::class, 'create'])->name('refactor.admin.admins.create');
    Route::post('admins/store', [AdminAdminController::class, 'store'])->name('refactor.admin.admins.store');
    Route::get('admins/{uid}/edit', [AdminAdminController::class, 'edit'])->name('refactor.admin.admins.edit');
    Route::post('admins/{uid}/update', [AdminAdminController::class, 'update'])->name('refactor.admin.admins.update');
    Route::post('admins/enable', [AdminAdminController::class, 'enable'])->name('refactor.admin.admins.enable');
    Route::post('admins/disable', [AdminAdminController::class, 'disable'])->name('refactor.admin.admins.disable');
    Route::post('admins/delete', [AdminAdminController::class, 'delete'])->name('refactor.admin.admins.delete');
    Route::post('admins/login-as', [AdminAdminController::class, 'loginAs'])->name('refactor.admin.admins.login-as');
    Route::get('admins/login-back', [AdminAdminController::class, 'loginBack'])->name('refactor.admin.admins.login-back');
    Route::get('admins/one-click-login', [AdminAdminController::class, 'oneClickLogin'])->name('refactor.admin.admins.one-click-login');

    // Admin Groups
    Route::get('admin-groups', [AdminAdminGroupController::class, 'index'])->name('refactor.admin.admin-groups.index');
    Route::get('admin-groups/listing', [AdminAdminGroupController::class, 'listing'])->name('refactor.admin.admin-groups.listing');
    Route::get('admin-groups/create', [AdminAdminGroupController::class, 'create'])->name('refactor.admin.admin-groups.create');
    Route::post('admin-groups/store', [AdminAdminGroupController::class, 'store'])->name('refactor.admin.admin-groups.store');
    Route::get('admin-groups/{id}/edit', [AdminAdminGroupController::class, 'edit'])->name('refactor.admin.admin-groups.edit');
    Route::post('admin-groups/{id}/update', [AdminAdminGroupController::class, 'update'])->name('refactor.admin.admin-groups.update');
    Route::post('admin-groups/delete', [AdminAdminGroupController::class, 'delete'])->name('refactor.admin.admin-groups.delete');

    // Customer Roles (global roles for customer team members)
    // Roles — canonical URL moved to /admin/roles (see /admin group below).
    Route::get('roles/{path?}', function (Request $request, string $path = '') {
        $qs = $request->getQueryString();
        return redirect('/admin/roles' . ($path === '' ? '' : '/' . $path) . ($qs ? '?' . $qs : ''));
    })->where('path', '.*');

    // Account
    Route::match(['get', 'post'], 'account/profile', [AdminAccountController::class, 'profile'])->name('refactor.admin.account.profile');
    Route::match(['get', 'post'], 'account/contact', [AdminAccountController::class, 'contact'])->name('refactor.admin.account.contact');
    Route::get('account/api', [AdminAccountController::class, 'api'])->name('refactor.admin.account.api');
    Route::post('account/renew-token', [AdminAccountController::class, 'renewToken'])->name('refactor.admin.account.renew-token');
    Route::get('account/2fa', [AdminAccountController::class, 'twoFactor'])->name('refactor.admin.account.2fa');
    Route::post('account/2fa/enable', [AdminAccountController::class, 'twoFactorEnable'])->name('refactor.admin.account.2fa_enable');
    Route::post('account/2fa/disable', [AdminAccountController::class, 'twoFactorDisable'])->name('refactor.admin.account.2fa_disable');
    Route::post('account/2fa/save', [AdminAccountController::class, 'twoFactorSave'])->name('refactor.admin.account.2fa_save');
    Route::post('account/2fa/google/generate-key', [AdminAccountController::class, 'twoFactorGenerateKey'])->name('refactor.admin.account.2fa_generate_key');
    Route::post('account/2fa/google/save-key', [AdminAccountController::class, 'twoFactorSaveKey'])->name('refactor.admin.account.2fa_save_key');
    Route::post('account/color-scheme', [AdminAccountController::class, 'saveColorScheme'])->name('refactor.admin.account.color_scheme');
    Route::get('account/languages', [AdminAccountController::class, 'languages'])->name('refactor.admin.account.languages');
    Route::post('account/change-language', [AdminAccountController::class, 'changeLanguage'])->name('refactor.admin.account.changeLanguage');

    // Settings
    Route::get('settings', [AdminSettingController::class, 'index'])->name('refactor.admin.settings.index');
    Route::match(['get', 'post'], 'settings/general', [AdminSettingController::class, 'general'])->name('refactor.admin.settings.general');
    Route::match(['get', 'post'], 'settings/mailer', [AdminSettingController::class, 'mailer'])->name('refactor.admin.settings.mailer');
    Route::post('settings/mailer/test', [AdminSettingController::class, 'mailerTest'])->name('refactor.admin.settings.mailer-test');
    Route::get('settings/urls', [AdminSettingController::class, 'urls'])->name('refactor.admin.settings.urls');
    Route::post('settings/urls/update', [AdminSettingController::class, 'urlsUpdate'])->name('refactor.admin.settings.urls-update');
    Route::match(['get', 'post'], 'settings/cronjob', [AdminSettingController::class, 'cronjob'])->name('refactor.admin.settings.cronjob');
    Route::match(['get', 'post'], 'settings/payment', [AdminSettingController::class, 'payment'])->name('refactor.admin.settings.payment');
    Route::get('settings/advanced', [AdminSettingController::class, 'advanced'])->name('refactor.admin.settings.advanced');
    Route::post('settings/advanced/{name}/update', [AdminSettingController::class, 'advancedUpdate'])->name('refactor.admin.settings.advanced-update');
    Route::match(['get', 'post'], 'settings/license', [AdminSettingController::class, 'license'])->name('refactor.admin.settings.license');
    Route::post('settings/license/remove', [AdminSettingController::class, 'licenseRemove'])->name('refactor.admin.settings.license-remove');
    Route::post('settings/license/refresh', [AdminSettingController::class, 'licenseRefresh'])->name('refactor.admin.settings.license-refresh');
    Route::get('settings/upgrade', [AdminSettingController::class, 'upgrade'])->name('refactor.admin.settings.upgrade');
    Route::post('settings/upgrade/do', [AdminSettingController::class, 'doUpgrade'])->name('refactor.admin.settings.do-upgrade');
    Route::post('settings/upgrade/cancel', [AdminSettingController::class, 'cancelUpgrade'])->name('refactor.admin.settings.cancel-upgrade');
    Route::post('settings/upgrade/upload', [AdminSettingController::class, 'uploadPatch'])->name('refactor.admin.settings.upload-patch');
    Route::post('settings/upgrade/download-url', [AdminSettingController::class, 'downloadPatchFromUrl'])->name('refactor.admin.settings.download-patch-url');
    Route::get('settings/logs', [AdminSettingController::class, 'logs'])->name('refactor.admin.settings.logs');

    // Languages
    Route::get('languages', [AdminLanguageController::class, 'index'])->name('refactor.admin.languages.index');
    Route::get('languages/listing', [AdminLanguageController::class, 'listing'])->name('refactor.admin.languages.listing');
    Route::get('languages/create', [AdminLanguageController::class, 'create'])->name('refactor.admin.languages.create');
    Route::post('languages/store', [AdminLanguageController::class, 'store'])->name('refactor.admin.languages.store');
    Route::get('languages/{uid}/edit', [AdminLanguageController::class, 'edit'])->name('refactor.admin.languages.edit');
    Route::post('languages/{uid}/update', [AdminLanguageController::class, 'update'])->name('refactor.admin.languages.update');
    Route::post('languages/enable', [AdminLanguageController::class, 'enable'])->name('refactor.admin.languages.enable');
    Route::post('languages/disable', [AdminLanguageController::class, 'disable'])->name('refactor.admin.languages.disable');
    Route::post('languages/delete', [AdminLanguageController::class, 'delete'])->name('refactor.admin.languages.delete');
    Route::get('languages/{uid}/translate', [AdminLanguageController::class, 'translate'])->name('refactor.admin.languages.translate');
    Route::get('languages/{uid}/download', [AdminLanguageController::class, 'download'])->name('refactor.admin.languages.download');
    Route::match(['get', 'post'], 'languages/{uid}/upload', [AdminLanguageController::class, 'upload'])->name('refactor.admin.languages.upload');

    // Translation
    Route::get('translation', [AdminTranslationController::class, 'index'])->name('refactor.admin.translation.index');
    Route::get('translation/phrases-list', [AdminTranslationController::class, 'phrasesList'])->name('refactor.admin.translation.phrases-list');
    Route::post('translation/phrases-save', [AdminTranslationController::class, 'phrasesSave'])->name('refactor.admin.translation.phrases-save');

    // Activity Logs (6 types via single controller)
    Route::get('logs/{type}', [AdminLogController::class, 'index'])->name('refactor.admin.logs.index')->where('type', 'tracking|bounce|open|click|feedback|unsubscribe');
    Route::get('logs/{type}/listing', [AdminLogController::class, 'listing'])->name('refactor.admin.logs.listing')->where('type', 'tracking|bounce|open|click|feedback|unsubscribe');
    // Legacy sidebar alias
    Route::get('tracking-log', function() { return redirect()->route('refactor.admin.logs.index', 'tracking'); })->name('refactor.admin.tracking-log.index');

    // Admin AI surfaces (`/rui/admin/ai-*`) moved into the acelle/ai
    // plugin's routes.php (W4 of the AI-extraction plan). The plugin
    // owns its own `Route::group(['prefix' => 'rui/admin', ...])` with
    // matching outer middleware + plugin-specific `ai.active` gate.

    // Blacklist
    Route::get('blacklist', [AdminBlacklistController::class, 'index'])->name('refactor.admin.blacklist.index');
    Route::get('blacklist/listing', [AdminBlacklistController::class, 'listing'])->name('refactor.admin.blacklist.listing');
    Route::post('blacklist/store', [AdminBlacklistController::class, 'store'])->name('refactor.admin.blacklist.store');
    Route::post('blacklist/delete', [AdminBlacklistController::class, 'delete'])->name('refactor.admin.blacklist.delete');
    Route::get('blacklist/{id}/reason', [AdminBlacklistController::class, 'reason'])->name('refactor.admin.blacklist.reason');
    Route::get('blacklist/import', [AdminBlacklistController::class, 'import'])->name('refactor.admin.blacklist.import');
    Route::post('blacklist/start-import', [AdminBlacklistController::class, 'startImport'])->name('refactor.admin.blacklist.start-import');
    Route::get('blacklist/import-progress/{job_uid}', [AdminBlacklistController::class, 'importProgress'])->name('refactor.admin.blacklist.import-progress');
    Route::post('blacklist/cancel-import/{job_uid}', [AdminBlacklistController::class, 'cancelImport'])->name('refactor.admin.blacklist.cancel-import');

    // Notifications — admin inbox = direct rows + shared 'admins' broadcast
    Route::prefix('notifications')
        ->name('refactor.admin.notifications.')
        ->group(function () {
            $c = AdminNotificationController::class;
            Route::get('/',          [$c, 'index'])->name('index');
            Route::get('/listing',   [$c, 'listing'])->name('listing');
            Route::get('/dropdown',  [$c, 'dropdown'])->name('dropdown');
            Route::get('/badge',     [$c, 'badge'])->name('badge');
            Route::post('/{id}/read',     [$c, 'markRead'])->name('read');
            Route::post('/{id}/unread',   [$c, 'markUnread'])->name('unread');
            Route::post('/{id}/dismiss',  [$c, 'dismiss'])->name('dismiss');
            Route::post('/read-all',  [$c, 'markAllRead'])->name('read_all');
        });

    // Plugins
    Route::get('plugins', [AdminPluginController::class, 'index'])->name('refactor.admin.plugins.index');
    Route::get('plugins/listing', [AdminPluginController::class, 'listing'])->name('refactor.admin.plugins.listing');
    Route::match(['get', 'post'], 'plugins/install', [AdminPluginController::class, 'install'])->name('refactor.admin.plugins.install');
    Route::post('plugins/enable', [AdminPluginController::class, 'enable'])->name('refactor.admin.plugins.enable');
    Route::post('plugins/disable', [AdminPluginController::class, 'disable'])->name('refactor.admin.plugins.disable');
    Route::post('plugins/refresh', [AdminPluginController::class, 'refresh'])->name('refactor.admin.plugins.refresh');
    Route::post('plugins/delete', [AdminPluginController::class, 'delete'])->name('refactor.admin.plugins.delete');

    // GeoIP
    Route::get('geoip', [AdminGeoIPController::class, 'index'])->name('refactor.admin.geoip.index');
    Route::match(['get', 'post'], 'geoip/setting', [AdminGeoIPController::class, 'setting'])->name('refactor.admin.geoip.setting');
    Route::post('geoip/reset', [AdminGeoIPController::class, 'reset'])->name('refactor.admin.geoip.reset');

    // Webhooks
    Route::get('webhooks', [AdminWebhookController::class, 'index'])->name('refactor.admin.webhooks.index');
    Route::get('webhooks/listing', [AdminWebhookController::class, 'listing'])->name('refactor.admin.webhooks.listing');
    Route::get('webhooks/create', [AdminWebhookController::class, 'create'])->name('refactor.admin.webhooks.create');
    Route::post('webhooks/store', [AdminWebhookController::class, 'store'])->name('refactor.admin.webhooks.store');
    Route::get('webhooks/{uid}/edit', [AdminWebhookController::class, 'edit'])->name('refactor.admin.webhooks.edit');
    Route::post('webhooks/{uid}/update', [AdminWebhookController::class, 'update'])->name('refactor.admin.webhooks.update');
    Route::match(['get', 'post'], 'webhooks/{uid}/setup', [AdminWebhookController::class, 'setup'])->name('refactor.admin.webhooks.setup');
    Route::post('webhooks/enable', [AdminWebhookController::class, 'enable'])->name('refactor.admin.webhooks.enable');
    Route::post('webhooks/disable', [AdminWebhookController::class, 'disable'])->name('refactor.admin.webhooks.disable');
    Route::post('webhooks/delete', [AdminWebhookController::class, 'delete'])->name('refactor.admin.webhooks.delete');

    // HTTP Config
    Route::get('http-config', [AdminHttpConfigController::class, 'index'])->name('refactor.admin.http-config.index');
    Route::get('http-config/listing', [AdminHttpConfigController::class, 'listing'])->name('refactor.admin.http-config.listing');
    Route::get('http-config/{uid}/requests', [AdminHttpConfigController::class, 'httpRequests'])->name('refactor.admin.http-config.requests');
    Route::get('http-config/{uid}/requests-list', [AdminHttpConfigController::class, 'httpRequestsList'])->name('refactor.admin.http-config.requests-list');
    Route::get('http-config/{uid}/logs', [AdminHttpConfigController::class, 'httpRequestLogs'])->name('refactor.admin.http-config.logs');

    // Power Search (command palette)
    Route::get('power-search', [AdminSearchController::class, 'search'])->name('refactor.admin.power-search');

    // Search (admin topbar AJAX — legacy, kept for backward compat)
    Route::get('search/general', [AdminSearchController::class, 'general'])->name('refactor.admin.search.general');
    Route::get('search/customers', [AdminSearchController::class, 'customers'])->name('refactor.admin.search.customers');
    Route::get('search/plans', [AdminSearchController::class, 'plans'])->name('refactor.admin.search.plans');
    Route::get('search/templates', [AdminSearchController::class, 'templates'])->name('refactor.admin.search.templates');
    Route::get('search/sending-servers', [AdminSearchController::class, 'sendingServers'])->name('refactor.admin.search.sending-servers');

    // API Docs
    Route::get('api-docs', [AdminApiDocController::class, 'index'])->name('refactor.admin.api-docs');

    // Monitor (campaign)
    Route::get('monitor', [AdminMonitorCampaignController::class, 'index'])->name('refactor.admin.monitor.index');
    Route::get('monitor/listing', [AdminMonitorCampaignController::class, 'listing'])->name('refactor.admin.monitor.listing');

    // Email Verification Tool
    Route::match(['get', 'post'], 'verification-tool', [AdminVerificationToolController::class, 'index'])->name('refactor.admin.verification-tool.index');

    // Sub-Admin Groups 2
    Route::get('admin-groups2', [AdminAdminGroup2Controller::class, 'index'])->name('refactor.admin.admin-groups2.index');
    Route::get('admin-groups2/listing', [AdminAdminGroup2Controller::class, 'listing'])->name('refactor.admin.admin-groups2.listing');
    Route::get('admin-groups2/create', [AdminAdminGroup2Controller::class, 'create'])->name('refactor.admin.admin-groups2.create');
    Route::post('admin-groups2/store', [AdminAdminGroup2Controller::class, 'store'])->name('refactor.admin.admin-groups2.store');
    Route::get('admin-groups2/{id}/edit', [AdminAdminGroup2Controller::class, 'edit'])->name('refactor.admin.admin-groups2.edit');
    Route::post('admin-groups2/{id}/update', [AdminAdminGroup2Controller::class, 'update'])->name('refactor.admin.admin-groups2.update');
    Route::post('admin-groups2/delete', [AdminAdminGroup2Controller::class, 'delete'])->name('refactor.admin.admin-groups2.delete');

    // Sub-Admins 2
    Route::get('admins2', [AdminAdmin2Controller::class, 'index'])->name('refactor.admin.admins2.index');
    Route::get('admins2/listing', [AdminAdmin2Controller::class, 'listing'])->name('refactor.admin.admins2.listing');
    Route::get('admins2/create', [AdminAdmin2Controller::class, 'create'])->name('refactor.admin.admins2.create');
    Route::post('admins2/store', [AdminAdmin2Controller::class, 'store'])->name('refactor.admin.admins2.store');
    Route::get('admins2/{uid}/edit', [AdminAdmin2Controller::class, 'edit'])->name('refactor.admin.admins2.edit');
    Route::post('admins2/{uid}/update', [AdminAdmin2Controller::class, 'update'])->name('refactor.admin.admins2.update');
    Route::post('admins2/enable', [AdminAdmin2Controller::class, 'enable'])->name('refactor.admin.admins2.enable');
    Route::post('admins2/disable', [AdminAdmin2Controller::class, 'disable'])->name('refactor.admin.admins2.disable');
    Route::post('admins2/delete', [AdminAdmin2Controller::class, 'delete'])->name('refactor.admin.admins2.delete');
    Route::get('admins2/{uid}/login-as', [AdminAdmin2Controller::class, 'loginAs'])->name('refactor.admin.admins2.login-as');
    Route::get('admins2/login-back', [AdminAdmin2Controller::class, 'loginBack'])->name('refactor.admin.admins2.login-back');

    // Plan payment stub — moved to /admin/plans/* group below

    // Invoice custom create + template edit — moved to /admin/invoices/* group below

    // HTTP Config test
    Route::match(['get', 'post'], 'http-config/{uid}/test', [AdminHttpConfigController::class, 'test'])->name('refactor.admin.http-config.test');

    // Admin builders (clone — views delegate to builder.default)
    Route::match(['get', 'post'], 'email-templates/{uid}/builder', [AdminSystemEmailTemplateController::class, 'builder'])->name('refactor.admin.email-templates.builder');
    Route::match(['get', 'post'], 'email-templates/{uid}/custom-html', [AdminSystemEmailTemplateController::class, 'customHtml'])->name('refactor.admin.email-templates.custom_html');
    Route::match(['get', 'post'], 'form-templates/{uid}/builder', [AdminFormTemplateController::class, 'builder'])->name('refactor.admin.form-templates.builder');
    Route::match(['get', 'post'], 'page-templates/{uid}/builder', [AdminPageTemplateController::class, 'builder'])->name('refactor.admin.page-templates.builder');
    Route::match(['get', 'post'], 'page-templates/{uid}/custom-html', [AdminPageTemplateController::class, 'customHtml'])->name('refactor.admin.page-templates.custom_html');
    // Page templates use pricing page builder (already in edit view), not generic builder

    // Template builder AJAX save
    Route::post('templates/{uid}/builder-edit', [AdminTemplateController::class, 'builderEdit'])->name('refactor.admin.templates.builder_edit');
    Route::post('templates/{uid}/change-template', [AdminTemplateController::class, 'changeTemplate'])->name('refactor.admin.templates.change_template');

    // Admin Ads
    Route::get('ads/dashboard', [\App\Http\Controllers\Refactor\Admin\AdminAdsDashboardController::class, 'index'])->name('refactor.admin.ads.dashboard');
    Route::get('ads/observability', [\App\Http\Controllers\Refactor\Admin\AdminAdsObservabilityController::class, 'index'])->name('refactor.admin.ads.observability');
    Route::get('ads/platforms', [\App\Http\Controllers\Refactor\Admin\AdminAdsPlatformController::class, 'index'])->name('refactor.admin.ads.platforms.index');
    Route::get('ads/platforms/listing', [\App\Http\Controllers\Refactor\Admin\AdminAdsPlatformController::class, 'listing'])->name('refactor.admin.ads.platforms.listing');

    // Admin Ads Settings (Phase N)
    Route::get('ads/settings', [\App\Http\Controllers\Refactor\Admin\AdminAdsSettingsController::class, 'show'])->name('refactor.admin.ads.settings.show');
    Route::post('ads/settings', [\App\Http\Controllers\Refactor\Admin\AdminAdsSettingsController::class, 'update'])->name('refactor.admin.ads.settings.update');
    Route::post('ads/settings/test/{platform}', [\App\Http\Controllers\Refactor\Admin\AdminAdsSettingsController::class, 'testConnection'])->name('refactor.admin.ads.settings.test');
    Route::get('ads/settings/review-status/{platform}', [\App\Http\Controllers\Refactor\Admin\AdminAdsSettingsController::class, 'reviewStatus'])->name('refactor.admin.ads.settings.review_status');

    // Admin Ads Lead Inspection (R11.5)
    Route::get ('ads/leads/{id}',                      [\App\Http\Controllers\Refactor\Admin\AdminAdsLeadController::class, 'show'])->name('refactor.admin.ads.leads.show');

    // Admin Ads Emergency Controls (R11.1)
    Route::get ('ads/emergency',                       [\App\Http\Controllers\Refactor\Admin\AdsEmergencyController::class, 'index'])->name('refactor.admin.ads.emergency.index');
    Route::post('ads/emergency/pause-platform',        [\App\Http\Controllers\Refactor\Admin\AdsEmergencyController::class, 'pausePlatform'])->name('refactor.admin.ads.emergency.pause_platform');
    Route::post('ads/emergency/resume-platform',       [\App\Http\Controllers\Refactor\Admin\AdsEmergencyController::class, 'resumePlatform'])->name('refactor.admin.ads.emergency.resume_platform');
    Route::post('ads/emergency/freeze-customer',       [\App\Http\Controllers\Refactor\Admin\AdsEmergencyController::class, 'freezeCustomer'])->name('refactor.admin.ads.emergency.freeze_customer');
    Route::post('ads/emergency/unfreeze-customer',     [\App\Http\Controllers\Refactor\Admin\AdsEmergencyController::class, 'unfreezeCustomer'])->name('refactor.admin.ads.emergency.unfreeze_customer');
    Route::post('ads/emergency/bulk-pause',            [\App\Http\Controllers\Refactor\Admin\AdsEmergencyController::class, 'pauseAllCustomerCampaigns'])->name('refactor.admin.ads.emergency.bulk_pause');
    Route::post('ads/emergency/set-quota',             [\App\Http\Controllers\Refactor\Admin\AdsEmergencyController::class, 'setQuotaOverride'])->name('refactor.admin.ads.emergency.set_quota');
    Route::post('ads/emergency/clear-quota',           [\App\Http\Controllers\Refactor\Admin\AdsEmergencyController::class, 'clearQuotaOverride'])->name('refactor.admin.ads.emergency.clear_quota');
});

/*
|--------------------------------------------------------------------------
| Admin Routes (migrated off /rui/admin/ prefix)
|--------------------------------------------------------------------------
|
| Admin-area routes that opted out of /rui/admin/ prefix. Same controllers
| and same middleware as the rui/admin group above; only the URL prefix
| differs. Module migrations land here one at a time — dashboard (in web.php),
| customers, ... .
|
*/
Route::group([
    'prefix' => 'admin',
    'middleware' => ['not_installed', 'auth', 'backend', '2fa', 'demo_guard'],
], function () {
    // Customers
    Route::get('customers', [AdminCustomerController::class, 'index'])->name('refactor.admin.customers.index');
    Route::get('customers/listing', [AdminCustomerController::class, 'listing'])->name('refactor.admin.customers.listing');
    Route::get('customers/create', [AdminCustomerController::class, 'create'])->name('refactor.admin.customers.create');
    Route::post('customers/store', [AdminCustomerController::class, 'store'])->name('refactor.admin.customers.store');
    Route::post('customers/{uid}/refresh-cache', [AdminCustomerController::class, 'refreshCache'])->name('refactor.admin.customers.refresh-cache');
    // Customer admin 360° dashboard (read-only overview) — placed BEFORE edit so it becomes the
    // primary detail entry point. See docs/automated/features/admin-customer-dashboard.md
    Route::get('customers/{uid}/dashboard', [AdminCustomerDashboardController::class, 'index'])->name('refactor.admin.customers.dashboard');
    Route::get('customers/{uid}/dashboard/sending', [AdminCustomerDashboardController::class, 'sendingTrendChart'])->name('refactor.admin.customers.dashboard.sending');
    Route::get('customers/{uid}/dashboard/growth', [AdminCustomerDashboardController::class, 'growthChart'])->name('refactor.admin.customers.dashboard.growth');

    Route::get('customers/{uid}/edit', [AdminCustomerController::class, 'edit'])->name('refactor.admin.customers.edit');
    Route::put('customers/{uid}/update', [AdminCustomerController::class, 'update'])->name('refactor.admin.customers.update');
    Route::post('customers/enable', [AdminCustomerController::class, 'enable'])->name('refactor.admin.customers.enable');
    Route::post('customers/disable', [AdminCustomerController::class, 'disable'])->name('refactor.admin.customers.disable');
    Route::post('customers/delete', [AdminCustomerController::class, 'delete'])->name('refactor.admin.customers.delete');
    Route::get('customers/{uid}/login-as', [AdminCustomerController::class, 'loginAs'])->name('refactor.admin.customers.login-as');
    Route::get('customers/login-back', [AdminCustomerController::class, 'loginBack'])->name('refactor.admin.customers.login-back');
    Route::get('customers/{uid}/subscriptions', [AdminCustomerController::class, 'subscriptions'])->name('refactor.admin.customers.subscriptions');
    Route::get('customers/growth-chart', [AdminCustomerController::class, 'growthChart'])->name('refactor.admin.customers.growth-chart');
    Route::get('customers/select2', [AdminCustomerController::class, 'select2'])->name('refactor.admin.customers.select2');
    Route::match(['get', 'post'], 'customers/{uid}/assign-plan', [AdminCustomerController::class, 'assignPlan'])->name('refactor.admin.customers.assign-plan');

    // Customer contact
    Route::get('customers/{uid}/contact', [AdminCustomerController::class, 'contact'])->name('refactor.admin.customers.contact');
    Route::post('customers/{uid}/contact', [AdminCustomerController::class, 'contactUpdate'])->name('refactor.admin.customers.contact.update');

    // Customer one-click login
    Route::get('customers/{uid}/one-click-login', [AdminCustomerController::class, 'oneClickLogin'])->name('refactor.admin.customers.one_click_login');

    // Customer users
    Route::get('customers/{uid}/users', [AdminCustomerController::class, 'users'])->name('refactor.admin.customers.users');
    Route::get('customers/{uid}/users/listing', [AdminCustomerController::class, 'usersListing'])->name('refactor.admin.customers.users.listing');
    Route::get('customers/{uid}/users/create', [AdminCustomerController::class, 'userCreate'])->name('refactor.admin.customers.users.create');
    Route::post('customers/{uid}/users/store', [AdminCustomerController::class, 'userStore'])->name('refactor.admin.customers.users.store');
    Route::get('customers/{uid}/users/{user_uid}/edit', [AdminCustomerController::class, 'userEdit'])->name('refactor.admin.customers.users.edit');
    Route::put('customers/{uid}/users/{user_uid}/update', [AdminCustomerController::class, 'userUpdate'])->name('refactor.admin.customers.users.update');
    Route::post('customers/{uid}/users/enable', [AdminCustomerController::class, 'usersEnable'])->name('refactor.admin.customers.users.enable');
    Route::post('customers/{uid}/users/disable', [AdminCustomerController::class, 'usersDisable'])->name('refactor.admin.customers.users.disable');
    Route::post('customers/{uid}/users/delete', [AdminCustomerController::class, 'usersDelete'])->name('refactor.admin.customers.users.delete');
    Route::get('customers/{uid}/users/{user_uid}/login-as', [AdminCustomerController::class, 'userLoginAs'])->name('refactor.admin.customers.users.login_as');

    // Subscriptions
    Route::get('subscriptions', [AdminSubscriptionController::class, 'index'])->name('refactor.admin.subscriptions.index');
    Route::get('subscriptions/listing', [AdminSubscriptionController::class, 'listing'])->name('refactor.admin.subscriptions.listing');
    Route::post('subscriptions/{id}/approve', [AdminSubscriptionController::class, 'approve'])->name('refactor.admin.subscriptions.approve');
    Route::post('subscriptions/{id}/terminate', [AdminSubscriptionController::class, 'terminate'])->name('refactor.admin.subscriptions.terminate');
    Route::post('subscriptions/{id}/disable-recurring', [AdminSubscriptionController::class, 'disableRecurring'])->name('refactor.admin.subscriptions.disable-recurring');
    Route::post('subscriptions/{id}/enable-recurring', [AdminSubscriptionController::class, 'enableRecurring'])->name('refactor.admin.subscriptions.enable-recurring');
    Route::post('subscriptions/delete', [AdminSubscriptionController::class, 'delete'])->name('refactor.admin.subscriptions.delete');
    // Generic admin credit-remaining override (replaces the per-type replenish routes).
    // POST with JSON body { remaining: int, note?: string } — remaining=-1 for Unlimited.
    Route::post('subscriptions/{id}/credits/{creditKey}', [AdminSubscriptionController::class, 'setCredit'])->name('refactor.admin.subscriptions.set-credit');
    Route::post('subscriptions/{id}/refresh-credits', [AdminSubscriptionController::class, 'refreshCredits'])->name('refactor.admin.subscriptions.refresh-credits');
    Route::get ('subscriptions/create', [AdminSubscriptionController::class, 'create'])->name('refactor.admin.subscriptions.create');
    Route::post('subscriptions/create', [AdminSubscriptionController::class, 'store'])->name('refactor.admin.subscriptions.store');
    Route::get('subscriptions/{id}/show', [AdminSubscriptionController::class, 'show'])->name('refactor.admin.subscriptions.show');
    Route::get('subscriptions/{id}/credits-debug', [AdminSubscriptionController::class, 'creditsDebug'])->name('refactor.admin.subscriptions.credits-debug');
    Route::post('subscriptions/{id}/credits-debug/sync/{creditKey}', [AdminSubscriptionController::class, 'syncCreditFromPlan'])->name('refactor.admin.subscriptions.credits-debug.sync');
    Route::get ('subscriptions/{id}/reject-pending', [AdminSubscriptionController::class, 'rejectPendingForm'])->name('refactor.admin.subscriptions.reject-pending');
    Route::post('subscriptions/{id}/reject-pending', [AdminSubscriptionController::class, 'rejectPending'])->name('refactor.admin.subscriptions.reject-pending.submit');
    Route::get('subscriptions/{id}/invoices', [AdminSubscriptionController::class, 'invoices'])->name('refactor.admin.subscriptions.invoices');
    Route::post('subscriptions/{id}/sync-remote', [AdminSubscriptionController::class, 'syncRemote'])->name('refactor.admin.subscriptions.sync-remote');
    Route::get('subscriptions/{id}/remote-info', [AdminSubscriptionController::class, 'remoteInfo'])->name('refactor.admin.subscriptions.remote-info');

    // Invoices
    Route::get('invoices', [AdminInvoiceController::class, 'index'])->name('refactor.admin.invoices.index');
    Route::get('invoices/listing', [AdminInvoiceController::class, 'listing'])->name('refactor.admin.invoices.listing');
    Route::post('invoices/{uid}/approve', [AdminInvoiceController::class, 'approve'])->name('refactor.admin.invoices.approve');
    Route::get ('invoices/{uid}/reject', [AdminInvoiceController::class, 'rejectForm'])->name('refactor.admin.invoices.reject');
    Route::post('invoices/{uid}/reject', [AdminInvoiceController::class, 'reject'])->name('refactor.admin.invoices.reject.submit');
    Route::get('invoices/{uid}/logs', [AdminInvoiceController::class, 'logs'])->name('refactor.admin.invoices.logs');
    Route::post('invoices/{uid}/delete', [AdminInvoiceController::class, 'delete'])->name('refactor.admin.invoices.delete');
    Route::get('invoices/{uid}/download', [AdminInvoiceController::class, 'download'])->name('refactor.admin.invoices.download');
    Route::get('invoices/custom/create', [AdminInvoiceController::class, 'customCreate'])->name('refactor.admin.invoices.custom_create');
    Route::match(['get', 'post'], 'invoices/template/edit', [AdminInvoiceController::class, 'templateEdit'])->name('refactor.admin.invoices.template_edit');

    // Plans
    Route::get('plans', [AdminPlanController::class, 'index'])->name('refactor.admin.plans.index');
    Route::get('plans/listing', [AdminPlanController::class, 'listing'])->name('refactor.admin.plans.listing');
    Route::get('plans/create', [AdminPlanController::class, 'create'])->name('refactor.admin.plans.create');
    Route::post('plans/store', [AdminPlanController::class, 'store'])->name('refactor.admin.plans.store');
    Route::get('plans/pie-chart', [AdminPlanController::class, 'pieChart'])->name('refactor.admin.plans.pie-chart');
    Route::get('plans/{uid}/general', [AdminPlanController::class, 'general'])->name('refactor.admin.plans.general');
    Route::get('plans/{uid}/sending-servers', [AdminPlanController::class, 'sendingServers'])->name('refactor.admin.plans.sending_servers');
    Route::match(['get', 'post'], 'plans/{uid}/sending-servers/add', [AdminPlanController::class, 'addSendingServer'])->name('refactor.admin.plans.sending_servers.add');
    Route::post('plans/{uid}/sending-servers/remove', [AdminPlanController::class, 'removeSendingServer'])->name('refactor.admin.plans.sending_servers.remove');
    Route::post('plans/{uid}/sending-servers/set-primary', [AdminPlanController::class, 'setPrimarySendingServer'])->name('refactor.admin.plans.sending_servers.set-primary');
    Route::match(['get', 'post'], 'plans/{uid}/sending-servers/fitness', [AdminPlanController::class, 'fitness'])->name('refactor.admin.plans.sending_servers.fitness');
    Route::post('plans/{uid}/sending-servers/set-mode', [AdminPlanController::class, 'setSendingServerMode'])->name('refactor.admin.plans.sending_servers.set-mode');
    Route::get ('plans/{uid}/credits',       [AdminPlanController::class, 'planCredits'])->name('refactor.admin.plans.plan_credits');
    Route::post('plans/{uid}/credits',       [AdminPlanController::class, 'savePlanCredits'])->name('refactor.admin.plans.plan_credits.save');
    Route::get ('plans/{uid}/quotas',        [AdminPlanController::class, 'planQuotas'])->name('refactor.admin.plans.plan_quotas');
    Route::post('plans/{uid}/quotas',        [AdminPlanController::class, 'savePlanQuotas'])->name('refactor.admin.plans.plan_quotas.save');
    Route::get ('plans/{uid}/entitlements',  [AdminPlanController::class, 'planEntitlements'])->name('refactor.admin.plans.plan_entitlements');
    Route::post('plans/{uid}/entitlements',  [AdminPlanController::class, 'savePlanEntitlements'])->name('refactor.admin.plans.plan_entitlements.save');
    Route::get ('plans/{uid}/rate-limits',   [AdminPlanController::class, 'planRateLimits'])->name('refactor.admin.plans.plan_rate_limits');
    Route::post('plans/{uid}/rate-limits',   [AdminPlanController::class, 'savePlanRateLimits'])->name('refactor.admin.plans.plan_rate_limits.save');
    Route::get('plans/{uid}/tos', [AdminPlanController::class, 'tos'])->name('refactor.admin.plans.tos');
    Route::post('plans/{uid}/save', [AdminPlanController::class, 'save'])->name('refactor.admin.plans.save');
    Route::post('plans/{uid}/save-tos', [AdminPlanController::class, 'saveTos'])->name('refactor.admin.plans.save-tos');
    Route::post('plans/enable', [AdminPlanController::class, 'enable'])->name('refactor.admin.plans.enable');
    Route::post('plans/disable', [AdminPlanController::class, 'disable'])->name('refactor.admin.plans.disable');
    Route::post('plans/delete', [AdminPlanController::class, 'delete'])->name('refactor.admin.plans.delete');
    Route::post('plans/{uid}/visible/on', [AdminPlanController::class, 'visibleOn'])->name('refactor.admin.plans.visible-on');
    Route::post('plans/{uid}/visible/off', [AdminPlanController::class, 'visibleOff'])->name('refactor.admin.plans.visible-off');
    Route::post('plans/{uid}/copy', [AdminPlanController::class, 'copy'])->name('refactor.admin.plans.copy');
    Route::get('plans/{uid}/payment', [AdminPlanController::class, 'payment'])->name('refactor.admin.plans.payment');

    // Roles
    Route::get('roles', [AdminRoleController::class, 'index'])->name('refactor.admin.roles.index');
    Route::get('roles/listing', [AdminRoleController::class, 'listing'])->name('refactor.admin.roles.listing');
    Route::get('roles/create', [AdminRoleController::class, 'create'])->name('refactor.admin.roles.create');
    Route::post('roles/store', [AdminRoleController::class, 'store'])->name('refactor.admin.roles.store');
    Route::get('roles/{uid}/edit', [AdminRoleController::class, 'edit'])->name('refactor.admin.roles.edit');
    Route::post('roles/{uid}/update', [AdminRoleController::class, 'update'])->name('refactor.admin.roles.update');
    Route::post('roles/delete', [AdminRoleController::class, 'delete'])->name('refactor.admin.roles.delete');
    Route::post('roles/enable', [AdminRoleController::class, 'enable'])->name('refactor.admin.roles.enable');
    Route::post('roles/disable', [AdminRoleController::class, 'disable'])->name('refactor.admin.roles.disable');
});