// Conhecer o ciclo de vida ajuda a depurar assim:
// 1. Verificar se a vinculação existe
app()->bound('payment.gateway');
// 2. Verificar qual provider a registrou
app()->getBindings()['payment.gateway']['concrete'];
// 3. Rastrear a ordem de execução do middleware
app()->make(\Illuminate\Foundation\Http\Kernel::class)->getMiddlewarePriority();

# Verificar provedores de serviço registrados
php artisan about --only=providers
# Listados: AppServiceProvider, AuthServiceProvider, etc.

# Verificar pipeline de middleware
php artisan route:list --columns=method,uri,middleware
# GET /dashboard → auth, tenant.resolve, verified

# Verificar serviços vinculados no container
php artisan tinker
# app()->getBindings()
# Lista todas as vinculações de container registradas

# Comando executado com sucesso

// bootstrap/app.php — Configuração em arquivo único do Laravel 11
return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        api: __DIR__.'/../routes/api.php',
        commands: __DIR__.'/../routes/console.php',
        health: '/up',
    )
    ->withMiddleware(function (Middleware $middleware) {
        $middleware->appendToGuestList([
            '/api/*',
        ]);
        $middleware->alias([
            'tenant.resolve' => \App\Http\Middleware\TenantResolve::class,
        ]);
    })
    ->withExceptions(function (Exceptions $exceptions) {
        //
    })->create();

// bootstrap/app.php
->withMiddleware(function (Middleware $middleware) {
    // Adicionar middleware global (executa em toda requisição)
    $middleware->append([
        \App\Http\Middleware\SetLocale::class,
    ]);

    // Remover um middleware global padrão
    $middleware->remove([
        \Illuminate\Foundation\Http\Middleware\TrimStrings::class,
    ]);

    // Registrar alias para middleware de rota
    $middleware->alias([
        'tenant' => \App\Http\Middleware\TenantResolve::class,
        'role' => \App\Http\Middleware\CheckRole::class,
    ]);
})

// Execução bem-sucedida

// app/Providers/AppServiceProvider.php
public function register(): void
{
    // Vincular interface à implementação
    $this->app->bind(
        PaymentGatewayInterface::class,
        StripeGateway::class,
    );

    // Vincular com closure (controle total)
    $this->app->bind('analytics.service', function ($app) {
        return new AnalyticsService(
            $app->make(CacheManager::class),
            $app['config']->get('analytics.ttl'),
        );
    });

    // Singleton — mesma instância toda vez
    $this->app->singleton(ShopMetricsConfig::class, function ($app) {
        return new ShopMetricsConfig(
            $app['config']->get('shopmetrics'),
        );
    });
}

// Resolução automática via dica de tipo
class OrderController extends Controller
{
    public function __construct(
        private PaymentGatewayInterface $gateway, // resolvido automaticamente
    ) {}
}

// Resolução manual
$gateway = app(PaymentGatewayInterface::class);
$gateway = app()->make(PaymentGatewayInterface::class);
$analytics = resolve('analytics.service');

// app/Providers/AppServiceProvider.php
public function register(): void
{
    $this->app->bind(
        \App\Contracts\ReportGeneratorInterface::class,
        \App\Services\PdfReportGenerator::class,
    );

    $this->app->singleton(
        \App\Services\TenantManager::class,
        fn ($app) => new TenantManager(
            $app->make(\App\Models\Tenant::class),
        ),
    );

    $this->app->when(ShopController::class)
        ->needs(\App\Contracts\FileStorageInterface::class)
        ->give(\App\Services\S3StorageService::class);
}

// Execução bem-sucedida

// Usando Facade — conciso
use Illuminate\Support\Facades\Cache;

public function getShopStats(int $shopId): array
{
    return Cache::remember("shop.stats.{$shopId}", 3600, function () use ($shopId) {
        return Shop::findOrFail($shopId)->getStats();
    });
}

// Usando DI — explícito, mais fácil de testar
public function __construct(
    private CacheManager $cache,
) {}

public function getShopStats(int $shopId): array
{
    return $this->cache->remember("shop.stats.{$shopId}", 3600, function () use ($shopId) {
        return Shop::findOrFail($shopId)->getStats();
    });
}

// Execução bem-sucedida

Requisição chega
  → Fase Register: register() de todos os providers chamado (sem booting ainda)
  → Fase Boot: boot() de todos os providers chamado (todas as vinculações disponíveis)
  → Aplicação pronta

// app/Providers/PaymentServiceProvider.php
class PaymentServiceProvider extends ServiceProvider
{
    protected bool $defer = true;

    public function register(): void
    {
        $this->app->singleton(StripeGateway::class, function ($app) {
            return new StripeGateway(config('services.stripe'));
        });
    }

    public function provides(): array
    {
        return [StripeGateway::class];
    }
}

// app/Providers/ShopMetricsServiceProvider.php
class ShopMetricsServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        $this->app->bind(
            ReportGeneratorInterface::class,
            PdfReportGenerator::class,
        );

        $this->app->singleton(TenantManager::class);
    }

    public function boot(): void
    {
        // Registrar alias de middleware
        $this->app->make(\Illuminate\Routing\Router::class)
            ->aliasMiddleware('tenant', TenantResolve::class);

        // Registrar view composer
        View::composer('dashboard.*', NavigationComposer::class);

        // Registrar listeners de eventos
        Event::listen(OrderPlaced::class, SendOrderNotification::class);
    }
}

// Execução bem-sucedida

// ============================================
// Completo: Rastrear uma requisição do ShopMetrics
// Abrange: ciclo de vida, container, facade, provider
// ============================================

// 1. public/index.php — Ponto de entrada
// $app = require_once __DIR__.'/../bootstrap/app.php';
// $app->handleRequest();

// 2. bootstrap/app.php — Configuração do Kernel
// return Application::configure(basePath: dirname(__DIR__))
//     ->withRouting(web: ..., api: ...)
//     ->withMiddleware(fn ($m) => $m->append([SetLocale::class]))
//     ->create();

// 3. AppServiceProvider — Registrar vinculações
// public function register(): void
// {
//     $this->app->singleton(TenantManager::class);
//     $this->app->bind(PaymentGatewayInterface::class, StripeGateway::class);
// }

// 4. Rota: GET /{tenant}/dashboard
// Route::middleware(['auth', 'tenant'])->get('/{tenant}/dashboard', [DashboardController::class, 'index']);

// 5. Controlador — Usar DI e Facades
class DashboardController extends Controller
{
    public function __construct(
        private TenantManager $tenantManager, // Resolvido via DI
    ) {}

    public function index(Request $request): View
    {
        $tenant = $this->tenantManager->current();
        $stats = Cache::remember("dashboard.{$tenant->id}", 300, function () use ($tenant) {
            return [
                'revenue' => $tenant->shops()->sum('revenue'),
                'orders' => $tenant->orders()->count(),
                'shops' => $tenant->shops()->active()->count(),
            ];
        });

        return view('dashboard.index', compact('tenant', 'stats'));
    }
}

// 6. Resposta enviada → Middleware Terminable executa → Requisição concluída