function getZoomAuthUrl() {
  const clientId = process.env.ZOOM_CLIENT_ID;
  const redirectUri = encodeURIComponent('https://yourapp.com/zoom/callback');

  return `https://zoom.us/oauth/authorize?response_type=code&client_id=${clientId}&redirect_uri=${redirectUri}`;
}

// In your route handler
app.get('/connect-zoom', (req, res) => {
  res.redirect(getZoomAuthUrl());
});

from urllib.parse import urlencode
from flask import redirect

def get_zoom_auth_url():
    client_id = os.environ['ZOOM_CLIENT_ID']
    redirect_uri = 'https://yourapp.com/zoom/callback'

    params = urlencode({
        'response_type': 'code',
        'client_id': client_id,
        'redirect_uri': redirect_uri
    })

    return f'https://zoom.us/oauth/authorize?{params}'

@app.route('/connect-zoom')
def connect_zoom():
    return redirect(get_zoom_auth_url())

app.get('/zoom/callback', async (req, res) => {
  const { code, state } = req.query;

  if (!code) {
    return res.status(400).send('Missing authorization code');
  }

  // Verify state if you used it
  if (state !== req.session.zoomCsrf) {
    return res.status(403).send('Invalid state parameter');
  }

  try {
    // Send to Meeting BaaS
    const connection = await createZoomConnection(code);

    // Store the zoom_user_id with your user
    await saveZoomConnection(req.user.id, connection.zoom_user_id);

    res.redirect('/dashboard?zoom_connected=true');
  } catch (error) {
    console.error('Zoom OAuth error:', error);
    res.redirect('/dashboard?zoom_error=true');
  }
});

@app.route('/zoom/callback')
def zoom_callback():
    code = request.args.get('code')
    state = request.args.get('state')

    if not code:
        return 'Missing authorization code', 400

    # Verify state if you used it
    if state != session.get('zoom_csrf'):
        return 'Invalid state parameter', 403

    try:
        # Send to Meeting BaaS
        connection = create_zoom_connection(code)

        # Store the zoom_user_id with your user
        save_zoom_connection(current_user.id, connection['zoom_user_id'])

        return redirect('/dashboard?zoom_connected=true')
    except Exception as e:
        print(f'Zoom OAuth error: {e}')
        return redirect('/dashboard?zoom_error=true')

async function createZoomConnection(authorizationCode) {
  const response = await fetch('https://api.meetingbaas.com/zoom_oauth_connections', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-meeting-baas-api-key': process.env.MEETING_BAAS_API_KEY,
    },
    body: JSON.stringify({
      authorization_code: authorizationCode,
      redirect_uri: 'https://yourapp.com/zoom/callback',
      zoom_client_id: process.env.ZOOM_CLIENT_ID,
      zoom_client_secret: process.env.ZOOM_CLIENT_SECRET,
    }),
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Failed to create connection: ${error.message}`);
  }

  return response.json();
}

import requests

def create_zoom_connection(authorization_code):
    response = requests.post(
        'https://api.meetingbaas.com/zoom_oauth_connections',
        headers={
            'Content-Type': 'application/json',
            'x-meeting-baas-api-key': os.environ['MEETING_BAAS_API_KEY'],
        },
        json={
            'authorization_code': authorization_code,
            'redirect_uri': 'https://yourapp.com/zoom/callback',
            'zoom_client_id': os.environ['ZOOM_CLIENT_ID'],
            'zoom_client_secret': os.environ['ZOOM_CLIENT_SECRET'],
        }
    )

    response.raise_for_status()
    return response.json()

async function createBot(meetingUrl, userId) {
  // Look up the user's zoom_user_id
  const zoomUserId = await getZoomUserIdForUser(userId);

  const response = await fetch('https://api.meetingbaas.com/bots', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-meeting-baas-api-key': process.env.MEETING_BAAS_API_KEY,
    },
    body: JSON.stringify({
      meeting_url: meetingUrl,
      bot_name: 'Recording Bot',
      zoom_obf_token_user_id: zoomUserId,
    }),
  });

  return response.json();
}

def create_bot(meeting_url, user_id):
    # Look up the user's zoom_user_id
    zoom_user_id = get_zoom_user_id_for_user(user_id)

    response = requests.post(
        'https://api.meetingbaas.com/bots',
        headers={
            'Content-Type': 'application/json',
            'x-meeting-baas-api-key': os.environ['MEETING_BAAS_API_KEY'],
        },
        json={
            'meeting_url': meeting_url,
            'bot_name': 'Recording Bot',
            'zoom_obf_token_user_id': zoom_user_id,
        }
    )

    return response.json()

async function getConnectionState(zoomUserId) {
  const connections = await fetch(
    'https://api.meetingbaas.com/zoom_oauth_connections',
    {
      headers: {
        'x-meeting-baas-api-key': process.env.MEETING_BAAS_API_KEY,
      },
    }
  ).then(r => r.json());

  const connection = connections.find(c => c.zoom_user_id === zoomUserId);
  return connection?.state || 'not_found';
}

// Before creating a bot
const state = await getConnectionState(user.zoomUserId);
if (state !== 'connected') {
  // Prompt user to reconnect
  return res.redirect('/connect-zoom');
}

def get_connection_state(zoom_user_id):
    response = requests.get(
        'https://api.meetingbaas.com/zoom_oauth_connections',
        headers={
            'x-meeting-baas-api-key': os.environ['MEETING_BAAS_API_KEY'],
        }
    )

    connections = response.json()
    connection = next(
        (c for c in connections if c['zoom_user_id'] == zoom_user_id),
        None
    )
    return connection['state'] if connection else 'not_found'

# Before creating a bot
state = get_connection_state(user.zoom_user_id)
if state != 'connected':
    # Prompt user to reconnect
    return redirect('/connect-zoom')