from flask import Flask, request, jsonify
import hmac
import hashlib

app = Flask(__name__)
WEBHOOK_SECRET = "your-webhook-secret-key"

def verify_signature(payload, signature):
    expected_signature = hmac.new(
        WEBHOOK_SECRET.encode(),
        payload,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(signature, expected_signature)

@app.route('/webhooks/meetingbaas', methods=['POST'])
def webhook_handler():
    signature = request.headers.get('X-MeetingBaas-Signature')
    payload = request.get_data()
    
    if not verify_signature(payload, signature):
        return jsonify({"error": "Invalid signature"}), 401
    
    event_data = request.json
    
    if event_data['event'] == 'complete':
        # Handle meeting completion
        bot_id = event_data['data']['bot_id']
        transcript = event_data['data']['transcript']
        recording_url = event_data['data']['mp4']
        
        # Process the meeting data
        process_meeting_completion(bot_id, transcript, recording_url)
        
    elif event_data['event'] == 'failed':
        # Handle meeting failure
        bot_id = event_data['data']['bot_id']
        error = event_data['data']['error']
        message = event_data['data']['message']
        
        # Log the failure
        log_meeting_failure(bot_id, error, message)
    
    return jsonify({"status": "success"}), 200

def process_meeting_completion(bot_id, transcript, recording_url):
    # Your custom logic here
    print(f"Meeting {bot_id} completed")
    print(f"Recording available at: {recording_url}")

if __name__ == '__main__':
    app.run(debug=True, port=5000)

from fastapi import FastAPI, Request, HTTPException, Header
import hmac
import hashlib
from typing import Optional

app = FastAPI()
WEBHOOK_SECRET = "your-webhook-secret-key"

def verify_signature(payload: bytes, signature: str) -> bool:
    expected_signature = hmac.new(
        WEBHOOK_SECRET.encode(),
        payload,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(signature, expected_signature)

@app.post("/webhooks/meetingbaas")
async def webhook_handler(
    request: Request,
    x_meetingbaas_signature: Optional[str] = Header(None)
):
    payload = await request.body()
    
    if not x_meetingbaas_signature:
        raise HTTPException(status_code=401, detail="Missing signature")
    
    if not verify_signature(payload, x_meetingbaas_signature):
        raise HTTPException(status_code=401, detail="Invalid signature")
    
    event_data = await request.json()
    
    # Process different event types
    if event_data['event'] == 'complete':
        await handle_meeting_completion(event_data['data'])
    elif event_data['event'] == 'failed':
        await handle_meeting_failure(event_data['data'])
    elif event_data['event'] == 'transcription_complete':
        await handle_transcription_complete(event_data['data'])
    
    return {"status": "success"}

async def handle_meeting_completion(data):
    bot_id = data['bot_id']
    transcript = data['transcript']
    recording_url = data['mp4']
    
    # Your custom logic here
    print(f"Meeting {bot_id} completed")
    print(f"Recording available at: {recording_url}")

async def handle_meeting_failure(data):
    bot_id = data['bot_id']
    error = data['error']
    message = data['message']
    
    # Your custom logic here
    print(f"Meeting {bot_id} failed: {error} - {message}")

async def handle_transcription_complete(data):
    bot_id = data['bot_id']
    
    # Your custom logic here
    print(f"Transcription completed for meeting {bot_id}")