# One command does everything
php artisan shopmetrics:daily-maintenance

# Or let the scheduler run it automatically at 2 AM
php artisan schedule:run

# App info
php artisan about
php artisan env

# Database operations
php artisan migrate --seed
php artisan db:show --counts

# Cache management
php artisan cache:clear
php artisan config:cache
php artisan route:cache
php artisan view:cache
php artisan optimize           # Cache config + route + view

# Maintenance mode
php artisan down --secret="maintenance-token"  # Allow access with ?secret=
php artisan up

# Queue management
php artisan queue:work --queue=high,default
php artisan queue:failed
php artisan queue:retry all

# Route inspection
php artisan route:list --path=api
php artisan route:list --columns=method,uri,name

# Command executed successfully

php artisan make:command ProcessTenantAnalytics
# Creates: app/Console/Commands/ProcessTenantAnalytics.php

// app/Console/Commands/ProcessTenantAnalytics.php
class ProcessTenantAnalytics extends Command
{
    // Signature syntax: {argument} {--option}
    protected $signature = 'shopmetrics:analytics
                            {tenant? : Tenant ID or slug (optional)}
                            {--type=monthly : Report type (daily|weekly|monthly)}
                            {--force : Force re-calculation}
                            {--format=csv : Output format (csv|json)}';

    protected $description = 'Process analytics for tenants';

    public function handle(): int
    {
        $tenant = $this->argument('tenant');
        $type = $this->option('type');
        $force = $this->option('force');

        if ($tenant) {
            $this->processSingleTenant($tenant, $type, $force);
        } else {
            $this->processAllTenants($type, $force);
        }

        return self::SUCCESS;
    }
}

// app/Console/Commands/ManageTenant.php
class ManageTenant extends Command
{
    protected $signature = 'shopmetrics:tenant
                            {action : Action to perform (list|suspend|activate|stats)}
                            {tenant? : Tenant ID or slug}
                            {--with-users : Include user statistics}';

    protected $description = 'Manage ShopMetrics tenants';

    public function handle(): int
    {
        $action = $this->argument('action');

        match ($action) {
            'list' => $this->listTenants(),
            'suspend' => $this->suspendTenant(),
            'activate' => $this->activateTenant(),
            'stats' => $this->showTenantStats(),
            default => $this->error("Unknown action: {$action}"),
        };

        return self::SUCCESS;
    }

    private function listTenants(): void
    {
        $tenants = Tenant::withCount(['shops', 'users'])->get();
        $this->table(
            ['ID', 'Name', 'Slug', 'Status', 'Shops', 'Users'],
            $tenants->map(fn ($t) => [
                $t->id, $t->name, $t->slug, $t->status,
                $t->shops_count, $t->users_count,
            ])
        );
    }

    private function suspendTenant(): void
    {
        $identifier = $this->argument('tenant') ?? $this->ask('Enter tenant ID or slug:');
        $tenant = $this->resolveTenant($identifier);
        $tenant->update(['status' => 'suspended']);
        $this->info("Tenant {$tenant->name} has been suspended.");
    }

    private function resolveTenant(string $identifier): Tenant
    {
        return is_numeric($identifier)
            ? Tenant::findOrFail($identifier)
            : Tenant::whereSlug($identifier)->firstOrFail();
    }
}

// Execution Successful

// Arguments
$name = $this->argument('name');        // Single argument
$all = $this->arguments();              // All arguments as array

// Options
$force = $this->option('force');        // Single option (boolean or value)
$all = $this->options();                // All options as array

// Signature with array argument
protected $signature = 'shopmetrics:report
                        {tenants* : One or more tenant IDs}
                        {--type=monthly}';

// Usage
php artisan shopmetrics:report 1 2 3 --type=weekly

// Access
$tenants = $this->argument('tenants'); // [1, 2, 3]

// app/Console/Commands/CleanupExpiredData.php
class CleanupExpiredData extends Command
{
    protected $signature = 'shopmetrics:cleanup
                            {--days=90 : Delete data older than N days}
                            {--dry-run : Show what would be deleted}';

    protected $description = 'Clean up expired data (old reports, expired tokens)';

    public function handle(): int
    {
        $days = $this->option('days');
        $dryRun = $this->option('dry-run');
        $cutoff = now()->subDays($days);

        // Clean expired tokens
        $expiredTokens = Sanctum::$personalAccessTokenModel::where('last_used_at', '<', $cutoff);
        $this->info(($dryRun ? 'Would delete' : 'Deleting') . " {$expiredTokens->count()} expired tokens.");

        // Clean old reports from S3
        $bar = $this->output->createProgressBar(Tenant::count());
        $deletedFiles = 0;

        Tenant::chunk(100, function ($tenants) use ($cutoff, $dryRun, &$deletedFiles, $bar) {
            foreach ($tenants as $tenant) {
                $files = Storage::disk('s3')->allFiles("reports/{$tenant->slug}");
                foreach ($files as $file) {
                    if (Storage::disk('s3')->lastModified($file) < $cutoff->timestamp) {
                        if (!$dryRun) Storage::disk('s3')->delete($file);
                        $deletedFiles++;
                    }
                }
                $bar->advance();
            }
        });

        $bar->finish();
        $this->newLine();
        $this->info(($dryRun ? 'Would delete' : 'Deleted') . " {$deletedFiles} old report files.");

        if (!$dryRun) {
            $expiredTokens->delete();
        }

        return self::SUCCESS;
    }
}

// Execution Successful

// routes/console.php
use Illuminate\Support\Facades\Schedule;

Schedule::command('shopmetrics:analytics --type=daily')
    ->dailyAt('02:00')
    ->onOneServer()
    ->withoutOverlapping()
    ->emailOutputOnFailure('admin@shopmetrics.io');

Schedule::command('shopmetrics:cleanup --days=90')
    ->weekly()
    ->sundays()
    ->at('03:00')
    ->onOneServer();

Schedule::command('shopmetrics:sync-subscriptions')
    ->dailyAt('06:00')
    ->onOneServer()
    ->withoutOverlapping();

Schedule::job(new ProcessMonthlyAnalyticsJob)
    ->monthlyOn(1, '00:00')
    ->onOneServer();

// routes/console.php
Schedule::command('shopmetrics:analytics --type=daily')
    ->dailyAt('02:00')
    ->onOneServer()
    ->withoutOverlapping(60)
    ->emailOutputOnFailure('ops@shopmetrics.io');

Schedule::command('shopmetrics:cleanup --days=90')
    ->weeklyOn(Schedule::SUNDAY, '03:00')
    ->onOneServer();

Schedule::command('shopmetrics:send-expiring-notifications')
    ->dailyAt('08:00')
    ->when(fn () => Subscription::expiringSoon()->exists());

Schedule::command('queue:prune-failed --hours=168')
    ->daily();

Schedule::command('queue:prune-batches --hours=168')
    ->daily();

// Cron entry on server
// * * * * * cd /var/www/shopmetrics && php artisan schedule:run >> /dev/null 2>&1

// Execution Successful

// Ask for input
$name = $this->ask('What is the tenant name?');

// Ask with default
$email = $this->ask('Email address?', 'admin@example.com');

// Secret input (passwords)
$password = $this->secret('Enter password:');

// Confirm (yes/no)
if ($this->confirm('Do you wish to continue?', true)) {
    // Default: yes
}

// Choice (single select)
$type = $this->choice(
    'Select report type',
    ['daily', 'weekly', 'monthly'],
    0 // default index
);

// Anticipate (autocomplete)
$name = $this->anticipate('Tenant name', Tenant::pluck('name')->toArray());

// app/Console/Commands/SetupTenant.php
class SetupTenant extends Command
{
    protected $signature = 'shopmetrics:tenant-setup';

    protected $description = 'Interactive tenant setup wizard';

    public function handle(): int
    {
        $this->info('=== ShopMetrics Tenant Setup Wizard ===');

        $name = $this->ask('Tenant name');
        $slug = $this->anticipate('Slug', [Str::slug($name)]);
        $domain = $this->ask('Custom domain (optional)', $slug . '.shopmetrics.io');
        $plan = $this->choice('Select plan', ['Starter', 'Pro', 'Enterprise'], 1);
        $ownerEmail = $this->ask('Owner email');

        $this->table(
            ['Field', 'Value'],
            [['Name', $name], ['Slug', $slug], ['Domain', $domain], ['Plan', $plan], ['Owner', $ownerEmail]],
        );

        if (!$this->confirm('Create this tenant?', true)) {
            $this->warn('Cancelled.');
            return self::FAILURE;
        }

        $tenant = Tenant::create(compact('name', 'slug', 'domain'));
        User::factory()->create([
            'tenant_id' => $tenant->id,
            'email' => $ownerEmail,
            'role' => 'tenant_owner',
        ]);

        $this->info("Tenant {$name} created successfully!");
        return self::SUCCESS;
    }
}

// app/Console/Commands/ExportData.php
class ExportData extends Command
{
    protected $signature = 'shopmetrics:export';

    protected $description = 'Interactive data export tool';

    public function handle(): int
    {
        $type = $this->choice('What to export?', [
            'orders' => 'Orders',
            'products' => 'Products',
            'analytics' => 'Analytics Report',
        ]);

        $tenant = $this->anticipate('Tenant (leave blank for all)', Tenant::pluck('name')->push('All')->toArray());

        $format = $this->choice('Format?', ['csv', 'xlsx', 'json'], 0);

        $dateFrom = $this->ask('Date from (Y-m-d, optional)');
        $dateTo = $this->ask('Date to (Y-m-d, optional)');

        $this->info("Exporting {$type} for {$tenant} in {$format} format...");

        $query = match ($type) {
            'orders' => Order::query(),
            'products' => Product::query(),
            'analytics' => AnalyticsReport::query(),
        };

        if ($tenant !== 'All') {
            $tenantModel = Tenant::whereName($tenant)->firstOrFail();
            $query->where('tenant_id', $tenantModel->id);
        }

        if ($dateFrom) $query->where('created_at', '>=', $dateFrom);
        if ($dateTo) $query->where('created_at', '<=', $dateTo);

        $count = $query->count();
        $this->info("Found {$count} records.");

        if (!$this->confirm("Export {$count} records?", true)) {
            return self::FAILURE;
        }

        $path = ExportService::export($query, $format);
        $this->info("Export saved to: {$path}");

        return self::SUCCESS;
    }
}

// Execution Successful

// ============================================
// Comprehensive: ShopMetrics Operations Commands
// Covers: signature, options, progress, scheduling, interactive
// ============================================

// app/Console/Commands/DailyMaintenance.php
class DailyMaintenance extends Command
{
    protected $signature = 'shopmetrics:daily-maintenance
                            {--skip-analytics : Skip analytics processing}
                            {--skip-cleanup : Skip data cleanup}
                            {--notify : Send completion notification}';

    protected $description = 'Run daily maintenance tasks';

    public function handle(): int
    {
        $this->info('Starting daily maintenance...');

        if (!$this->option('skip-analytics')) {
            $this->processAnalytics();
        }

        if (!$this->option('skip-cleanup')) {
            $this->cleanupExpiredData();
        }

        $this->syncSubscriptions();

        if ($this->option('notify')) {
            $this->sendCompletionNotification();
        }

        $this->info('Daily maintenance completed.');
        return self::SUCCESS;
    }

    private function processAnalytics(): void
    {
        $this->info('Processing daily analytics...');
        $tenants = Tenant::active()->get();
        $bar = $this->output->createProgressBar($tenants->count());

        foreach ($tenants as $tenant) {
            GenerateReportJob::dispatch($tenant, 'daily', 'json');
            $bar->advance();
        }

        $bar->finish();
        $this->newLine();
    }

    private function cleanupExpiredData(): void
    {
        $this->call('shopmetrics:cleanup', ['--days' => 90]);
    }

    private function syncSubscriptions(): void
    {
        $this->call('shopmetrics:sync-subscriptions');
    }

    private function sendCompletionNotification(): void
    {
        $admin = User::where('role', 'super_admin')->first();
        $admin?->notify(new DailyMaintenanceCompleted());
    }
}

// Schedule it
// routes/console.php
Schedule::command('shopmetrics:daily-maintenance --notify')
    ->dailyAt('02:00')
    ->onOneServer()
    ->withoutOverlapping()
    ->emailOutputOnFailure('ops@shopmetrics.io');