import http from 'k6/http';
import { check, sleep } from 'k6';
import { SharedArray } from 'k6/data';

// --- Test Configuration ---
export const options = {
  stages: [
    { duration: '1m', target: 50 },  // Ramp up to 50 virtual users over 1 minute
    { duration: '3m', target: 50 },  // Stay at 50 VU for 3 minutes
    { duration: '1m', target: 0 },   // Ramp down to 0 VU over 1 minute
  ],
  thresholds: {
    'http_req_duration{name:Callback}': ['p(95)<500'], // 95% of callback requests < 500ms
    'http_req_failed{name:Callback}': ['rate<0.01'],   // Less than 1% failed callback requests
    // 'http_req_duration{name:MockTokenExchange}': ['p(95)<100'], // If mocking token exchange
  },
};

// --- Test Data (Conceptual - generate more realistically) ---
const users = new SharedArray('users_data', function () {
  const data = [];
  for (let i = 0; i < 1000; i++) {
    data.push({
      authCode: `mockAuthCode\${i}-\${Math.random().toString(36).substring(7)}`,
      state: `mockState\${i}-\${Math.random().toString(36).substring(7)}`,
      // pkceVerifier: `mockVerifier\${i}` // If testing PKCE
    });
  }
  return data;
});

// --- Mock Mubarokah ID Token Endpoint (Run this as a separate server in your test env) ---
// This is a conceptual mock. In a real test, you'd have a simple server (e.g., Express.js)
// that responds to POST /mock/oauth/token
const MOCK_TOKEN_ENDPOINT = 'http://localhost:3001/mock/oauth/token'; // Your mock server
const YOUR_APP_CALLBACK_URL = 'https://yourapp.com/auth/mubarokah/callback';

// --- Main Test Function (Virtual User) ---
export default function () {
  const user = users[Math.floor(Math.random() * users.length)];

  // 1. Simulate Mubarokah ID redirecting to your callback
  // Your app's session middleware should handle storing/retrieving the state for validation.
  // For the load test, you might need to pre-populate session storage if your app expects it,
  // or your app might handle cases where state is missing if it's a direct hit without prior session.
  // This part highly depends on your app's session and state validation logic.
  // For simplicity, we assume the callback can be hit directly with code & state.

  const callbackUrl = `${YOUR_APP_CALLBACK_URL}?code=${user.authCode}&state=${user.state}`;
  const callbackResponse = http.get(callbackUrl, {
    tags: { name: 'Callback' },
    // If your callback expects a session cookie with the state, you'd need to manage cookies.
  });

  check(callbackResponse, {
    'Callback successful (e.g., redirects or returns 200)': (r) => r.status === 200 || r.status === 302,
  });

  // Inside your callback handler (which is being tested), it would then:
  // - Validate state (needs session pre-population or mock for test)
  // - Make a POST request to Mubarokah's /oauth/token.
  //   For load testing, this should go to your MOCK_TOKEN_ENDPOINT.
  //   This call is part of what callbackResponse.timings.duration measures.

  // Example of how your app *might* call the (mocked) token endpoint:
  /*
  if (callbackResponse.status === 200 || callbackResponse.status === 302) { // Assuming callback leads to token exchange
    // This part is what your server does. The load test measures the whole callback.
    const tokenPayload = {
      grant_type: 'authorization_code',
      code: user.authCode,
      redirect_uri: YOUR_APP_CALLBACK_URL, // Or the original redirect URI
      client_id: 'your_client_id',
      client_secret: 'your_client_secret_FOR_MOCK_ONLY', // Use mock credentials for mock server
      // code_verifier: user.pkceVerifier // If using PKCE
    };
    const tokenResponse = http.post(MOCK_TOKEN_ENDPOINT, tokenPayload, {
      tags: { name: 'MockTokenExchange' },
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    });
    check(tokenResponse, {
      'Mock token exchange successful': (r) => r.status === 200 && r.json('access_token') !== '',
    });
  }
  */

  sleep(1); // Think time between iterations for a VU
}