async function getOrangeToken(): Promise<string> {
  const response = await fetch('https://api.orange.com/oauth/v3/token', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
      'Authorization': Basic ${Buffer.from(${clientId}:${clientSecret}).toString('base64')}
    },
    body: 'grant_type=client_credentials'
  });
  const data = await response.json();
  return data.access_token;
}

interface OrangePaymentRequest {
  amount: string;
  currency: 'XOF';
  merchant_key: string;
  order_id: string;
  callback_url: string;
  customer_phone: string;
}
async function initiateOrangePayment(
  token: string,
  payment: OrangePaymentRequest
): Promise<{ payment_url: string; transaction_id: string }> {
  const response = await fetch('https://api.orange.com/orange-money-webpay/senegal/v1/webpay', {
    method: 'POST',
    headers: {
      'Authorization': Bearer ${token},
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      amount: payment.amount,
      currency: payment.currency,
      merchant_key: payment.merchant_key,
      order_id: payment.order_id,
      callback_url: payment.callback_url,
      customer_phone: payment.customer_phone,
      return_url: ${payment.callback_url}/return,
      cancel_url: ${payment.callback_url}/cancel
    })
  });
  if (!response.ok) {
    throw new Error(Orange Money API error: ${response.status});
  }
  const data = await response.json();
  return {
    payment_url: data.payment_url,
    transaction_id: data.transaction_id
  };
}

interface OrangeWebhookPayload {
  transaction_id: string;
  order_id: string;
  status: 'SUCCESS' | 'FAILED' | 'PENDING';
  amount: string;
  currency: string;
  payment_method: 'ORANGE_MONEY';
  timestamp: string;
}
async function handleOrangeWebhook(req: Request, res: Response) {
  const payload = await req.json() as OrangeWebhookPayload;
  // Vérifier la signature HMAC-SHA256
  const signature = req.headers['x-orange-signature'];
  const expectedSignature = crypto
    .createHmac('sha256', process.env.ORANGE_WEBHOOK_SECRET)
    .update(JSON.stringify(payload))
    .digest('base64');
  if (signature !== expectedSignature) {
    return res.status(401).json({ error: 'Invalid signature' });
  }
  // Traiter le paiement
  if (payload.status === 'SUCCESS') {
    await updateOrderStatus(payload.order_id, 'PAID');
  }
  res.status(200).json({ received: true });
}

interface MTNAuthResponse {
  access_token: string;
  token_type: string;
  expires_in: number;
}
async function getMTNToken(): Promise<string> {
  const authString = Buffer.from(${apiUser}:${apiKey}).toString('base64');
  const response = await fetch('https://sandbox.momodeveloper.mtn.com/collection/token/', {
    method: 'POST',
    headers: {
      'Authorization': Basic ${authString},
      'Ocp-Apim-Subscription-Key': subscriptionKey
    }
  });
  const data = await response.json() as MTNAuthResponse;
  return data.access_token;
}

interface MTNPaymentRequest {
  amount: string;
  currency: 'XOF';
  external_id: string;
  payer_phone: string;
  payer_message: string;
  payee_note: string;
}
async function requestMTNPayment(
  token: string,
  payment: MTNPaymentRequest
): Promise<{ reference_id: string; financial_transaction_id: string }> {
  const response = await fetch('https://momodeveloper.mtn.com/collection/v1_0/requesttopay', {
    method: 'POST',
    headers: {
      'Authorization': Bearer ${token},
      'X-Reference-Id': generateUUID(),
      'X-Target-Environment': 'senegal',
      'Ocp-Apim-Subscription-Key': subscriptionKey,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      amount: payment.amount,
      currency: payment.currency,
      externalId: payment.external_id,
      payer: {
        partyIdType: 'MSISDN',
        partyId: payment.payer_phone
      },
      payerMessage: payment.payer_message,
      payeeNote: payment.payee_note
    })
  });
  if (!response.ok) {
    const error = await response.text();
    throw new Error(MTN MoMo API error: ${error});
  }
  const referenceId = response.headers.get('X-Reference-Id');
  const statusResponse = await fetch(
    https://momodeveloper.mtn.com/collection/v1_0/requesttopay/${referenceId},
    {
      headers: {
        'Authorization': Bearer ${token},
        'X-Target-Environment': 'senegal',
        'Ocp-Apim-Subscription-Key': subscriptionKey
      }
    }
  );
  const statusData = await statusResponse.json();
  return {
    reference_id: referenceId!,
    financial_transaction_id: statusData.financialTransactionId
  };
}

type PaymentStatus = 'PENDING' | 'SUCCESSFUL' | 'FAILED' | 'TIMED_OUT';
async function getMTNPaymentStatus(
  token: string,
  referenceId: string
): Promise<{ status: PaymentStatus; amount?: string }> {
  const response = await fetch(
    https://momodeveloper.mtn.com/collection/v1_0/requesttopay/${referenceId},
    {
      headers: {
        'Authorization': Bearer ${token},
        'X-Target-Environment': 'senegal',
        'Ocp-Apim-Subscription-Key': subscriptionKey
      }
    }
  );
  const data = await response.json();
  return {
    status: data.status as PaymentStatus,
    amount: data.amount
  };
}

// Configuration des timeouts par opérateur
const PSP_TIMEOUTS = {
  ORANGE_MONEY: {
    payment_validation: 30000, // 30s max pour validation client
    webhook_delay: 5000,       // Premier webhook attendu après ~5s
    max_waiting_time: 120000   // 2min max avant considérer comme timeout
  },
  MTN_MOMO: {
    payment_validation: 900000, // 15min pour validation USSD
    webhook_delay: 7000,        // Premier webhook après ~7s
    max_waiting_time: 960000    // 16min max avant timeout
  }
};
async function waitForPaymentConfirmation(
  psp: 'ORANGE_MONEY' | 'MTN_MOMO',
  transactionId: string
): Promise<PaymentStatus> {
  const timeout = PSP_TIMEOUTS[psp].max_waiting_time;
  const startTime = Date.now();
  while (Date.now() - startTime < timeout) {
    const status = await checkTransactionStatus(psp, transactionId);
    if (status === 'SUCCESS') return 'SUCCESS';
    if (status === 'FAILED') return 'FAILED';
    // Attendre avant prochaine vérification
    await new Promise(resolve => setTimeout(resolve, 2000));
  }
  return 'TIMEOUT';
}

interface TransactionLimits {
  min_amount: number;
  max_amount: number;
  daily_max: number;
}
const PSP_LIMITS: Record<string, TransactionLimits> = {
  ORANGE_MONEY: {
    min_amount: 100,
    max_amount: 1000000,
    daily_max: 5000000
  },
  MTN_MOMO: {
    min_amount: 100,
    max_amount: 500000,
    daily_max: 2000000
  }
};
function selectPSPForAmount(
  amount: number,
  customerPSPPreference?: string
): string {
  // Vérifier si le montant dépasse les limites du PSP préféré
  if (customerPSPPreference) {
    const limits = PSP_LIMITS[customerPSPPreference];
    if (amount <= limits.max_amount) {
      return customerPSPPreference;
    }
  }
  // Sinon, router vers le PSP avec la limite la plus élevée
  if (amount > PSP_LIMITS.MTN_MOMO.max_amount) {
    return 'ORANGE_MONEY';
  }
  // Pour les montants compatibles avec les deux, choisir le moins cher
  return amount > 50000 ? 'MTN_MOMO' : 'ORANGE_MONEY';
}

Client → Simiz API → [Orange Money | MTN MoMo] → Client
                      ↓
                  Votre webhook

// Exemple de règles de routing configurables dans Simiz
interface RoutingRule {
  condition: (context: PaymentContext) => boolean;
  psp: 'ORANGE_MONEY' | 'MTN_MOMO';
  priority: number;
}
const SIMIZ_ROUTING_RULES: RoutingRule[] = [
  {
    // Préférence explicite du client
    condition: (ctx) => ctx.customerPreference !== null,
    psp: 'CUSTOMER_PREFERENCE',
    priority: 1
  },
  {
    // Montants > 500K FCFA → Orange (limite plus élevée)
    condition: (ctx) => ctx.amount > 500000,
    psp: 'ORANGE_MONEY',
    priority: 2
  },
  {
    // Optimisation tarifaire → MTN pour 50K-500K
    condition: (ctx) => ctx.amount >= 50000 && ctx.amount <= 500000,
    psp: 'MTN_MOMO',
    priority: 3
  },
  {
    // Fallback sur disponibilité
    condition: () => true,
    psp: 'LEAST_LOADED',
    priority: 4
  }
];

// Une seule interface pour tous les PSPs Sénégal
async function initiatePayment(params: {
  amount: number;
  currency: 'XOF';
  customer_phone: string;
  customer_email?: string;
  order_id: string;
}): Promise<{
  transaction_id: string;
  status: 'PENDING' | 'SUCCESS';
  payment_url?: string;
}> {
  const response = await fetch('https://api.simiz.io/v1/payments/initiate', {
    method: 'POST',
    headers: {
      'Authorization': Bearer ${SIMIZ_API_KEY},
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      ...params,
      country: 'SN',
      allowed_psps: ['ORANGE_MONEY', 'MTN_MOMO'],
      success_url: 'https://votre-site.com/payment/success',
      cancel_url: 'https://votre-site.com/payment/cancel',
      webhook_url: 'https://votre-site.com/webhooks/simiz'
    })
  });
  return response.json();
}