from fastapi import FastAPI, Request, HTTPException, status
import hmac
import hashlib
import json
from typing import Dict, Any

app = FastAPI()

# Store this securely (environment variable, secrets manager, etc.)
WEBHOOK_SECRET = "your_webhook_secret_here"

# Track processed events to prevent duplicates
processed_events: set[str] = set()

def verify_signature(body: bytes, signature: str, secret: str) -> bool:
    """Verify webhook signature."""
    expected_signature = hmac.new(
        secret.encode(),
        body,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(signature, expected_signature)

@app.post("/webhook")
async def handle_webhook(request: Request):
    # Get signature from header
    signature = request.headers.get("Decoda-Signature")
    if not signature:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Missing signature"
        )

    # Read request body
    body = await request.body()

    # Verify signature
    if not verify_signature(body, signature, WEBHOOK_SECRET):
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid signature"
        )

    # Parse event
    event = json.loads(body)
    event_id = event.get("id")
    event_type = event.get("type")
    event_data = event.get("data")

    # Check for duplicate events
    if event_id in processed_events:
        return {"status": "duplicate", "event_id": event_id}

    # Process event based on type
    try:
        if event_type == "PAYMENT_SUCCEEDED":
            # Handle payment completion
            payment_id = event_data.get("id")
            charge_id = event_data.get("charge_id")
            amount_cents = event_data.get("amount_cents")

            # Your business logic here
            print(f"Payment {payment_id} completed for charge {charge_id}: ${amount_cents/100}")

        elif event_type == "PLANNED_PAYMENT_FAILED":
            # Handle a failed payment-plan installment
            payment_id = event_data.get("id")
            failure_reason = event_data.get("failure_reason")

            # Your business logic here
            print(f"Planned payment {payment_id} failed: {failure_reason}")

        elif event_type == "PATIENT_CREATED":
            # Handle new patient
            patient_id = event_data.get("id")
            patient_name = f"{event_data.get('first_name')} {event_data.get('last_name')}"

            # Your business logic here
            print(f"New patient created: {patient_name} ({patient_id})")

        # Mark event as processed
        processed_events.add(event_id)

        return {"status": "success", "event_id": event_id}

    except Exception as e:
        # Log error but return 200 to prevent retries for application errors
        print(f"Error processing event {event_id}: {e}")
        return {"status": "error", "event_id": event_id}

import express, { Request, Response } from "express";
import crypto from "crypto";

const app = express();
app.use(express.json());

const WEBHOOK_SECRET = "your_webhook_secret_here";
const processedEvents = new Set<string>();

function verifySignature(body: string, signature: string, secret: string): boolean {
  const expectedSignature = crypto
    .createHmac("sha256", secret)
    .update(body)
    .digest("hex");
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignature)
  );
}

app.post("/webhook", (req: Request, res: Response) => {
  const signature = req.headers["decoda-signature"] as string;

  if (!signature) {
    return res.status(401).json({ error: "Missing signature" });
  }

  const body = JSON.stringify(req.body);

  if (!verifySignature(body, signature, WEBHOOK_SECRET)) {
    return res.status(401).json({ error: "Invalid signature" });
  }

  const event = req.body;
  const eventId = event.id;
  const eventType = event.type;
  const eventData = event.data;

  // Check for duplicates
  if (processedEvents.has(eventId)) {
    return res.json({ status: "duplicate", event_id: eventId });
  }

  try {
    switch (eventType) {
      case "PAYMENT_SUCCEEDED":
        console.log(
          `Payment ${eventData.id} completed for charge ${eventData.charge_id}: $${eventData.amount_cents / 100}`
        );
        break;

      case "PLANNED_PAYMENT_FAILED":
        console.log(
          `Planned payment ${eventData.id} failed: ${eventData.failure_reason}`
        );
        break;

      case "PATIENT_CREATED":
        console.log(
          `New patient created: ${eventData.first_name} ${eventData.last_name} (${eventData.id})`
        );
        break;
    }

    processedEvents.add(eventId);
    res.json({ status: "success", event_id: eventId });

  } catch (error) {
    console.error(`Error processing event ${eventId}:`, error);
    res.json({ status: "error", event_id: eventId });
  }
});

app.listen(3000, () => {
  console.log("Webhook server listening on port 3000");
});