<?php

// namespace App\Console\Commands;

// use Illuminate\Console\Command;
// use App\Models\MubarokahToken; // Asumsi model Eloquent

class DebugOAuthFlow extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'mubarokah:debug {client_id} {--user_id=} {--trace}';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Debug Mubarokah ID OAuth flow for a specific client or user';

    /**
     * Execute the console command.
     *
     * @return int
     */
    public function handle()
    {
        $clientId = $this->argument('client_id');
        $userId = $this->option('user_id');
        $this->info("🔍 Debugging for Mubarokah ID Client: {$clientId}");

        // 1. Check Client Configuration (from your app's perspective)
        $this->line("\n📋 Client Configuration:");
        $clientConfig = config('services.mubarokah'); // Example
        if ($clientConfig['client_id'] == $clientId) {
            $this->info("Loaded Client ID: " . $clientConfig['client_id']);
            $this->info("Redirect URI: " . $clientConfig['redirect']);
            $this->info("Base URL: " . $clientConfig['base_url']);
        } else {
            $this->error("Client ID mismatch or not found in local config.");
        }

        // 2. Check Recent Tokens from your Token Store (e.g., MubarokahToken model)
        $this->line("\n🎫 Recent Token Activity (from local store):");
        // Logika untuk mengambil token, contoh:
        // $recentTokens = MubarokahToken::where('client_id', $clientId)
        //     ->orderBy('created_at', 'desc')
        //     ->limit(5)
        //     ->get();
        // foreach ($recentTokens as $token) {
        //     $status = $token->isExpired() ? '⏰ Expired' : '✅ Active';
        //     $this->line("Token for User {$token->user_id}: {$status} - Created: {$token->created_at} - Expires: {$token->expires_at}");
        //     $this->line("   Scopes: " . implode(', ', $token->scopes ?? []));
        // }

        // 3. Check Error Logs
        $this->line("\n📝 Recent Error Logs (filtered):");
        $this->comment('// Implement log searching logic here...');
        $this->comment('// Example: grep for client_id or user_id in your application logs.');

        if ($this->option('trace')) {
            $this->line("\n🔬 Simulating OAuth Flow Trace (Conceptual):");
            // This would involve making mock calls or describing expected steps.
            try {
                // $testClient = new \GuzzleHttp\Client();
                // $response = $testClient->post(config('services.mubarokah.base_url') . '/oauth/token', [
                //     'form_params' => [
                //         'grant_type' => 'client_credentials',
                //         'client_id' => $clientId,
                //         'client_secret' => config('services.mubarokah.client_secret') // Careful with secrets
                //     ]
                // ]);
                // $this->info("Client Credentials Grant Test: Success " . $response->getStatusCode());
            } catch (\Exception $e) {
                // $this->error("Client Credentials Grant Test: Failed - " . $e->getMessage());
            }
        }
    }
}

import { v4 as uuidv4 } from 'uuid'; // Example for generating unique IDs

class OAuthFlowTracer {
    private activeTraces: Map<string, { startTime: number, steps: any[], errors: any[], context: any }> = new Map();

    public startTrace(initialContext: any = {}): string {
        const traceId = uuidv4();
        this.activeTraces.set(traceId, {
            startTime: Date.now(),
            steps: [{ step: 'Trace Initiated', timestamp: Date.now(), data: initialContext }],
            errors: [],
            context: initialContext
        });
        console.log(`OAuth Trace Started: ${traceId}`, initialContext); // Replace with proper logging
        return traceId;
    }

    public addStep(traceId: string, stepName: string, data: any = {}): void {
        const trace = this.activeTraces.get(traceId);
        if (trace) {
            const stepData = { step: stepName, timestamp: Date.now(), data, memory: process.memoryUsage().rss };
            trace.steps.push(stepData);
            console.log(`OAuth Trace [${traceId}] Step: ${stepName}`, data); // Replace with proper logging
        }
    }

    public addError(traceId: string, error: any, context: any = {}): void {
        const trace = this.activeTraces.get(traceId);
        if (trace) {
            const errorData = { error: error.message || error, timestamp: Date.now(), context, stack: error.stack };
            trace.errors.push(errorData);
            console.error(`OAuth Trace [${traceId}] Error: ${error.message || error}`, context); // Replace with proper logging
        }
    }

    public endTrace(traceId: string): any | null {
        const trace = this.activeTraces.get(traceId);
        if (trace) {
            trace.steps.push({ step: 'Trace Ended', timestamp: Date.now() });
            const totalDuration = Date.now() - trace.startTime;
            console.log(`OAuth Trace Ended: ${traceId}, Duration: ${totalDuration}ms`, {
                duration: totalDuration,
                stepCount: trace.steps.length,
                errorCount: trace.errors.length
            }); // Replace with proper logging

            this.activeTraces.delete(traceId);
            return { ...trace, totalDuration };
        }
        return null;
    }
}

// Usage Example:
// const tracer = new OAuthFlowTracer();
// const traceId = tracer.startTrace({ clientId: 'xyz-client-123' });
// tracer.addStep(traceId, 'Redirecting to authorize endpoint');
// // ... later in your callback handler ...
// tracer.addStep(traceId, 'Callback received', { code: 'some-auth-code', state: 'state-value' });
// // if (error) tracer.addError(traceId, error);
// tracer.endTrace(traceId);