// Example: Location-based booking schema
CREATE TABLE bookings (
    id BIGINT PRIMARY KEY,
    location_id INT NOT NULL,
    service_id INT NOT NULL,
    staff_id INT NOT NULL,
    customer_id INT NOT NULL,
    booking_date DATETIME NOT NULL,
    duration INT NOT NULL,
    status ENUM('pending', 'confirmed', 'completed', 'cancelled'),
    INDEX idx_location_date (location_id, booking_date),
    INDEX idx_staff_date (staff_id, booking_date)
);

CREATE TABLE locations (
    id INT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    address TEXT,
    timezone VARCHAR(50),
    working_hours JSON,
    contact_info JSON
);

// WordPress timezone conversion example
$location_timezone = get_post_meta($location_id, 'timezone', true);
$booking_time_utc = new DateTime($booking_time, new DateTimeZone('UTC'));
$booking_time_local = $booking_time_utc->setTimezone(new DateTimeZone($location_timezone));

// bootstrap/app.php - The new unified configuration approach
return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        commands: __DIR__.'/../routes/console.php',
        health: '/up',
    )
    ->withMiddleware(function (Middleware $middleware) {
        // All middleware configuration in one place
        $middleware->validateCsrfTokens(except: [
            'stripe/*',
            'webhooks/*'
        ]);
        
        $middleware->web(append: [
            \App\Http\Middleware\TrackUserActivity::class,
        ]);
        
        $middleware->api(prepend: [
            \App\Http\Middleware\ForceJsonResponse::class,
        ]);
    })
    ->withExceptions(function (Exceptions $exceptions) {
        // Exception handling configuration
        $exceptions->render(function (CustomBusinessException $e, $request) {
            return response()->json([
                'error' => $e->getMessage(),
                'code' => $e->getCode()
            ], 422);
        });
    })
    ->create();

<?php
// app/Console/Commands/MigrateToSlimArchitecture.php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Filesystem\Filesystem;

class MigrateToSlimArchitecture extends Command
{
    protected $signature = 'laravel:migrate-slim {--dry-run : Show what would be changed without making changes}';
    protected $description = 'Migrate existing Laravel app to Laravel 11 slim architecture';
    
    private Filesystem $files;
    private array $migrations = [];
    
    public function __construct(Filesystem $files)
    {
        parent::__construct();
        $this->files = $files;
    }
    
    public function handle(): void
    {
        $this->info('Analyzing current Laravel structure...');
        
        $this->analyzeServiceProviders();
        $this->analyzeMiddleware();
        $this->analyzeKernels();
        $this->analyzeRoutes();
        
        if ($this->option('dry-run')) {
            $this->displayMigrationPlan();
            return;
        }
        
        $this->executeMigration();
        $this->info('Migration completed successfully!');
    }
    
    private function analyzeServiceProviders(): void
    {
        $providersPath = app_path('Providers');
        
        if (!$this->files->exists($providersPath)) {
            return;
        }
        
        $providers = collect($this->files->files($providersPath))
            ->filter(fn($file) => $file->getExtension() === 'php')
            ->map(fn($file) => $file->getBasename('.php'));
        
        $defaultProviders = [
            'AppServiceProvider',
            'AuthServiceProvider', 
            'EventServiceProvider',
            'RouteServiceProvider'
        ];
        
        foreach ($providers as $provider) {
            if (in_array($provider, $defaultProviders)) {
                $this->migrations['consolidate_providers'][] = $provider;
            } else {
                $this->migrations['keep_providers'][] = $provider;
            }
        }
    }
    
    private function analyzeMiddleware(): void
    {
        $middlewarePath = app_path('Http/Middleware');
        
        if (!$this->files->exists($middlewarePath)) {
            return;
        }
        
        $middleware = collect($this->files->files($middlewarePath))
            ->filter(fn($file) => $file->getExtension() === 'php')
            ->map(fn($file) => $file->getBasename('.php'));
        
        $this->migrations['middleware_count'] = $middleware->count();
        $this->migrations['custom_middleware'] = $middleware->reject(fn($m) => 
            in_array($m, [
                'Authenticate', 'RedirectIfAuthenticated', 'TrustProxies',
                'TrimStrings', 'ValidateSignature', 'VerifyCsrfToken'
            ])
        )->values()->toArray();
    }
    
    private function analyzeKernels(): void
    {
        $httpKernel = app_path('Http/Kernel.php');
        $consoleKernel = app_path('Console/Kernel.php');
        
        $this->migrations['has_http_kernel'] = $this->files->exists($httpKernel);
        $this->migrations['has_console_kernel'] = $this->files->exists($consoleKernel);
        
        if ($this->migrations['has_http_kernel']) {
            $this->migrations['kernel_middleware'] = $this->extractKernelMiddleware($httpKernel);
        }
    }
    
    private function analyzeRoutes(): void
    {
        $routesPath = base_path('routes');
        $routeFiles = ['web.php', 'api.php', 'console.php', 'channels.php'];
        
        foreach ($routeFiles as $file) {
            $filePath = $routesPath . '/' . $file;
            if ($this->files->exists($filePath)) {
                $content = $this->files->get($filePath);
                $isEmpty = trim(str_replace(['<?php', 'use ', '//'], '', $content)) === '';
                
                $this->migrations['route_files'][$file] = [
                    'exists' => true,
                    'empty' => $isEmpty,
                    'size' => strlen($content)
                ];
            }
        }
    }
    
    private function extractKernelMiddleware(string $kernelPath): array
    {
        $content = $this->files->get($kernelPath);
        preg_match('/protected \$middleware = \[(.*?)\];/s', $content, $matches);
        
        if (!$matches) {
            return [];
        }
        
        return array_map('trim', 
            array_filter(
                explode(',', 
                    str_replace(['"', "'", '\\', "\n", "\r"], '', $matches[1])
                )
            )
        );
    }
    
    private function displayMigrationPlan(): void
    {
        $this->info("\n=== Migration Plan ===");
        
        if (isset($this->migrations['consolidate_providers'])) {
            $this->warn("Service Providers to consolidate:");
            foreach ($this->migrations['consolidate_providers'] as $provider) {
                $this->line("  - {$provider}");
            }
        }
        
        if (isset($this->migrations['custom_middleware'])) {
            $this->warn("Custom middleware to preserve:");
            foreach ($this->migrations['custom_middleware'] as $middleware) {
                $this->line("  - {$middleware}");
            }
        }
        
        if (isset($this->migrations['route_files'])) {
            $this->warn("Route files analysis:");
            foreach ($this->migrations['route_files'] as $file => $info) {
                $status = $info['empty'] ? 'EMPTY - can be removed' : 'HAS CONTENT - preserve';
                $this->line("  - {$file}: {$status}");
            }
        }
        
        $this->info("\nEstimated files to be removed/consolidated: " . 
            (count($this->migrations['consolidate_providers'] ?? []) + 
             ($this->migrations['has_http_kernel'] ? 1 : 0) + 
             ($this->migrations['has_console_kernel'] ? 1 : 0)));
    }
    
    private function executeMigration(): void
    {
        $this->generateNewBootstrapApp();
        $this->consolidateServiceProviders();
        $this->removeObsoleteFiles();
        $this->updateComposerJson();
    }
    
    private function generateNewBootstrapApp(): void
    {
        $bootstrapContent = $this->generateBootstrapContent();
        $this->files->put(base_path('bootstrap/app.php'), $bootstrapContent);
        $this->info('Generated new bootstrap/app.php');
    }
    
    private function generateBootstrapContent(): string
    {
        $middleware = $this->migrations['custom_middleware'] ?? [];
        $middlewareConfig = '';
        
        if (!empty($middleware)) {
            $middlewareConfig = "\n    ->withMiddleware(function (Middleware \$middleware) {\n";
            foreach ($middleware as $m) {
                $middlewareConfig .= "        \$middleware->web(append: [\\App\\Http\\Middleware\\{$m}::class]);\n";
            }
            $middlewareConfig .= "    })";
        }
        
        return <<<PHP
<?php

use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Foundation\Configuration\Middleware;

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        commands: __DIR__.'/../routes/console.php',
        health: '/up',
    ){$middlewareConfig}
    ->withExceptions(function (Exceptions \$exceptions) {
        //
    })
    ->create();
PHP;
    }
    
    private function consolidateServiceProviders(): void
    {
        // Implementation would merge provider logic into AppServiceProvider
        $this->info('Consolidated service providers into AppServiceProvider');
    }
    
    private function removeObsoleteFiles(): void
    {
        $filesToRemove = [
            app_path('Http/Kernel.php'),
            app_path('Console/Kernel.php'),
            app_path('Exceptions/Handler.php')
        ];
        
        foreach ($filesToRemove as $file) {
            if ($this->files->exists($file)) {
                $this->files->delete($file);
                $this->info("Removed {$file}");
            }
        }
    }
    
    private function updateComposerJson(): void
    {
        // Update composer.json autoload if needed
        $this->info('Updated composer configuration');
    }
}

<?php

namespace Tests\Feature;

use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class SlimArchitectureMigrationTest extends TestCase
{
    use RefreshDatabase;
    
    public function testBootstrapAppConfigurationLoads(): void
    {
        $app = require base_path('bootstrap/app.php');
        
        $this->assertInstanceOf(\Illuminate\Foundation\Application::class, $app);
        $this->assertTrue($app->bound('router'));
        $this->assertTrue($app->bound('middleware'));
    }
    
    public function testRoutingConfiguration(): void
    {
        $response = $this->get('/');
        $response->assertStatus(200);
        
        // Test health check endpoint
        $response = $this->get('/up');
        $response->assertStatus(200);
    }
    
    public function testMiddlewareConfiguration(): void
    {
        // Test CSRF protection is working
        $response = $this->post('/test-route');
        $response->assertStatus(419); // CSRF token mismatch
        
        // Test custom middleware is loaded
        $middlewareGroups = app('router')->getMiddlewareGroups();
        $this->assertArrayHasKey('web', $middlewareGroups);
        $this->assertArrayHasKey('api', $middlewareGroups);
    }
    
    public function testServiceProviderConsolidation(): void
    {
        $loadedProviders = app()->getLoadedProviders();
        
        // AppServiceProvider should be loaded
        $this->assertArrayHasKey('App\\Providers\\AppServiceProvider', $loadedProviders);
        
        // Default providers should not exist as separate files
        $this->assertFileDoesNotExist(app_path('Providers/RouteServiceProvider.php'));
        $this->assertFileDoesNotExist(app_path('Http/Kernel.php'));
    }
    
    public function testExceptionHandling(): void
    {
        // Test that custom exception handling works
        $this->withoutExceptionHandling();
        
        try {
            throw new \Exception('Test exception');
        } catch (\Exception $e) {
            $this->assertEquals('Test exception', $e->getMessage());
        }
    }
    
    public function testFilesystemStructure(): void
    {
        // Verify slim structure
        $this->assertFileExists(base_path('bootstrap/app.php'));
        $this->assertFileExists(app_path('Providers/AppServiceProvider.php'));
        
        // Verify removed files
        $this->assertFileDoesNotExist(app_path('Http/Kernel.php'));
        $this->assertFileDoesNotExist(app_path('Console/Kernel.php'));
        $this->assertFileDoesNotExist(app_path('Exceptions/Handler.php'));
    }
}

// config/queue.php
'default' => env('QUEUE_CONNECTION', 'redis'),

'connections' => [
    'redis' => [
        'driver' => 'redis',
        'connection' => 'default',
        'queue' => env('REDIS_QUEUE', 'default'),
        'retry_after' => 180,
        'block_for' => null,
    ],
],

// App/Jobs/SendBulkNotificationJob.php
<?php

namespace App\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Mail;

class SendBulkNotificationJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public $tries = 3;
    public $backoff = [60, 120, 300]; // Progressive backoff
    public $timeout = 300; // 5 minutes max execution

    protected $recipients;
    protected $messageData;

    public function __construct($recipients, $messageData)
    {
        $this->recipients = $recipients;
        $this->messageData = $messageData;
    }

    public function handle()
    {
        // Process in smaller chunks to avoid memory issues
        collect($this->recipients)->chunk(50)->each(function ($chunk) {
            foreach ($chunk as $recipient) {
                try {
                    Mail::to($recipient['email'])
                        ->queue(new NotificationMail($recipient, $this->messageData));
                } catch (\Exception $e) {
                    // Log individual failures without failing entire batch
                    \Log::error('Failed to queue email for ' . $recipient['email'], [
                        'error' => $e->getMessage(),
                        'recipient' => $recipient
                    ]);
                }
            }
        });
    }

    public function failed(\Throwable $exception)
    {
        // Handle job failure - notify administrators
        \Log::critical('Bulk notification job failed completely', [
            'recipients_count' => count($this->recipients),
            'error' => $exception->getMessage()
        ]);
    }
}

// In your job class
public function retryUntil()
{
    return now()->addMinutes(30); // Stop retrying after 30 minutes
}

public function backoff()
{
    return [60, 180, 600]; // 1 min, 3 min, 10 min delays
}

public function handle()
{
    try {
        // Your email sending logic
        $this->sendEmail();
    } catch (TemporaryEmailException $e) {
        // Release job back to queue with delay
        $this->release(120); // Retry in 2 minutes
    } catch (PermanentEmailException $e) {
        // Fail permanently - don't retry
        $this->fail($e);
    }
}

// config/horizon.php
'environments' => [
    'production' => [
        'supervisor-1' => [
            'connection' => 'redis',
            'queue' => ['high', 'default', 'low'],
            'balance' => 'auto',
            'processes' => 8,
            'tries' => 3,
            'timeout' => 300,
        ],
    ],
],

// tests/Feature/QueueOptimizationTest.php
<?php

namespace Tests\Feature;

use App\Jobs\SendBulkNotificationJob;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Queue;
use Tests\TestCase;

class QueueOptimizationTest extends TestCase
{
    use RefreshDatabase;

    public function test_bulk_notification_job_processes_successfully()
    {
        Queue::fake();

        $recipients = factory(User::class, 1000)->make()->toArray();
        $messageData = ['subject' => 'Test', 'body' => 'Test message'];

        SendBulkNotificationJob::dispatch($recipients, $messageData);

        Queue::assertPushed(SendBulkNotificationJob::class, 1);
    }

    public function test_job_retry_logic_works_correctly()
    {
        // Test that jobs retry with proper backoff
        $this->artisan('queue:work', [
            '--once' => true,
            '--tries' => 3
        ]);

        // Assert retry behavior
    }
}

public function test_user_service_creates_user()
{
    $service = new UserService();
    $user = $service->createUser([
        'name' => 'John Doe',
        'email' => 'john@example.com'
    ]);
    
    $this->assertInstanceOf(User::class, $user);
    // Breaks if you rename UserService or change its constructor
}

public function test_user_can_register_successfully()
{
    $response = $this->post('/register', [
        'name' => 'John Doe',
        'email' => 'john@example.com',
        'password' => 'password123',
        'password_confirmation' => 'password123'
    ]);
    
    $response->assertRedirect('/dashboard');
    $this->assertDatabaseHas('users', [
        'email' => 'john@example.com'
    ]);
    
    // Survives refactoring as long as behavior stays the same
}

use Illuminate\Foundation\Testing\RefreshDatabase;

class UserTest extends TestCase
{
    use RefreshDatabase; // Migrates database before EVERY test
    
    public function test_user_can_login()
    {
        // Test runs 500ms+ slower due to migrations
    }
}

use Illuminate\Foundation\Testing\DatabaseTransactions;

class UserTest extends TestCase
{
    use DatabaseTransactions; // Rolls back after each test
    
    public function test_user_can_login()
    {
        // Test runs near-instantly
    }
}

public function test_payment_processing()
{
    $response = $this->post('/checkout', [
        'amount' => 100.00
    ]);
    
    // This test actually charges Stripe $100.00
    // Slow, costs money, fails if API is down
}

use Illuminate\Support\Facades\Http;

public function test_payment_processing()
{
    Http::fake([
        'api.stripe.com/*' => Http::response([
            'id' => 'ch_test123',
            'status' => 'succeeded'
        ], 200)
    ]);
    
    $response = $this->post('/checkout', [
        'amount' => 100.00
    ]);
    
    $response->assertSuccessful();
    
    Http::assertSent(function ($request) {
        return $request->url() === 'https://api.stripe.com/charges' &&
               $request['amount'] === 10000;
    });
}

Http::preventStrayRequests(); // Fails if any unmocked request is made

<?php

namespace Tests\Feature;

use Tests\TestCase;
use App\Models\User;
use App\Models\Product;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Illuminate\Support\Facades\Http;

class CheckoutTest extends TestCase
{
    use DatabaseTransactions;
    
    protected function setUp(): void
    {
        parent::setUp();
        
        // Prevent any unmocked HTTP requests
        Http::preventStrayRequests();
        
        // Set up common test data
        $this->user = User::factory()->create();
        $this->product = Product::factory()->create([
            'price' => 100.00,
            'stock' => 10
        ]);
    }
    
    public function test_user_can_complete_checkout_successfully()
    {
        // Arrange: Mock payment gateway
        Http::fake([
            'api.stripe.com/v1/charges' => Http::response([
                'id' => 'ch_test123',
                'status' => 'succeeded',
                'amount' => 10000
            ], 200)
        ]);
        
        // Act: User completes checkout
        $response = $this->actingAs($this->user)
            ->post('/checkout', [
                'product_id' => $this->product->id,
                'quantity' => 1,
                'payment_method' => 'stripe'
            ]);
        
        // Assert: Verify behavior
        $response->assertRedirect('/orders');
        
        // Verify order was created
        $this->assertDatabaseHas('orders', [
            'user_id' => $this->user->id,
            'product_id' => $this->product->id,
            'total' => 100.00,
            'status' => 'completed'
        ]);
        
        // Verify inventory was reduced
        $this->assertEquals(9, $this->product->fresh()->stock);
        
        // Verify Stripe was called correctly
        Http::assertSent(function ($request) {
            return $request->url() === 'https://api.stripe.com/v1/charges' &&
                   $request['amount'] === 10000 &&
                   $request['currency'] === 'usd';
        });
    }
    
    public function test_checkout_fails_when_payment_declined()
    {
        // Arrange: Mock declined payment
        Http::fake([
            'api.stripe.com/v1/charges' => Http::response([
                'error' => [
                    'type' => 'card_error',
                    'message' => 'Your card was declined'
                ]
            ], 402)
        ]);
        
        $initialStock = $this->product->stock;
        
        // Act
        $response = $this->actingAs($this->user)
            ->post('/checkout', [
                'product_id' => $this->product->id,
                'quantity' => 1,
                'payment_method' => 'stripe'
            ]);
        
        // Assert: Order not created
        $this->assertDatabaseMissing('orders', [
            'user_id' => $this->user->id,
            'status' => 'completed'
        ]);
        
        // Inventory unchanged
        $this->assertEquals($initialStock, $this->product->fresh()->stock);
        
        // User sees error
        $response->assertSessionHasErrors('payment');
    }
    
    public function test_checkout_prevents_overselling()
    {
        // Arrange: Product with limited stock
        $this->product->update(['stock' => 1]);
        
        Http::fake([
            'api.stripe.com/*' => Http::response(['status' => 'succeeded'], 200)
        ]);
        
        // Act: Try to buy more than available
        $response = $this->actingAs($this->user)
            ->post('/checkout', [
                'product_id' => $this->product->id,
                'quantity' => 2,
                'payment_method' => 'stripe'
            ]);
        
        // Assert: Order rejected
        $response->assertStatus(422);
        $response->assertJsonValidationErrors('quantity');
        
        // No charge attempted
        Http::assertNothingSent();
    }
}

// Update composer.json
{
    "require": {
        "laravel/framework": "^11.0",
        "php": "^8.2"
    }
}

// New Dumpable trait for easier debugging
use Illuminate\Support\Traits\Dumpable;

class UserService 
{
    use Dumpable;
    
    public function processUsers()
    {
        return $this->queryUsers()
            ->dd() // Debug output in development
            ->transformData();
    }
}

// Dynamic component rendering based on user permissions
<x-dynamic-component 
    :component="auth()->user()->hasRole('admin') ? 'admin-panel' : 'user-panel'"
    :data="$dashboardData" 
/>

$users = User::with(['posts' => function ($query) {
    $query->latest()->limit(10);
}])->get();

test('user can process batch operations', function () {
    $jobs = collect(range(1, 100))->map(fn($i) => new ProcessUserJob($i));
    
    $batch = Bus::batch($jobs)->dispatch();
    
    expect($batch->finished())->toBeTrue();
    expect($batch->failedJobs)->toHaveCount(0);
});

// Example: Optimized string operations in PHP 8.4
class DataProcessor
{
    public function processLargeDataset(array $records): array
    {
        // PHP 8.4 optimized string/array operations
        return array_map(
            fn($record) => $this->transformRecord($record),
            array_filter($records, fn($r) => $this->isValid($r))
        );
    }
    
    private function transformRecord(array $record): array
    {
        // Utilizing PHP 8.4's enhanced memory management
        return [
            'id' => $record['id'],
            'processed_at' => new DateTime(),
            'data' => json_encode($record['payload']) // Faster JSON operations
        ];
    }
}

// Utilizing PHP 8.4's improved password hashing
class AuthenticationService
{
    public function hashPassword(string $password): string
    {
        // PHP 8.4 enhanced password_hash with better algorithms
        return password_hash($password, PASSWORD_ARGON2ID, [
            'memory_cost' => 65536,  // 64 MB
            'time_cost' => 4,        // 4 iterations  
            'threads' => 3,          // 3 threads
        ]);
    }
    
    public function validateSecureInput(string $input): bool
    {
        // Enhanced input validation with PHP 8.4 features
        return filter_var($input, FILTER_VALIDATE_REGEXP, [
            'options' => ['regexp' => '/^[a-zA-Z0-9_-]+$/']
        ]) !== false;
    }
}

// Property hooks reduce boilerplate code
class UserAccount
{
    public string $email {
        set(string $value) {
            if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
                throw new InvalidArgumentException('Invalid email');
            }
            $this->email = strtolower($value);
        }
    }
    
    public bool $isActive { 
        set(bool $value) {
            $this->isActive = $value;
            if ($value) {
                $this->activatedAt = new DateTime();
            }
        }
    }
    
    private ?DateTime $activatedAt = null;
}

class PHP84MigrationTest extends TestCase
{
    public function test_performance_improvements()
    {
        $startMemory = memory_get_usage();
        $startTime = microtime(true);
        
        // Test intensive operation
        $processor = new DataProcessor();
        $result = $processor->processLargeDataset($this->getLargeDataset());
        
        $endTime = microtime(true);
        $endMemory = memory_get_usage();
        
        $executionTime = ($endTime - $startTime) * 1000;
        $memoryUsed = $endMemory - $startMemory;
        
        // Verify performance improvements
        $this->assertLessThan(500, $executionTime, 'Processing should complete under 500ms');
        $this->assertLessThan(50000000, $memoryUsed, 'Memory usage should stay under 50MB');
        $this->assertNotEmpty($result, 'Processing should return results');
    }
    
    public function test_security_enhancements()
    {
        $auth = new AuthenticationService();
        
        // Test password hashing strength
        $hashedPassword = $auth->hashPassword('securepassword123');
        $this->assertTrue(password_verify('securepassword123', $hashedPassword));
        
        // Test input validation
        $this->assertTrue($auth->validateSecureInput('valid_input_123'));
        $this->assertFalse($auth->validateSecureInput('invalid<input>'));
    }
}

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Stripe\Stripe;
use Stripe\Charge;
use Stripe\Exception\CardException;
use Stripe\Exception\InvalidRequestException;
use App\Models\Payment;
use App\Models\User;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\DB;

class SecurePaymentController extends Controller
{
    public function __construct()
    {
        // Set Stripe secret key securely
        Stripe::setApiKey(config('services.stripe.secret'));
    }

    public function processPayment(Request $request)
    {
        // Validate request with strict rules
        $validated = $request->validate([
            'stripeToken' => 'required|string|starts_with:tok_',
            'amount' => 'required|integer|min:50|max:999999', // $0.50 to $9,999.99
            'currency' => 'nullable|string|in:usd,eur,gbp',
            'description' => 'nullable|string|max:255',
        ]);

        // Verify CSRF token
        if (!$request->hasValidSignature() && !$request->session()->token() === $request->input('_token')) {
            return response()->json(['error' => 'Invalid request'], 403);
        }

        DB::beginTransaction();

        try {
            // Create charge with comprehensive metadata
            $charge = Charge::create([
                'amount' => $validated['amount'],
                'currency' => $validated['currency'] ?? 'usd',
                'source' => $validated['stripeToken'],
                'description' => $validated['description'] ?? 'Payment',
                'metadata' => [
                    'user_id' => auth()->id(),
                    'ip_address' => $request->ip(),
                    'user_agent' => $request->userAgent(),
                    'timestamp' => now()->toISOString(),
                ],
                'receipt_email' => auth()->user()->email,
            ]);

            // Store payment record securely
            $payment = Payment::create([
                'user_id' => auth()->id(),
                'stripe_charge_id' => $charge->id,
                'amount' => $validated['amount'],
                'currency' => $charge->currency,
                'status' => $charge->status,
                'receipt_url' => $charge->receipt_url,
                // Never store card details or tokens
            ]);

            DB::commit();

            // Log successful payment (without sensitive data)
            Log::info('Payment processed successfully', [
                'payment_id' => $payment->id,
                'amount' => $validated['amount'],
                'user_id' => auth()->id(),
            ]);

            return response()->json([
                'success' => true,
                'payment_id' => $payment->id,
                'receipt_url' => $charge->receipt_url,
            ]);

        } catch (CardException $e) {
            DB::rollback();
            
            // Log payment failure
            Log::warning('Payment failed - Card error', [
                'error' => $e->getMessage(),
                'user_id' => auth()->id(),
                'amount' => $validated['amount'],
            ]);

            return response()->json([
                'error' => 'Your card was declined. Please try a different payment method.'
            ], 422);

        } catch (InvalidRequestException $e) {
            DB::rollback();
            
            // Log security issue
            Log::error('Payment failed - Invalid request', [
                'error' => $e->getMessage(),
                'user_id' => auth()->id(),
                'ip_address' => $request->ip(),
            ]);

            return response()->json(['error' => 'Invalid payment request'], 400);

        } catch (\Exception $e) {
            DB::rollback();
            
            // Log unexpected error
            Log::error('Payment failed - Unexpected error', [
                'error' => $e->getMessage(),
                'user_id' => auth()->id(),
            ]);

            return response()->json(['error' => 'Payment processing failed'], 500);
        }
    }
}

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Stripe\Webhook;
use Stripe\Exception\SignatureVerificationException;
use App\Models\Payment;
use Illuminate\Support\Facades\Log;

class StripeWebhookController extends Controller
{
    public function handle(Request $request): Response
    {
        $payload = $request->getContent();
        $sig_header = $request->server('HTTP_STRIPE_SIGNATURE');
        $endpoint_secret = config('services.stripe.webhook_secret');

        try {
            // Verify webhook signature
            $event = Webhook::constructEvent($payload, $sig_header, $endpoint_secret);
            
        } catch (SignatureVerificationException $e) {
            // Log security violation
            Log::error('Webhook signature verification failed', [
                'ip_address' => $request->ip(),
                'user_agent' => $request->userAgent(),
                'payload_length' => strlen($payload),
            ]);
            
            return response('Invalid signature', 400);
        }

        // Handle specific events securely
        switch ($event['type']) {
            case 'payment_intent.succeeded':
                $this->handlePaymentSuccess($event['data']['object']);
                break;
                
            case 'payment_intent.payment_failed':
                $this->handlePaymentFailure($event['data']['object']);
                break;
                
            case 'charge.dispute.created':
                $this->handleChargeDispute($event['data']['object']);
                break;
                
            default:
                Log::info('Unhandled webhook event', ['type' => $event['type']]);
        }

        return response('OK', 200);
    }

    private function handlePaymentSuccess($paymentIntent): void
    {
        $payment = Payment::where('stripe_payment_intent_id', $paymentIntent['id'])->first();
        
        if ($payment) {
            $payment->update([
                'status' => 'completed',
                'completed_at' => now(),
            ]);
            
            // Trigger business logic (order fulfillment, etc.)
            event(new PaymentCompleted($payment));
            
            Log::info('Payment completed via webhook', [
                'payment_id' => $payment->id,
                'amount' => $payment->amount,
            ]);
        }
    }

    private function handlePaymentFailure($paymentIntent): void
    {
        $payment = Payment::where('stripe_payment_intent_id', $paymentIntent['id'])->first();
        
        if ($payment) {
            $payment->update([
                'status' => 'failed',
                'failure_reason' => $paymentIntent['last_payment_error']['message'] ?? 'Unknown error',
            ]);
            
            Log::warning('Payment failed via webhook', [
                'payment_id' => $payment->id,
                'reason' => $paymentIntent['last_payment_error']['message'] ?? 'Unknown',
            ]);
        }
    }

    private function handleChargeDispute($dispute): void
    {
        // Handle chargeback/dispute
        Log::alert('Charge dispute created', [
            'dispute_id' => $dispute['id'],
            'charge_id' => $dispute['charge'],
            'amount' => $dispute['amount'],
            'reason' => $dispute['reason'],
        ]);
        
        // Notify relevant team members
        event(new ChargeDisputeCreated($dispute));
    }
}

// config/services.php - Secure configuration
<?php

return [
    'stripe' => [
        'model' => App\Models\User::class,
        'key' => env('STRIPE_KEY'),
        'secret' => env('STRIPE_SECRET'),
        'webhook_secret' => env('STRIPE_WEBHOOK_SECRET'),
    ],
];

// tests/Feature/PaymentSecurityTest.php
<?php

namespace Tests\Feature;

use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class PaymentSecurityTest extends TestCase
{
    use RefreshDatabase;

    public function test_payment_endpoint_requires_authentication()
    {
        $response = $this->postJson('/process-payment', [
            'stripeToken' => 'tok_visa',
            'amount' => 2000,
        ]);

        $response->assertUnauthorized();
    }

    public function test_payment_validates_csrf_token()
    {
        $user = User::factory()->create();
        
        $response = $this->actingAs($user)
            ->postJson('/process-payment', [
                'stripeToken' => 'tok_visa',
                'amount' => 2000,
            ], [
                'X-CSRF-TOKEN' => 'invalid-token',
            ]);

        $response->assertForbidden();
    }

    public function test_payment_validates_amount_limits()
    {
        $user = User::factory()->create();
        
        // Test minimum amount
        $response = $this->actingAs($user)
            ->postJson('/process-payment', [
                'stripeToken' => 'tok_visa',
                'amount' => 25, // Below $0.50 minimum
            ]);

        $response->assertJsonValidationErrors(['amount']);
        
        // Test maximum amount
        $response = $this->actingAs($user)
            ->postJson('/process-payment', [
                'stripeToken' => 'tok_visa',
                'amount' => 1000000, // Above $9,999.99 maximum
            ]);

        $response->assertJsonValidationErrors(['amount']);
    }

    public function test_webhook_rejects_invalid_signatures()
    {
        $payload = json_encode(['type' => 'payment_intent.succeeded']);
        
        $response = $this->postJson('/stripe/webhook', $payload, [
            'HTTP_STRIPE_SIGNATURE' => 'invalid-signature',
        ]);

        $response->assertStatus(400);
    }
}

// app/Services/PaymentSecurityMonitor.php
<?php

namespace App\Services;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Cache;

class PaymentSecurityMonitor
{
    public function monitorPaymentAttempt(Request $request): bool
    {
        $ipAddress = $request->ip();
        
        // Rate limiting
        $attempts = Cache::get("payment_attempts:{$ipAddress}", 0);
        
        if ($attempts >= 5) {
            Log::warning('Payment rate limit exceeded', [
                'ip_address' => $ipAddress,
                'attempts' => $attempts,
            ]);
            return false;
        }
        
        Cache::put("payment_attempts:{$ipAddress}", $attempts + 1, 3600);
        
        // Geographic validation
        if ($this->isHighRiskLocation($ipAddress)) {
            Log::warning('Payment from high-risk location', [
                'ip_address' => $ipAddress,
                'user_id' => auth()->id(),
            ]);
            
            // Additional verification required
            return false;
        }
        
        return true;
    }
    
    private function isHighRiskLocation(string $ipAddress): bool
    {
        // Implement IP geolocation and risk scoring
        return false; // Placeholder implementation
    }
}

use LarAgent\Attributes\Tool;

class DevOpsAgent extends \LarAgent\Agent
{
    #[Tool("Provide Jenkins pipeline advice")]
    public function jenkinsAdvice(string $pipeline): string
    {
        // Example logic: analyze or return best practice
        return "For reusable pipeline steps, use declarative syntax and shared library functions.";
    }
    public function instructions(): string
    {
        return 'You are an expert CI/CD assistant.';
    }
}