# Um comando faz tudo
php artisan shopmetrics:daily-maintenance

# Ou deixe o agendador executar automaticamente às 2 da manhã
php artisan schedule:run

# Informações da app
php artisan about
php artisan env

# Operações de banco de dados
php artisan migrate --seed
php artisan db:show --counts

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

# Modo de manutenção
php artisan down --secret="maintenance-token"  # Permitir acesso com ?secret=
php artisan up

# Gerenciamento de fila
php artisan queue:work --queue=high,default
php artisan queue:failed
php artisan queue:retry all

# Inspeção de rotas
php artisan route:list --path=api
php artisan route:list --columns=method,uri,name

# Comando executado com sucesso

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

// app/Console/Commands/ProcessTenantAnalytics.php
class ProcessTenantAnalytics extends Command
{
    // Sintaxe Signature: {argument} {--option}
    protected $signature = 'shopmetrics:analytics
                            {tenant? : ID ou slug do Tenant (opcional)}
                            {--type=monthly : Tipo de relatório (daily|weekly|monthly)}
                            {--force : Forçar recálculo}
                            {--format=csv : Formato de saída (csv|json)}';

    protected $description = 'Processar analytics para 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 : Ação a executar (list|suspend|activate|stats)}
                            {tenant? : ID ou slug do Tenant}
                            {--with-users : Incluir estatísticas de usuários}';

    protected $description = 'Gerenciar tenants do ShopMetrics';

    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("Ação desconhecida: {$action}"),
        };

        return self::SUCCESS;
    }

    private function listTenants(): void
    {
        $tenants = Tenant::withCount(['shops', 'users'])->get();
        $this->table(
            ['ID', 'Nome', 'Slug', 'Status', 'Lojas', 'Usuários'],
            $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('Digite o ID ou slug do tenant:');
        $tenant = $this->resolveTenant($identifier);
        $tenant->update(['status' => 'suspended']);
        $this->info("Tenant {$tenant->name} foi suspenso.");
    }

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

// Execução bem-sucedida

// Argumentos
$name = $this->argument('name');        // Argumento único
$all = $this->arguments();              // Todos os argumentos como array

// Opções
$force = $this->option('force');        // Opção única (booleano ou valor)
$all = $this->options();                // Todas as opções como array

// Signature com argumento de array
protected $signature = 'shopmetrics:report
                        {tenants* : Um ou mais IDs de tenant}
                        {--type=monthly}';

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

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

// app/Console/Commands/CleanupExpiredData.php
class CleanupExpiredData extends Command
{
    protected $signature = 'shopmetrics:cleanup
                            {--days=90 : Excluir dados mais antigos que N dias}
                            {--dry-run : Mostrar o que seria excluído}';

    protected $description = 'Limpar dados expirados (relatórios antigos, tokens expirados)';

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

        // Limpar tokens expirados
        $expiredTokens = Sanctum::$personalAccessTokenModel::where('last_used_at', '<', $cutoff);
        $this->info(($dryRun ? 'Excluiria' : 'Excluindo') . " {$expiredTokens->count()} tokens expirados.");

        // Limpar relatórios antigos do 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 ? 'Excluiria' : 'Excluídos') . " {$deletedFiles} arquivos de relatório antigos.");

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

        return self::SUCCESS;
    }
}

// Execução bem-sucedida

// 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();

// Entrada Cron no servidor
// * * * * * cd /var/www/shopmetrics && php artisan schedule:run >> /dev/null 2>&1

// Execução bem-sucedida

// Pedir entrada
$name = $this->ask('Qual é o nome do tenant?');

// Pedir com padrão
$email = $this->ask('Endereço de email?', 'admin@example.com');

// Entrada secreta (senhas)
$password = $this->secret('Digite a senha:');

// Confirmar (sim/não)
if ($this->confirm('Deseja continuar?', true)) {
    // Padrão: sim
}

// Escolha (seleção única)
$type = $this->choice(
    'Selecione o tipo de relatório',
    ['daily', 'weekly', 'monthly'],
    0 // índice padrão
);

// Antecipar (autocompletar)
$name = $this->anticipate('Nome do tenant', Tenant::pluck('name')->toArray());

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

    protected $description = 'Assistente interativo de configuração de tenant';

    public function handle(): int
    {
        $this->info('=== Assistente de Configuração de Tenant ShopMetrics ===');

        $name = $this->ask('Nome do tenant');
        $slug = $this->anticipate('Slug', [Str::slug($name)]);
        $domain = $this->ask('Domínio personalizado (opcional)', $slug . '.shopmetrics.io');
        $plan = $this->choice('Selecione o plano', ['Starter', 'Pro', 'Enterprise'], 1);
        $ownerEmail = $this->ask('Email do proprietário');

        $this->table(
            ['Campo', 'Valor'],
            [['Nome', $name], ['Slug', $slug], ['Domínio', $domain], ['Plano', $plan], ['Proprietário', $ownerEmail]],
        );

        if (!$this->confirm('Criar este tenant?', true)) {
            $this->warn('Cancelado.');
            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} criado com sucesso!");
        return self::SUCCESS;
    }
}

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

    protected $description = 'Ferramenta interativa de exportação de dados';

    public function handle(): int
    {
        $type = $this->choice('O que exportar?', [
            'orders' => 'Pedidos',
            'products' => 'Produtos',
            'analytics' => 'Relatório de Analytics',
        ]);

        $tenant = $this->anticipate('Tenant (deixe em branco para todos)', Tenant::pluck('name')->push('Todos')->toArray());

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

        $dateFrom = $this->ask('Data de (Y-m-d, opcional)');
        $dateTo = $this->ask('Data até (Y-m-d, opcional)');

        $this->info("Exportando {$type} para {$tenant} no formato {$format}...");

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

        if ($tenant !== 'Todos') {
            $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("Encontrados {$count} registros.");

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

        $path = ExportService::export($query, $format);
        $this->info("Exportação salva em: {$path}");

        return self::SUCCESS;
    }
}

// Execução bem-sucedida

// ============================================
// Compreensivo: Comandos de Operações do ShopMetrics
// Abrange: signature, options, progress, scheduling, interactive
// ============================================

// app/Console/Commands/DailyMaintenance.php
class DailyMaintenance extends Command
{
    protected $signature = 'shopmetrics:daily-maintenance
                            {--skip-analytics : Pular processamento de analytics}
                            {--skip-cleanup : Pular limpeza de dados}
                            {--notify : Enviar notificação de conclusão}';

    protected $description = 'Executar tarefas de manutenção diária';

    public function handle(): int
    {
        $this->info('Iniciando manutenção diária...');

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

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

        $this->syncSubscriptions();

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

        $this->info('Manutenção diária concluída.');
        return self::SUCCESS;
    }

    private function processAnalytics(): void
    {
        $this->info('Processando analytics diários...');
        $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());
    }
}

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