Leadify

// Webhook handler with retry logic
export async function POST(req: Request) {
  const signature = req.headers.get('x-coliix-signature')
  const payload = await req.json()

  // Verify signature
  if (!verifyWebhookSignature(payload, signature)) {
    return NextResponse.json({ error: 'Invalid signature' }, { status: 401 })
  }

  // Idempotency check
  const webhookId = payload.webhook_id
  const existing = await WebhookLog.findOne({ webhookId })
  if (existing) {
    return NextResponse.json({ message: 'Already processed' })
  }

  // Process with retry on failure
  try {
    await processTrackingUpdate(payload)
    await WebhookLog.create({ webhookId, status: 'success' })
  } catch (error) {
    // Add to retry queue
    await RetryQueue.create({
      webhookId,
      payload,
      attempts: 0,
      nextRetry: new Date(Date.now() + 60000) // 1 min
    })
  }

  return NextResponse.json({ success: true })
}

// Commission calculation engine
interface CommissionRule {
  type: 'percentage' | 'fixed' | 'tiered'
  value: number
  conditions?: {
    minAmount?: number
    maxAmount?: number
    productCategory?: string
  }
  priority: number
}

async function calculateCommission(
  parcel: IParcel,
  agent: IAgent
): Promise<number> {
  // Get applicable rules sorted by priority
  const rules = await CommissionRule.find({
    storeId: parcel.storeId,
    active: true
  }).sort({ priority: -1 })

  // Apply first matching rule
  for (const rule of rules) {
    if (matchesConditions(parcel, rule.conditions)) {
      const commission = applyRule(parcel, rule)

      // Audit trail
      await CommissionLog.create({
        parcelId: parcel._id,
        agentId: agent._id,
        ruleId: rule._id,
        amount: commission,
        calculation: {
          type: rule.type,
          value: rule.value,
          baseAmount: parcel.amount
        }
      })

      return commission
    }
  }

  return 0 // No matching rule
}