// Define CORS headers
const corsHeaders = {
  'Access-Control-Allow-Origin': '*',
  'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
  'Access-Control-Allow-Headers': 'Content-Type, Authorization, Accept',
  'Access-Control-Max-Age': '86400'
};

// Define pagination constants
const DEFAULT_PAGE_SIZE = 20;
const MAX_PAGE_SIZE = 100;

// Handle OPTIONS request for CORS preflight
function handleOptions() {
  return new Response(null, {
    headers: corsHeaders
  });
}

// Helper to create standardized responses
function createResponse(body, status = 200, cacheDuration = 60*60*24) {
  // Don't allow null or undefined body
  if (body === null || body === undefined) {
    console.error('createResponse called with null or undefined body');
    body = { error: 'Empty response body' };
    status = 500;
  }
  
  const headers = {
    'Content-Type': 'application/json',
    ...corsHeaders // Add CORS headers
  };
  
  if (cacheDuration > 0) {
    headers['Cache-Control'] = `public, max-age=${cacheDuration}`;
    headers['CDN-Cache-Control'] = `public, max-age=${cacheDuration}`;
  } else {
    headers['Cache-Control'] = 'no-store';
  }
  
  // Log the response details for debugging
  console.log(`Creating response: status=${status}, headers=${JSON.stringify(headers)}, body type=${typeof body}`);
  
  // Create a standard Response object
  // This ensures properties like 'ok' are properly set based on status code
  return new Response(JSON.stringify(body), {
    status,
    headers
  });
}

// Helper function to validate request parameters
function validateRequest(request, requiredParams = []) {
  const url = new URL(request.url);
  const missingParams = requiredParams.filter(param => !url.searchParams.has(param));
  
  if (missingParams.length > 0) {
    return createResponse({
      error: 'Missing required parameters',
      missing: missingParams
    }, 400);
  }
  
  return null;
}

// Helper function to get cache control headers
function getCacheControl(path) {
  const cacheRules = {
    '/api/health': 'public, max-age=3600',
    '/api/proposals': 'public, max-age=300, stale-while-revalidate=60',
    '/api/comments': 'public, max-age=60, stale-while-revalidate=30',
    default: 'no-cache'
  };
  
  return cacheRules[path] || cacheRules.default;
}

export default {
  async scheduled(event, env, ctx) {
    ctx.waitUntil(sendWeeklyDigest(env));
  },
  async fetch(request, env, ctx) {
    try {
      const url = new URL(request.url);
      const path = url.pathname;
      
      console.log(`Received request for path: ${path}`);
      console.log(`Full URL: ${url.toString()}`);

      // Handle CORS preflight requests
      if (request.method === 'OPTIONS') {
        return handleOptions();
      }

      // Set cache control headers based on path
      const cacheControl = getCacheControl(path);
      const headers = new Headers();
      headers.set('Cache-Control', cacheControl);

      // Handle static assets
      if (path === '/styles.css' || path === '/index.html' || path === '/') {
        console.log('Routing to static asset handler');
        return serveStaticAsset(request, env);
      }

      // Handle media files
      if (path.startsWith('/memes/') || path.startsWith('/audio/')) {
        return serveMedia(request, env);
      }

      // Handle API endpoints
      if (path.startsWith('/api/')) {
        try {
          // Validate request parameters for specific endpoints
          if (path === '/api/proposals' && request.method === 'GET') {
            const validationError = validateRequest(request, ['userId']);
            if (validationError) return validationError;
            return await getProposals(request, env);
          } else if (path === '/api/proposals' && request.method === 'POST') {
            return await createProposal(request, env);
          } else if (path === '/api/comments' && request.method === 'GET') {
            const validationError = validateRequest(request, ['proposalId']);
            if (validationError) return validationError;
            return await getComments(request, env);
          } else if (path === '/api/comments' && request.method === 'POST') {
            return await createComment(request, env);
          } else if (path === '/api/votes' && request.method === 'POST') {
            return await createOrUpdateVote(request, env);
          } else if (path === '/api/users' && request.method === 'POST') {
            return await createOrGetUser(request, env);
          } else if (path === '/api/memes' && request.method === 'POST') {
            return await uploadMeme(request, env);
          } else if (path === '/api/comment-votes' && request.method === 'POST') {
            return await createOrUpdateCommentVote(request, env);
          } else if (path === '/api/comment-votes' && request.method === 'GET') {
            return await getCommentVotes(request, env);
          } else if (path === '/api/leaderboard' && request.method === 'GET') {
            return await getLeaderboard(request, env);
          } else if (path === '/api/stats' && request.method === 'GET') {
            return await getSiteStats(request, env);
          } else if (path === '/api/email' && request.method === 'POST') {
            return await saveUserEmail(request, env);
          } else if (path === '/api/flag' && request.method === 'POST') {
            return await flagProposal(request, env);
          } else if (path === '/api/login' && request.method === 'POST') {
            return await validateLogin(request, env);
          } else if (path === '/api/join' && request.method === 'POST') {
            return await handleJoinMovement(request, env);
          } else if (path === '/api/petition-stats' && request.method === 'GET') {
            return await getPetitionStats(request, env);
          } else if (path === '/api/petition-svg' && request.method === 'GET') {
            return await servePetitionSVG(request, env);
          } else if (path === '/api/health' && request.method === 'GET') {
            return await healthCheck(env);
          } else if (path === '/api/debug-meta' && request.method === 'GET') {
            return await debugMetaTags(request, env);
          } else if (path.startsWith('/api/proposals/') && request.method === 'GET') {
            return await getProposalById(request, env);
          }
        } catch (error) {
          console.error('API Error:', error);
          return new Response(JSON.stringify({ error: 'Internal Server Error' }), {
            status: 500,
            headers: { 'Content-Type': 'application/json' },
          });
        }
      }

      // Return 404 for unknown routes
      return new Response('Not Found', { status: 404 });
    } catch (error) {
      console.error('Unhandled error:', error);
      return new Response('Internal Server Error', { status: 500 });
    }
  }
};

// ... existing code ...

// Handle media files (memes and audio)
async function serveMedia(request, env) {
  try {
    const url = new URL(request.url);
    const path = url.pathname;
    
    // Extract the filename from the path
    const filename = path.split('/').pop();
    
    // Determine the correct bucket based on the path
    const bucket = path.startsWith('/memes/') ? env.MEMES_BUCKET : env.AUDIO_BUCKET;
    
    if (!bucket) {
      console.error('Missing bucket binding');
      return new Response('Internal Server Error', { status: 500 });
    }
    
    // Get the object from R2
    const object = await bucket.get(filename);
    
    if (!object) {
      console.error(`File not found: ${filename}`);
      return new Response('File Not Found', { status: 404 });
    }
    
    // Determine content type based on file extension
    const contentType = path.endsWith('.mp3') ? 'audio/mpeg' : 'image/jpeg';
    
    // Create response with appropriate headers
    const headers = new Headers();
    headers.set('Content-Type', contentType);
    headers.set('Cache-Control', 'public, max-age=31536000'); // Cache for a year
    headers.set('Access-Control-Allow-Origin', '*');
    
    return new Response(object.body, {
      headers,
      status: 200
    });
  } catch (error) {
    console.error('Error serving media:', error);
    return new Response('Internal Server Error', { status: 500 });
  }
}

// Handle static assets
async function serveStaticAsset(request, env) {
  try {
    const url = new URL(request.url);
    const path = url.pathname;
    
    console.log(`Attempting to serve static asset: ${path}`);
    
    // Get the asset from the ASSETS binding
    const asset = await env.ASSETS.get(path.substring(1));
    
    if (!asset) {
      console.error(`Asset not found in bucket: ${path}`);
      return new Response('Asset Not Found', { status: 404 });
    }
    
    console.log(`Asset found, size: ${asset.size} bytes`);
    
    // Determine content type based on file extension
    let contentType = 'text/plain';
    if (path.endsWith('.css')) {
      contentType = 'text/css';
    } else if (path.endsWith('.js')) {
      contentType = 'application/javascript';
    } else if (path.endsWith('.html')) {
      contentType = 'text/html';
    }
    
    console.log(`Content type set to: ${contentType}`);
    
    // Create response with appropriate headers
    const headers = new Headers();
    headers.set('Content-Type', contentType);
    headers.set('Cache-Control', 'public, max-age=31536000'); // 1 year cache
    headers.set('Access-Control-Allow-Origin', '*');
    
    // Get the asset body as text
    const body = await asset.text();
    
    return new Response(body, {
      headers,
      status: 200
    });
  } catch (error) {
    console.error('Error serving static asset:', error);
    return new Response('Internal Server Error', { status: 500 });
  }
}

// ... existing code ...

async function serveMainPage(request, env) {
  try {
    // Fetch directly from Cloudflare Pages
    const response = await fetch('https://radical.pages.dev/index.html', {
      headers: {
        'User-Agent': request.headers.get('User-Agent') || 'Cloudflare Worker'
      }
    });
    
    if (!response.ok) {
      console.error('Failed to fetch main page', response.status, response.statusText);
      return new Response('Failed to load page', { status: 500 });
    }
    
    // Read the HTML content
    const html = await response.text();
    
    // Create a new response with the HTML content
    return new Response(html, {
      status: 200,
      headers: {
        'Content-Type': 'text/html',
        'Cache-Control': 'public, max-age=86400',
        // Add CORS headers if needed
        'Access-Control-Allow-Origin': '*'
      }
    });
  } catch (error) {
    console.error('Comprehensive error serving main page:', error);
    return new Response(`Internal Server Error: ${error.message}`, { status: 500 });
  }
}

async function serveLoginPage(request, env) {
  try {
    // Fetch the login HTML file from your storage
    // You could store this in R2 bucket or GitHub Pages like your other static files
    const response = await fetch('https://radical.pages.dev/radical/login.html', {
      headers: {
        'User-Agent': request.headers.get('User-Agent') || 'Cloudflare Worker'
      }
    });
    
    if (!response.ok) {
      console.error('Failed to fetch login page', response.status, response.statusText);
      return new Response('Failed to load login page', { status: 500 });
    }
    
    // Read the HTML content
    const html = await response.text();
    
    // Create a new response with the HTML content
    return new Response(html, {
      status: 200,
      headers: {
        'Content-Type': 'text/html',
        'Cache-Control': 'public, max-age=86400',
        'Access-Control-Allow-Origin': '*'
      }
    });
  } catch (error) {
    console.error('Error serving login page:', error);
    return new Response(`Internal Server Error: ${error.message}`, { status: 500 });
  }
}

// Function to validate user login with emoji combination and selections
async function validateLogin(request, env) {
  try {
    const data = await request.json();
    const { 
      emojiCombination, 
      selectedDictator, 
      selectedTarget 
    } = data;
    
    console.log(`Processing login attempt: ${JSON.stringify({
      emojiCount: emojiCombination?.length || 0,
      dictator: selectedDictator,
      target: selectedTarget
    })}`);
    
    // Basic validation
    if (!emojiCombination || !selectedDictator || !selectedTarget) {
      return createResponse({ 
        error: 'Missing required fields', 
        received: { 
          hasEmojis: !!emojiCombination, 
          hasDictator: !!selectedDictator, 
          hasTarget: !!selectedTarget 
        } 
      }, 400);
    }
    
    // Convert emoji array to string for storage/comparison
    const emojiCombinationString = Array.isArray(emojiCombination) 
      ? emojiCombination.join('') 
      : emojiCombination;
    
    // Check if dictator exists
    const dictatorCheck = await env.DB.prepare(
      `SELECT id FROM dictators WHERE id = ?`
    ).bind(selectedDictator).first();
    
    if (!dictatorCheck) {
      return createResponse({ 
        error: 'Invalid dictator selection', 
        dictatorId: selectedDictator 
      }, 400);
    }
    
    // Check if target exists
    const targetCheck = await env.DB.prepare(
      `SELECT id FROM time_targets WHERE id = ?`
    ).bind(selectedTarget).first();
    
    if (!targetCheck) {
      return createResponse({ 
        error: 'Invalid time target selection', 
        targetId: selectedTarget 
      }, 400);
    }
    
    // Record the login attempt (for security tracking)
    const attemptId = 'login_' + Date.now() + '_' + Math.random().toString(36).substr(2, 5);
    const timestamp = Date.now();
    const clientIP = request.headers.get('CF-Connecting-IP') || 'unknown';
    
    try {
      // Try to find a user with the exact combination
      const user = await env.DB.prepare(`
        SELECT id, name, emoji_combination, selected_dictator_id, selected_target_id 
        FROM users 
        WHERE emoji_combination = ? 
        AND selected_dictator_id = ? 
        AND selected_target_id = ?
      `).bind(
        emojiCombinationString, 
        selectedDictator, 
        selectedTarget
      ).first();
      
      // Log the attempt, regardless of outcome
      await env.DB.prepare(`
        INSERT INTO login_attempts (
          id, 
          user_id, 
          emoji_combination, 
          dictator_id, 
          target_id, 
          timestamp, 
          ip_address, 
          success
        )
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
      `).bind(
        attemptId,
        user ? user.id : null,
        emojiCombinationString,
        selectedDictator,
        selectedTarget,
        timestamp,
        clientIP,
        user ? 1 : 0
      ).run();
      
      if (user) {
        // Login successful - Update last login time
        await env.DB.prepare(`
          UPDATE users 
          SET last_login = ? 
          WHERE id = ?
        `).bind(timestamp, user.id).run();
        
        console.log(`Successful login for user ${user.id}`);
        
        // Return success with user info (excluding sensitive data)
        return createResponse({
          success: true,
          userId: user.id,
          username: user.name,
          message: "Login successful"
        });
      } else {
        // No matching user found - this could be a new signup
        // Check if this is a unique emoji combination
        const existingCombo = await env.DB.prepare(`
          SELECT COUNT(*) as count
          FROM users
          WHERE emoji_combination = ?
        `).bind(emojiCombinationString).first();
        
        if (existingCombo.count > 0) {
          // Emoji combination exists but other parameters don't match
          return createResponse({
            error: "Invalid credentials",
            message: "The combination you entered is incorrect"
          }, 401);
        }
        
        // This is a new user registration
        const newUserId = 'citizen_' + Math.random().toString(36).substr(2, 9);
        const newUsername = 'Citizen ' + Math.floor(Math.random() * 9000 + 1000);
        
        // Create the new user
        await env.DB.prepare(`
          INSERT INTO users (
            id, 
            name, 
            created_at, 
            emoji_combination, 
            selected_dictator_id, 
            selected_target_id,
            last_login
          )
          VALUES (?, ?, ?, ?, ?, ?, ?)
        `).bind(
          newUserId,
          newUsername,
          timestamp,
          emojiCombinationString,
          selectedDictator,
          selectedTarget,
          timestamp
        ).run();
        
        console.log(`Created new user ${newUserId} with emoji login`);
        
        // Return success with new user info
        return createResponse({
          success: true,
          isNewUser: true,
          userId: newUserId,
          username: newUsername,
          message: "Account created successfully"
        });
      }
    } catch (dbError) {
      console.error('Database error during login validation:', dbError);
      
      return createResponse({
        error: "Login processing error",
        details: "An error occurred while processing your login"
      }, 500);
    }
  } catch (error) {
    console.error('Error in login validation:', error);
    
    return createResponse({
      error: "Login request error",
      message: "Could not process login request"
    }, 500);
  }
}

async function createOrUpdateCommentVote(request, env) {
  try {
    const data = await request.json();
    const { commentId, userId, voteType } = data;
    
    console.log(`Processing comment vote: ${JSON.stringify({
      commentId, 
      userId, 
      voteType
    })}`);
    
    if (!commentId || !userId || !voteType) {
      return createResponse({ 
        error: 'Missing required fields', 
        received: { commentId, userId, voteType: voteType || 'undefined' } 
      }, 400);
    }
    
    if (voteType !== 'upvote' && voteType !== 'downvote') {
      return createResponse({ 
        error: 'Invalid vote type', 
        voteType, 
        allowedValues: ['upvote', 'downvote'] 
      }, 400);
    }
    
    // Check if entities exist
    try {
      const userCheck = await env.DB.prepare(`SELECT id FROM users WHERE id = ?`).bind(userId).first();
      if (!userCheck) {
        return createResponse({ error: 'User does not exist', userId }, 404);
      }
      
      const commentCheck = await env.DB.prepare(`SELECT id FROM comments WHERE id = ?`).bind(commentId).first();
      if (!commentCheck) {
        return createResponse({ error: 'Comment does not exist', commentId }, 404);
      }
    } catch (checkError) {
      return createResponse({ 
        error: 'Error checking user or comment existence', 
        details: logError(checkError, { action: 'check_entities', userId, commentId })
      }, 500);
    }
    
    // Check if vote already exists
    let existingVote;
    try {
      const checkQuery = `
        SELECT id, vote_type FROM comment_votes
        WHERE comment_id = ? AND user_id = ?
      `;
      
      existingVote = await env.DB.prepare(checkQuery).bind(commentId, userId).first();
      console.log(`Existing comment vote check: ${existingVote ? JSON.stringify(existingVote) : 'None found'}`);
    } catch (voteCheckError) {
      return createResponse({ 
        error: 'Error checking existing comment vote', 
        details: logError(voteCheckError, { action: 'check_comment_vote', userId, commentId })
      }, 500);
    }
    
    const timestamp = Date.now();
    const voteId = existingVote ? existingVote.id : 'comment_vote_' + Date.now() + '_' + Math.random().toString(36).substr(2, 5);
    
    try {
      // Process vote
      if (existingVote) {
        // If vote exists and it's the same type, remove it (toggle off)
        if (existingVote.vote_type === voteType) {
          await env.DB.prepare(`
            DELETE FROM comment_votes
            WHERE id = ?
          `).bind(existingVote.id).run();
          
          console.log(`Deleted comment vote ${existingVote.id} (toggle off)`);
          
          return createResponse({ 
            commentId, 
            userId, 
            voteType: null,
            action: 'removed'
          });
        } else {
          // If vote exists but is different type, update it
          await env.DB.prepare(`
            UPDATE comment_votes
            SET vote_type = ?, timestamp = ?
            WHERE id = ?
          `).bind(
            voteType, 
            timestamp, 
            existingVote.id
          ).run();
          
          console.log(`Updated comment vote ${existingVote.id} to ${voteType}`);
          
          return createResponse({ 
            commentId, 
            userId, 
            voteType,
            action: 'updated'
          });
        }
      } else {
        // If no vote exists, create new one
        await env.DB.prepare(`
          INSERT INTO comment_votes (id, comment_id, user_id, vote_type, timestamp)
          VALUES (?, ?, ?, ?, ?)
        `).bind(
          voteId, 
          commentId, 
          userId, 
          voteType, 
          timestamp
        ).run();
        
        console.log(`Created new comment vote with ID: ${voteId}`);
        
        return createResponse({ 
          commentId, 
          userId, 
          voteType,
          action: 'created'
        });
      }
    } catch (dbError) {
      return createResponse({ 
        error: 'Failed to process comment vote in database', 
        details: logError(dbError, { 
          action: 'process_comment_vote', 
          existingVote: existingVote || null,
          newVote: { commentId, userId, voteType }
        })
      }, 500);
    }
  } catch (error) {
    return createResponse({ 
      error: 'Failed to process comment vote request', 
      details: logError(error, { action: 'comment_vote_outer' })
    }, 500);
  }
}

// Function to get votes for a specific comment
async function getCommentVotes(request, env) {
  try {
    const url = new URL(request.url);
    const commentId = url.searchParams.get('commentId');
    const userId = url.searchParams.get('userId');
    
    if (!commentId) {
      return createResponse({ error: 'Missing commentId parameter' }, 400);
    }
    
    // Get vote counts
    const query = `
      SELECT 
        (SELECT COUNT(*) FROM comment_votes WHERE comment_id = ? AND vote_type = 'upvote') as upvotes,
        (SELECT COUNT(*) FROM comment_votes WHERE comment_id = ? AND vote_type = 'downvote') as downvotes
    `;
    
    try {
      const voteCounts = await env.DB.prepare(query).bind(commentId, commentId).first();
      
      let userVote = null;
      // If userId is provided, get the user's vote
      if (userId) {
        const userVoteQuery = `
          SELECT vote_type FROM comment_votes
          WHERE comment_id = ? AND user_id = ?
        `;
        
        const userVoteResult = await env.DB.prepare(userVoteQuery).bind(commentId, userId).first();
        if (userVoteResult) {
          userVote = userVoteResult.vote_type;
        }
      }
      
      return createResponse({
        commentId,
        upvotes: voteCounts.upvotes || 0,
        downvotes: voteCounts.downvotes || 0,
        userVote
      });
    } catch (dbError) {
      return createResponse({
        error: 'Failed to retrieve comment votes',
        details: logError(dbError, { action: 'get_comment_votes', commentId })
      }, 500);
    }
  } catch (error) {
    return createResponse({
      error: 'Failed to process comment votes request',
      details: logError(error, { action: 'get_comment_votes_outer' })
    }, 500);
  }
}



// Serve meme files
async function serveMeme(request, env) {
  const url = new URL(request.url);
  const path = url.pathname;
  const key = path.replace('/memes/', '');
  
  // Handle CORS preflight requests
  if (request.method === 'OPTIONS') {
    return handleOptions();
  }
  
  try {
    const object = await env.MEMES_BUCKET.get(key);
    
    if (object === null) {
      return new Response('Meme not found', { status: 404 });
    }
    
    const headers = new Headers();
    object.writeHttpMetadata(headers);
    headers.set('etag', object.httpEtag);
    headers.set('Cache-Control', 'public, max-age=31536000'); // Cache for a year
    
    // Add CORS headers
    Object.keys(corsHeaders).forEach(key => {
      headers.set(key, corsHeaders[key]);
    });
    
    return new Response(object.body, {
      headers
    });
  } catch (error) {
    console.error('Error serving meme:', error);
    return new Response('Internal Server Error', { status: 500 });
  }
}

// Debug endpoint to help diagnose meta tag issues
async function debugMetaTags(request, env) {
  try {
    // Create a sample proposal for testing
    const testProposal = {
      id: 'test_proposal',
      text: 'This is a test proposal for meta tags',
      author_name: 'Test User',
      timestamp: Date.now()
    };
    
    // Generate a shareable image URL
    const shareImageUrl = getShareableImageUrl(testProposal);
    
    // Prepare detailed meta tag information
    const metaTagInfo = {
      og_image: shareImageUrl,
      og_title: 'RADICAL Meta Tag Test',
      og_description: 'Testing meta tag generation and injection',
      twitter_image: shareImageUrl,
      twitter_title: 'RADICAL Meta Tag Verification',
      twitter_description: 'Checking social media sharing metadata'
    };
    
    // Return detailed information about the meta tags
    return createResponse({
      status: 'success',
      message: 'Meta tag debug information',
      shareImageUrl: shareImageUrl,
      metaTagDetails: metaTagInfo
    });
  } catch (error) {
    return createResponse({ 
      error: 'Debug meta tags endpoint error', 
      details: logError(error, { action: 'debug_meta_tags' })
    }, 500);
  }
}

// Handle meme uploads to R2 storage
async function uploadMeme(request, env) {
  try {
    // Check if R2 binding exists
    if (!env.MEMES_BUCKET) {
      return createResponse({ 
        error: 'Storage binding missing. Check your settings configuration.' 
      }, 500);
    }

    // Handle multipart form data
    const formData = await request.formData();
    
    // Get the proposal ID
    const proposalId = formData.get('proposalId');
    if (!proposalId) {
      return createResponse({ error: 'Missing proposalId' }, 400);
    }
    
    // Get the file
    const file = formData.get('meme');
    if (!file || !(file instanceof File)) {
      return createResponse({ error: 'No file uploaded or invalid file' }, 400);
    }
    
    // Validate file type
    const validTypes = ['image/jpeg', 'image/png', 'image/gif', 'image/webp'];
    if (!validTypes.includes(file.type)) {
      return createResponse({ 
        error: 'Invalid file type. Only JPEG, PNG, GIF, and WebP images are allowed.',
        received: file.type
      }, 400);
    }
    
    // Validate file size (limit to 2MB)
    const MAX_SIZE = 2 * 1024 * 1024; // 2MB
    if (file.size > MAX_SIZE) {
      return createResponse({ 
        error: 'File too large. Maximum size is 2MB.',
        size: file.size,
        maxSize: MAX_SIZE
      }, 400);
    }
    
    // Create a unique filename
    const fileExt = file.name.split('.').pop();
    const uniqueFilename = `${proposalId}_${Date.now()}.${fileExt}`;
    
    // Upload to R2
    await env.MEMES_BUCKET.put(uniqueFilename, file.stream(), {
      httpMetadata: {
        contentType: file.type,
      },
    });
    
    // Generate the public URL
    const memeUrl = `https://theradicalparty.com/memes/${uniqueFilename}`;
    
    // Helper function to fix broken meme URLs
    function fixMemeUrl(url) {
      // Check if the URL contains the problematic domain
      if (url && url.includes('memes.undefined')) {
        // Extract the filename from the URL
        const filename = url.split('/').pop();
        // Replace with the correct domain
        return `https://theradicalparty.com/memes/${filename}`;
      }
      return url;
    }

    // Update the proposal with the meme URL
    try {
      await env.DB.prepare(`
        UPDATE proposals
        SET meme_url = ?
        WHERE id = ?
      `).bind(memeUrl, proposalId).run();
      
      console.log(`Added meme ${uniqueFilename} to proposal ${proposalId}`);
      
      return createResponse({ 
        success: true, 
        proposalId, 
        memeUrl 
      });
    } catch (dbError) {
      // If DB update fails, try to delete the uploaded file
      try {
        await env.MEMES_BUCKET.delete(uniqueFilename);
      } catch (deleteError) {
        console.error('Failed to delete orphaned file:', deleteError);
      }
      
      return createResponse({ 
        error: 'Failed to update proposal with meme URL', 
        details: logError(dbError, { action: 'update_proposal_meme', proposalId })
      }, 500);
    }
  } catch (error) {
    return createResponse({ 
      error: 'Failed to process meme upload', 
      details: logError(error, { action: 'upload_meme' })
    }, 500);
  }
}

// Get petition statistics
async function getPetitionStats(request, env) {
  try {
    const url = new URL(request.url);
    const proposalId = url.searchParams.get('proposalId');
    
    if (!proposalId) {
      return createResponse({ error: 'Missing proposalId parameter' }, 400);
    }
    
    // Get petition statistics
    const statsQuery = `
      SELECT 
        COUNT(DISTINCT pd.user_id) as verified_count,
        (SELECT COUNT(*) FROM votes WHERE proposal_id = ? AND vote_type = 'upvote' AND is_petition = 1) as total_signatures,
        (SELECT text FROM proposals WHERE id = ?) as proposal_text
      FROM petition_details pd
      WHERE pd.proposal_id = ? AND pd.verified = 1
    `;
    
    const stats = await env.DB.prepare(statsQuery).bind(proposalId, proposalId, proposalId).first();
    
    if (!stats) {
      return createResponse({ error: 'Proposal not found' }, 404);
    }
    
    // Get top postcodes for this petition
    const postcodesQuery = `
      SELECT postcode, COUNT(*) as count
      FROM petition_details
      WHERE proposal_id = ? AND verified = 1
      GROUP BY postcode
      ORDER BY count DESC
      LIMIT 5
    `;
    
    const postcodes = await env.DB.prepare(postcodesQuery).bind(proposalId).all();
    
    return createResponse({
      proposalId,
      proposalText: stats.proposal_text,
      verifiedSignatures: stats.verified_count,
      totalSignatures: stats.total_signatures,
      topPostcodes: postcodes.results
    });
  } catch (error) {
    return createResponse({ 
      error: 'Failed to process petition stats request', 
      details: logError(error, { action: 'petition_stats', proposalId })
    }, 500);
  }
}

// Helper to log detailed errors 
function logError(error, context = {}) {
  const errorDetails = {
    message: error.message,
    stack: error.stack,
    name: error.name,
    context: context
  };
  
  console.error(JSON.stringify(errorDetails));
  return errorDetails;
}

// Function to check if a table exists
async function tableExists(env, tableName) {
  try {
    const query = "SELECT name FROM sqlite_master WHERE type='table' AND name = ?";
    const result = await env.DB.prepare(query).bind(tableName).first();
    return !!result;
  } catch (error) {
    logError(error, { action: 'check_table_exists', tableName });
    return false;
  }
}

// Simple health check endpoint
async function healthCheck(env) {
  try {
    // Check if DB binding exists
    if (!env.DB) {
      return createResponse({ 
        status: 'error', 
        error: 'Database binding missing. Check wrangler.toml configuration.'
      }, 500);
    }
    
    // Check if we can execute a simple query
    try {
      const result = await env.DB.prepare("SELECT 1 as db_check").first();
      if (!result || result.db_check !== 1) {
        return createResponse({ 
          status: 'error', 
          error: 'Database query failed to return expected result'
        }, 500);
      }
    } catch (dbError) {
      return createResponse({ 
        status: 'error', 
        error: 'Database query execution failed',
        details: logError(dbError, { action: 'health_check_query' })
      }, 500);
    }
    
    // Check if required tables exist
    const tables = ['users', 'proposals', 'votes', 'petition_details'];
    const tableStatus = {};
    
    for (const table of tables) {
      tableStatus[table] = await tableExists(env, table);
    }
    
    const missingTables = Object.keys(tableStatus).filter(table => !tableStatus[table]);
    
    if (missingTables.length > 0) {
      return createResponse({ 
        status: 'warning', 
        message: 'Database connected but some tables are missing',
        missingTables,
        tableStatus
      }, 200);
    }
    
    return createResponse({ 
      status: 'ok', 
      message: 'Database connection and tables verified',
      database: env.DB.name || 'unknown',
      tableStatus
    }, 200);
  } catch (error) {
    return createResponse({ 
      status: 'error', 
      error: 'Health check failed',
      details: logError(error, { action: 'health_check' })
    }, 500);
  }
}

// Get proposals with optional sorting
async function getProposals(request, env) {
  try {
    // Define pagination constants locally to ensure they're in scope
    const DEFAULT_PAGE_SIZE = 20;
    const MAX_PAGE_SIZE = 100;
    
    const url = new URL(request.url);
    const page = parseInt(url.searchParams.get('page')) || 1;
    const limit = Math.min(
      parseInt(url.searchParams.get('limit')) || DEFAULT_PAGE_SIZE,
      MAX_PAGE_SIZE
    );
    const offset = (page - 1) * limit;
    const sortBy = url.searchParams.get('sortBy') || 'newest';
    const userId = url.searchParams.get('userId') || '';

    console.log(`Getting proposals with sorting: ${sortBy}, page: ${page}, limit: ${limit}`);

    let query = `
      SELECT
        p.id, p.text, p.timestamp, p.trending, p.meme_url, p.flag_count,
        u.name as author_name, u.id as author_id,
        (SELECT COUNT(*) FROM votes WHERE proposal_id = p.id AND vote_type = 'upvote') as upvotes,
        (SELECT COUNT(*) FROM votes WHERE proposal_id = p.id AND vote_type = 'downvote') as downvotes,
        (SELECT COUNT(*) FROM votes WHERE proposal_id = p.id AND vote_type = 'upvote' AND is_petition = 1) as petition_signatures,
        (SELECT COUNT(DISTINCT pd.user_id) FROM petition_details pd WHERE pd.proposal_id = p.id AND pd.verified = 1) as verified_petitioners,
        (SELECT vote_type FROM votes WHERE proposal_id = p.id AND user_id = ?) as user_vote,
        (SELECT COUNT(DISTINCT u2.postcode) FROM votes v2 JOIN users u2 ON v2.user_id = u2.id WHERE v2.proposal_id = p.id AND v2.vote_type = 'upvote' AND u2.postcode IS NOT NULL) as postcode_count
      FROM proposals p
      JOIN users u ON p.author_id = u.id
      WHERE (p.hidden = 0 OR p.hidden IS NULL)
    `;

    if (sortBy === 'newest') {
      query += ` ORDER BY p.timestamp DESC`;
    } else if (sortBy === 'oldest') {
      query += ` ORDER BY p.timestamp ASC`;
    } else if (sortBy === 'popular') {
      query += ` ORDER BY upvotes DESC, p.timestamp DESC`;
    } else if (sortBy === 'controversial') {
      query += ` ORDER BY (upvotes + downvotes) DESC, ABS(upvotes - downvotes) ASC, p.timestamp DESC`;
    } else {
      query += ` ORDER BY p.timestamp DESC`;
    }

    query += ` LIMIT ? OFFSET ?`;

    console.log(`Executing query with pagination: limit=${limit}, offset=${offset}`);

    const proposals = await env.DB.prepare(query).bind(userId, limit, offset).all();

    // Normalise snake_case → camelCase for the frontend
    if (proposals.results) {
      proposals.results.forEach(p => { p.userVote = p.user_vote; });
    }
    
    console.log(`Retrieved ${proposals.results?.length || 0} proposals`);
    
    // Add pagination info to response
    return createResponse({
      data: proposals.results,
      pagination: {
        page,
        limit,
        total: proposals.results?.length || 0,
        hasMore: proposals.results?.length === limit
      }
    }, 200, 0);
  } catch (error) {
    console.error('Error retrieving proposals:', error);
    return createResponse({ 
      error: 'Failed to retrieve proposals', 
      details: logError(error, { action: 'get_proposals' })
    }, 500);
  }
}

// Get a single proposal by ID
async function getProposalById(request, env) {
  try {
    const url = new URL(request.url);
    const proposalId = url.pathname.split('/api/proposals/')[1];
    const userId = url.searchParams.get('userId');
    
    if (!proposalId) {
      return createResponse({ error: 'Missing proposal ID' }, 400);
    }
    
    console.log(`Getting proposal with ID: ${proposalId}`);
    
    let query = `
      SELECT 
        p.id, p.text, p.timestamp, p.trending, p.meme_url,
        u.name as author_name, u.id as author_id,
        (SELECT COUNT(*) FROM votes WHERE proposal_id = p.id AND vote_type = 'upvote') as upvotes,
        (SELECT COUNT(*) FROM votes WHERE proposal_id = p.id AND vote_type = 'downvote') as downvotes,
        (SELECT COUNT(*) FROM votes WHERE proposal_id = p.id AND vote_type = 'upvote' AND is_petition = 1) as petition_signatures,
        (SELECT COUNT(DISTINCT pd.user_id) FROM petition_details pd WHERE pd.proposal_id = p.id AND pd.verified = 1) as verified_petitioners
      FROM proposals p
      JOIN users u ON p.author_id = u.id
      WHERE p.id = ?
    `;
    
    try {
      const proposal = await env.DB.prepare(query).bind(proposalId).first();
      
      if (!proposal) {
        return createResponse({ error: 'Proposal not found' }, 404);
      }
      
      // If we have a userId, get their votes for this proposal
      if (userId) {
        try {
          const votesQuery = `
            SELECT proposal_id, vote_type, is_petition
            FROM votes
            WHERE user_id = ? AND proposal_id = ?
          `;
          
          const vote = await env.DB.prepare(votesQuery).bind(userId, proposalId).first();
          
          if (vote) {
            proposal.userVote = vote.vote_type;
            proposal.userPetitionSigned = vote.is_petition === 1;
          } else {
            proposal.userVote = null;
            proposal.userPetitionSigned = false;
          }
          
          // Also get petition details status
          const petitionQuery = `
            SELECT proposal_id, verified
            FROM petition_details
            WHERE user_id = ? AND proposal_id = ?
          `;
          
          const petition = await env.DB.prepare(petitionQuery).bind(userId, proposalId).first();
          
          if (petition) {
            proposal.userPetitionVerified = petition.verified === 1;
          } else {
            proposal.userPetitionVerified = false;
          }
        } catch (voteError) {
          // Just log the error but continue - we'll return the proposal without vote data
          logError(voteError, { 
            action: 'get_user_votes', 
            userId, 
            proposalId 
          });
          console.log('Warning: Failed to retrieve user votes, continuing without vote data');
        }
      }
      
      return createResponse(proposal);
    } catch (dbError) {
      return createResponse({ 
        error: 'Failed to retrieve proposal', 
        details: logError(dbError, { action: 'get_proposal_by_id', proposalId, query })
      }, 500);
    }
  } catch (error) {
    return createResponse({ 
      error: 'Failed to process proposal request', 
      details: logError(error, { action: 'get_proposal_by_id_outer' })
    }, 500);
  }
}

async function generateAndStoreShareImage(proposal, env) {
  try {
    // Check if we have the necessary bindings
    if (!env.MEMES_BUCKET) {
      console.error('Missing MEMES_BUCKET binding');
      return null;
    }
    
    // Get base text for the image
    const text = proposal.text || "Unknown petition";
    const authorName = proposal.author_name || "Anonymous";
    
    // Instead of using Cloudinary, let's use our SVG generation which we know works
    const imageId = `share_${proposal.id}`;
    const fallbackImageUrl = "https://theradicalparty.com/memes/petition-template.png";
    
    // Create a simple text-based SVG directly
    const svgMarkup = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1200 630" width="1200" height="630">
      <rect width="1200" height="630" fill="#000000" />
      <rect x="20" y="20" width="1160" height="590" fill="#111111" stroke="#ff0099" stroke-width="2" />
      <text x="600" y="100" font-family="Arial, sans-serif" font-size="60" fill="#ff0099" text-anchor="middle">RADICAL</text>
      <text x="600" y="180" font-family="Arial, sans-serif" font-size="40" fill="#ffffff" text-anchor="middle" width="1000">${text.substring(0, 80)}</text>
      <text x="600" y="550" font-family="Arial, sans-serif" font-size="24" fill="#aaaaaa" text-anchor="middle">by ${authorName}</text>
    </svg>`;
    
    // Convert SVG to a blob
    const svgBlob = new Blob([svgMarkup], { type: 'image/svg+xml' });
    
    // Upload the SVG to R2
    try {
      await env.MEMES_BUCKET.put(imageId, svgBlob, {
        httpMetadata: {
          contentType: 'image/svg+xml',
        },
      });
      
      // Generate the public URL for the stored image
      const shareImageUrl = `https://theradicalparty.com/memes/${imageId}`;
      console.log(`Created share image at: ${shareImageUrl}`);
      return shareImageUrl;
    } catch (uploadError) {
      console.error('Error uploading share image:', uploadError);
      return fallbackImageUrl;
    }
  } catch (error) {
    console.error('Error in share image generation:', error);
    // Return a fallback image URL in case of failure
    return "https://theradicalparty.com/memes/petition-template.png";
  }
}

// Create a new proposal
async function createProposal(request, env) {
  try {
    // Log request details for debugging
    console.log(`Received proposal creation request at ${Date.now()}`);
    
    // Check if DB binding exists
    if (!env.DB) {
      console.error('Database binding is missing');
      return createResponse({ 
        error: 'Database configuration error', 
        details: 'Database binding is not available' 
      }, 500);
    }

    // Parse request data
    let data;
    try {
      data = await request.json();
      console.log(`Parsed request data: ${JSON.stringify(data)}`);
    } catch (parseError) {
      console.error('Failed to parse request JSON:', parseError);
      return createResponse({ 
        error: 'Invalid request format', 
        details: 'Could not parse JSON body' 
      }, 400);
    }
    
    const { text, authorId, trending = false } = data;
    
    // Validate required fields
    if (!text || !authorId) {
      console.error('Missing required fields:', { text: !!text, authorId: !!authorId });
      return createResponse({ 
        error: 'Missing required fields', 
        received: { text: text ? 'present' : 'missing', authorId: authorId ? 'present' : 'missing' } 
      }, 400);
    }
    
    // Check if user exists first
    try {
      console.log(`Checking if user exists: ${authorId}`);
      const userCheck = await env.DB.prepare(`SELECT id, name FROM users WHERE id = ?`).bind(authorId).first();
      
      if (!userCheck) {
        console.error(`User not found: ${authorId}`);
        return createResponse({ 
          error: 'Author does not exist', 
          authorId,
          suggestion: 'Create the user first before posting a proposal' 
        }, 400);
      }
      
      console.log(`User found: ${userCheck.id}, ${userCheck.name}`);
      
      // Create a temporary proposal object with author name for image generation
      const id = 'proposal_' + Date.now() + '_' + Math.random().toString(36).substr(2, 5);
      const timestamp = Date.now();
      
      console.log(`Generated proposal ID: ${id}`);
      
      // Create temporary proposal object
      const tempProposal = {
        id: id,
        text: text,
        author_name: userCheck.name
      };
      
      // Insert the proposal first
      console.log('Inserting proposal into database');
      const query = `
        INSERT INTO proposals (id, author_id, text, timestamp, trending)
        VALUES (?, ?, ?, ?, ?)
      `;
      
      try {
        await env.DB.prepare(query)
          .bind(id, authorId, text, timestamp, trending ? 1 : 0)
          .run();
        
        console.log('Proposal inserted successfully');
      } catch (insertError) {
        console.error('Database insertion error:', insertError);
        return createResponse({ 
          error: 'Failed to insert proposal into database', 
          details: logError(insertError, { action: 'insert_proposal' })
        }, 500);
      }
      
      // Generate and store the share image (but don't block on it)
      console.log('Generating share image');
      let shareImageUrl = null;
      
      try {
        shareImageUrl = await generateAndStoreShareImage(tempProposal, env);
        console.log(`Generated share image: ${shareImageUrl}`);
        
        // Update the proposal with the share image URL if we got one
        if (shareImageUrl) {
          console.log('Updating proposal with share image URL');
          await env.DB.prepare(`
            UPDATE proposals
            SET share_image_url = ?
            WHERE id = ?
          `).bind(shareImageUrl, id).run();
        }
      } catch (imageError) {
        // Log but don't fail the whole request if image generation fails
        console.error('Image generation error (non-fatal):', imageError);
      }
      
      console.log(`Successfully created proposal with ID: ${id}`);
      
      // Return success response with created proposal data
      return createResponse({ 
        id, 
        authorId, 
        text, 
        timestamp, 
        trending,
        shareImageUrl 
      });
    } catch (userCheckError) {
      console.error('Error checking user existence:', userCheckError);
      return createResponse({ 
        error: 'Failed to verify user', 
        details: logError(userCheckError, { action: 'check_user', authorId })
      }, 500);
    }
  } catch (error) {
    console.error('Unhandled error in proposal creation:', error);
    return createResponse({ 
      error: 'Failed to process proposal creation', 
      details: logError(error, { action: 'create_proposal_outer' })
    }, 500);
  }
}

// Update a proposal (e.g., mark as trending)
async function updateProposal(id, request, env) {
  try {
    const data = await request.json();
    const { trending } = data;
    
    console.log(`Updating proposal ${id}: ${JSON.stringify(data)}`);
    
    if (trending === undefined) {
      return createResponse({ error: 'No fields to update', received: data }, 400);
    }
    
    // Check if proposal exists
    try {
      const proposalCheck = await env.DB.prepare(`SELECT id FROM proposals WHERE id = ?`).bind(id).first();
      if (!proposalCheck) {
        return createResponse({ error: 'Proposal does not exist', id }, 404);
      }
    } catch (checkError) {
      return createResponse({ 
        error: 'Error checking proposal existence', 
        details: logError(checkError, { action: 'check_proposal', id })
      }, 500);
    }
    
    const query = `
      UPDATE proposals
      SET trending = ?
      WHERE id = ?
    `;
    
    try {
      await env.DB.prepare(query).bind(trending ? 1 : 0, id).run();
      console.log(`Successfully updated proposal ${id} trending status to ${trending}`);
      
      return createResponse({ id, trending });
    } catch (dbError) {
      return createResponse({ 
        error: 'Failed to update proposal', 
        details: logError(dbError, { action: 'update_proposal', id, trending }) 
      }, 500);
    }
  } catch (error) {
    return createResponse({ 
      error: 'Failed to process proposal update', 
      details: logError(error, { action: 'update_proposal_outer', id }) 
      }, 500);
  }
}

// Create or update a vote and handle petition data
async function createOrUpdateVote(request, env) {
  try {
    const data = await request.json();
    const { proposalId, userId, voteType, isPetition = false, petitionDetails = null } = data;
    
    console.log(`Processing vote/petition: ${JSON.stringify({
      proposalId, 
      userId, 
      voteType, 
      isPetition,
      hasDetails: petitionDetails !== null
    })}`);
    
    if (!proposalId || !userId || !voteType) {
      return createResponse({ 
        error: 'Missing required fields', 
        received: { proposalId, userId, voteType: voteType || 'undefined' } 
      }, 400);
    }
    
    if (voteType !== 'upvote' && voteType !== 'downvote') {
      return createResponse({ 
        error: 'Invalid vote type', 
        voteType, 
        allowedValues: ['upvote', 'downvote'] 
      }, 400);
    }
    
    // Check if entities exist
    try {
      const userCheck = await env.DB.prepare(`SELECT id FROM users WHERE id = ?`).bind(userId).first();
      if (!userCheck) {
        return createResponse({ error: 'User does not exist', userId }, 404);
      }
      
      const proposalCheck = await env.DB.prepare(`SELECT id FROM proposals WHERE id = ?`).bind(proposalId).first();
      if (!proposalCheck) {
        return createResponse({ error: 'Proposal does not exist', proposalId }, 404);
      }
    } catch (checkError) {
      return createResponse({ 
        error: 'Error checking user or proposal existence', 
        details: logError(checkError, { action: 'check_entities', userId, proposalId })
      }, 500);
    }
    
    // Check if vote already exists
    let existingVote;
    try {
      const checkQuery = `
        SELECT id, vote_type, is_petition FROM votes
        WHERE proposal_id = ? AND user_id = ?
      `;
      
      existingVote = await env.DB.prepare(checkQuery).bind(proposalId, userId).first();
      console.log(`Existing vote check: ${existingVote ? JSON.stringify(existingVote) : 'None found'}`);
    } catch (voteCheckError) {
      return createResponse({ 
        error: 'Error checking existing vote', 
        details: logError(voteCheckError, { action: 'check_vote', userId, proposalId })
      }, 500);
    }
    
    const timestamp = Date.now();
    
    try {
      // Process vote
      if (existingVote) {
        // If vote exists and it's the same type, remove it (toggle off)
        if (existingVote.vote_type === voteType) {
          await env.DB.prepare(`
            DELETE FROM votes
            WHERE id = ?
          `).bind(existingVote.id).run();
          
          console.log(`Deleted vote ${existingVote.id} (toggle off)`);
          
          return createResponse({ proposalId, userId, voteType: null });
        } else {
          // If vote exists but is different type, update it
          await env.DB.prepare(`
            UPDATE votes
            SET vote_type = ?, timestamp = ?, is_petition = ?
            WHERE id = ?
          `).bind(
            voteType, 
            timestamp, 
            voteType === 'upvote' && isPetition ? 1 : 0, 
            existingVote.id
          ).run();
          
          console.log(`Updated vote ${existingVote.id} to ${voteType}`);
        }
      } else {
        // If no vote exists, create new one
        const result = await env.DB.prepare(`
          INSERT INTO votes (proposal_id, user_id, vote_type, timestamp, is_petition)
          VALUES (?, ?, ?, ?, ?)
        `).bind(
          proposalId, 
          userId, 
          voteType, 
          timestamp,
          voteType === 'upvote' && isPetition ? 1 : 0
        ).run();
        
        console.log(`Created new vote with ID: ${result.meta?.last_row_id || 'unknown'}`);
      }
      
      // Process petition details if provided
      if (voteType === 'upvote' && isPetition && petitionDetails) {
        try {
          // Validate petition details
          const { fullName, address, postcode, dob, email } = petitionDetails;
          
          if (!fullName || !address || !postcode || !dob || !email) {
            return createResponse({ error: 'Missing required petition details' }, 400);
          }
          
          // Check if petition details already exist
          const petitionCheck = await env.DB.prepare(`
            SELECT id FROM petition_details
            WHERE user_id = ? AND proposal_id = ?
          `).bind(userId, proposalId).first();
          
          if (!petitionCheck) {
            // Store petition details
            await env.DB.prepare(`
              INSERT INTO petition_details 
              (user_id, proposal_id, full_name, address, postcode, dob, email, timestamp, verified)
              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
            `).bind(
              userId, 
              proposalId, 
              fullName, 
              address, 
              postcode, 
              dob, 
              email, 
              timestamp,
              1 // Assuming verification was successful
            ).run();
            
            console.log(`Stored petition details for user ${userId} on proposal ${proposalId}`);
          } else {
            // Update existing petition details
            await env.DB.prepare(`
              UPDATE petition_details
              SET full_name = ?, address = ?, postcode = ?, dob = ?, email = ?, timestamp = ?, verified = ?
              WHERE user_id = ? AND proposal_id = ?
            `).bind(
              fullName,
              address,
              postcode,
              dob,
              email,
              timestamp,
              1, // Assuming verification was successful
              userId,
              proposalId
            ).run();
            
            console.log(`Updated petition details for user ${userId} on proposal ${proposalId}`);
          }
        } catch (petitionError) {
          return createResponse({ 
            error: 'Failed to process petition details', 
            details: logError(petitionError, { action: 'store_petition', userId, proposalId })
          }, 500);
        }
      }
      
      if (voteType === 'upvote') {
        checkAndNotifyMilestones(proposalId, env).catch(e => console.error('Milestone check error:', e));
      }

      return createResponse({
        proposalId,
        userId,
        voteType,
        isPetition: voteType === 'upvote' && isPetition,
        petitionVerified: voteType === 'upvote' && isPetition
      });
    } catch (dbError) {
      return createResponse({ 
        error: 'Failed to process vote/petition in database', 
        details: logError(dbError, { 
          action: 'process_vote_petition', 
          existingVote: existingVote || null,
          newVote: { proposalId, userId, voteType, isPetition }
        })
      }, 500);
    }
  } catch (error) {
    return createResponse({ 
      error: 'Failed to process vote/petition request', 
      details: logError(error, { action: 'vote_petition_outer' })
    }, 500);
  }
}

// 3. Update the getComments function to include vote counts
async function getComments(request, env) {
  try {
    const url = new URL(request.url);
    const proposalId = url.searchParams.get('proposalId');
    const userId = url.searchParams.get('userId');
    
    if (!proposalId) {
      return createResponse({ error: 'Missing proposalId parameter' }, 400);
    }
    
    const query = `
      SELECT 
        c.id, c.user_id, c.comment_text, c.timestamp,
        u.name as user_name,
        (SELECT COUNT(*) FROM comment_votes WHERE comment_id = c.id AND vote_type = 'upvote') as upvotes,
        (SELECT COUNT(*) FROM comment_votes WHERE comment_id = c.id AND vote_type = 'downvote') as downvotes
      FROM comments c
      JOIN users u ON c.user_id = u.id
      WHERE c.proposal_id = ?
      ORDER BY c.timestamp DESC
    `;
    
    try {
      const comments = await env.DB.prepare(query).bind(proposalId).all();
      console.log(`Retrieved ${comments.results.length} comments for proposal ${proposalId}`);
      
      // If userId is provided, get the user's votes for these comments
      if (userId && comments.results.length > 0) {
        const commentIds = comments.results.map(c => c.id);
        
        // Build placeholders for the SQL query
        let placeholders = commentIds.map(() => '?').join(',');
        
        const votesQuery = `
          SELECT comment_id, vote_type 
          FROM comment_votes 
          WHERE user_id = ? AND comment_id IN (${placeholders})
        `;
        
        // Prepare bind parameters
        const bindParams = [userId, ...commentIds];
        
        const votes = await env.DB.prepare(votesQuery).bind(...bindParams).all();
        
        // Create a map of commentId to vote type
        const voteMap = {};
        votes.results.forEach(vote => {
          voteMap[vote.comment_id] = vote.vote_type;
        });
        
        // Add user's vote to each comment
        comments.results.forEach(comment => {
          comment.userVote = voteMap[comment.id] || null;
        });
      }
      
      return createResponse(comments.results);
    } catch (dbError) {
      return createResponse({
        error: 'Failed to retrieve comments',
        details: logError(dbError, { action: 'get_comments', proposalId })
      }, 500);
    }
  } catch (error) {
    return createResponse({
      error: 'Failed to process comments request',
      details: logError(error, { action: 'get_comments_outer' })
    }, 500);
  }
}

// Function to create a new comment
async function createComment(request, env) {
  console.log("========== BEGIN createComment ==========");
  try {
    // First check if request is properly formed
    if (!request || !request.body) {
      console.error("Invalid request object or missing body");
      return createResponse({
        error: 'Invalid request',
        details: 'Request missing required properties'
      }, 400);
    }
    
    // Attempt to parse JSON data
    let data;
    try {
      data = await request.json();
      console.log(`Parsed comment request data: ${JSON.stringify(data)}`);
    } catch (jsonError) {
      console.error("Failed to parse request JSON:", jsonError);
      return createResponse({
        error: 'Invalid JSON in request',
        details: 'Could not parse request body as JSON'
      }, 400);
    }
    
    const { proposalId, userId, commentText } = data;
    
    console.log(`Creating comment: proposalId=${proposalId}, userId=${userId}, text length=${commentText?.length || 0}`);
    
    if (!proposalId || !userId || !commentText) {
      console.error("Missing required fields:", {
        hasProposalId: !!proposalId,
        hasUserId: !!userId,
        hasCommentText: !!commentText
      });
      
      return createResponse({
        error: 'Missing required fields',
        received: { 
          proposalId: proposalId || '[missing]', 
          userId: userId || '[missing]', 
          commentText: commentText ? '[present]' : '[missing]' 
        }
      }, 400);
    }
    
    // Check if proposal exists
    try {
      console.log(`Checking if proposal exists: ${proposalId}`);
      const proposalCheck = await env.DB.prepare(
        `SELECT id FROM proposals WHERE id = ?`
      ).bind(proposalId).first();
      
      if (!proposalCheck) {
        console.error(`Proposal not found: ${proposalId}`);
        return createResponse({ 
          error: 'Proposal does not exist', 
          proposalId 
        }, 404);
      }
      
      console.log(`Proposal found: ${proposalCheck.id}`);
    } catch (checkError) {
      console.error("Error checking proposal existence:", checkError);
      return createResponse({
        error: 'Error checking proposal existence',
        details: logError(checkError, { action: 'check_proposal', proposalId })
      }, 500);
    }
    
    // Check if user exists
    try {
      console.log(`Checking if user exists: ${userId}`);
      const userCheck = await env.DB.prepare(
        `SELECT id FROM users WHERE id = ?`
      ).bind(userId).first();
      
      if (!userCheck) {
        console.error(`User not found: ${userId}`);
        return createResponse({ 
          error: 'User does not exist', 
          userId 
        }, 404);
      }
      
      console.log(`User found: ${userCheck.id}`);
    } catch (userError) {
      console.error("Error checking user existence:", userError);
      return createResponse({
        error: 'Error checking user existence',
        details: logError(userError, { action: 'check_user', userId })
      }, 500);
    }
    
    // Generate a unique comment ID
    const id = 'comment_' + Date.now() + '_' + Math.random().toString(36).substr(2, 5);
    const timestamp = Date.now();
    
    console.log(`Generated comment ID: ${id}`);
    
    // Insert the comment into the database
    try {
      console.log("Inserting comment into database");
      await env.DB.prepare(`
        INSERT INTO comments (id, proposal_id, user_id, comment_text, timestamp)
        VALUES (?, ?, ?, ?, ?)
      `).bind(id, proposalId, userId, commentText, timestamp).run();
      
      console.log(`Successfully created comment with ID: ${id}`);
      
      // Get user name for response
      console.log("Getting user name for response");
      const userQuery = await env.DB.prepare(
        `SELECT name FROM users WHERE id = ?`
      ).bind(userId).first();
      
      if (!userQuery || !userQuery.name) {
        console.warn(`Could not find name for user ${userId}, using 'Anonymous'`);
      }
      
      const responseData = {
        id,
        proposalId,
        userId,
        userName: userQuery?.name || 'Anonymous',
        commentText,
        timestamp,
        upvotes: 0,
        downvotes: 0
      };
      
      console.log(`Creating successful response: ${JSON.stringify(responseData)}`);
      console.log("========== END createComment ==========");
      
      return createResponse(responseData, 201);  // Use 201 Created for successful creation
    } catch (dbError) {
      console.error("Database error creating comment:", dbError);
      return createResponse({
        error: 'Failed to create comment in database',
        details: logError(dbError, {
          action: 'insert_comment',
          comment: { id, proposalId, userId, timestamp }
        })
      }, 500);
    }
  } catch (error) {
    console.error("Unhandled error in createComment:", error);
    console.log("========== END createComment (with error) ==========");
    return createResponse({
      error: 'Failed to process comment creation',
      details: logError(error, { action: 'create_comment_outer' })
    }, 500);
  }
}

// Create or get a user
async function createOrGetUser(request, env) {
  try {
    const data = await request.json();
    const { id, name } = data;
    
    console.log(`Processing user request: ${JSON.stringify(data)}`);
    
    if (!id || !name) {
      return createResponse({ 
        error: 'Missing required fields', 
        received: { id: id || 'undefined', name: name || 'undefined' } 
      }, 400);
    }
    
    // Check if user exists
    let existingUser;
    try {
      const checkQuery = `
        SELECT id, name FROM users
        WHERE id = ?
      `;
      
      existingUser = await env.DB.prepare(checkQuery).bind(id).first();
      console.log(`Existing user check: ${existingUser ? JSON.stringify(existingUser) : 'None found'}`);
    } catch (userCheckError) {
      return createResponse({ 
        error: 'Error checking user existence', 
        details: logError(userCheckError, { action: 'check_user', id })
      }, 500);
    }
    
    if (!existingUser) {
      try {
        // Create new user if doesn't exist
        const timestamp = Date.now();
        const insertQuery = `
          INSERT INTO users (id, name, created_at)
          VALUES (?, ?, ?)
        `;
        await env.DB.prepare(insertQuery).bind(id, name, timestamp).run();
        console.log(`Created new user with ID: ${id}`);
      } catch (insertError) {
        return createResponse({ 
          error: 'Failed to create user', 
          details: logError(insertError, { action: 'insert_user', user: { id, name } })
        }, 500);
      }
    } else {
      console.log(`Found existing user: ${existingUser.id}`);
    }
    
    return createResponse({ id, name });
  } catch (error) {
    return createResponse({ 
      error: 'Failed to process user request', 
      details: logError(error, { action: 'user_outer' })
    }, 500);
  }
}

async function verifyTemplateImage(env) {
  try {
    const key = "petition-template.png";
    const object = await env.MEMES_BUCKET.get(key);
    
    if (object === null) {
      console.error("❌ Template image not found in R2 bucket!");
      return false;
    }
    
    console.log("✅ Template image found in R2 bucket");
    return true;
  } catch (error) {
    console.error("Error verifying template image:", error);
    return false;
  }
}

/**
 * Handle requests for dynamic SVG images for petitions
 * @param {Request} request - The incoming request
 * @param {Object} env - Environment bindings
 * @returns {Response} - SVG response
 */
async function servePetitionSVG(request, env) {
  try {
    const url = new URL(request.url);
    const proposalId = url.searchParams.get('id');
    
    if (!proposalId) {
      return new Response('Missing proposal ID', { status: 400 });
    }
    
    console.log(`Generating SVG image for proposal: ${proposalId}`);
    
    // Fetch the proposal data from the database
    const proposal = await env.DB.prepare(`
      SELECT 
        p.id, p.text, p.timestamp,
        u.name as author_name,
        (SELECT COUNT(*) FROM votes WHERE proposal_id = p.id AND vote_type = 'upvote') as upvotes,
        (SELECT COUNT(*) FROM votes WHERE proposal_id = p.id AND vote_type = 'downvote') as downvotes
      FROM proposals p
      JOIN users u ON p.author_id = u.id
      WHERE p.id = ?
    `).bind(proposalId).first();
    
    if (!proposal) {
      return new Response('Proposal not found', { status: 404 });
    }
    
    // Generate the SVG
    const svgMarkup = generatePetitionSVG(proposal);
    
    // Return the SVG with appropriate headers
    return new Response(svgMarkup, {
      headers: {
        'Content-Type': 'image/svg+xml',
        'Cache-Control': 'public, max-age=360000', // Cache for 1 hour
        'Access-Control-Allow-Origin': '*'
      }
    });
  } catch (error) {
    console.error('Error generating petition SVG:', error);
    return new Response('Internal Server Error', { status: 500 });
  }
}

/**
 * Generates a dynamic SVG for a petition with the given data
 * @param {Object} proposal - The petition/proposal data
 * @returns {string} - SVG markup as a string
 */
function generatePetitionSVG(proposal) {
  const text = escapeHTML(proposal.text || 'Untitled petition');
  const upvotes = proposal.upvotes || 0;
  const author = escapeHTML(proposal.author_name || 'Anonymous');
  const date = new Date(proposal.timestamp || Date.now()).toLocaleDateString('en-AU', {
    day: 'numeric', month: 'short', year: 'numeric'
  });

  // Word-wrap the petition text into lines (max ~52 chars per line at font-size 28)
  const words = text.split(' ');
  const lines = [];
  let line = '';
  for (const word of words) {
    if ((line + ' ' + word).trim().length > 52) { lines.push(line.trim()); line = word; }
    else line = (line + ' ' + word).trim();
  }
  if (line) lines.push(line);
  const displayLines = lines.slice(0, 7);
  if (lines.length > 7) displayLines[6] = displayLines[6].replace(/.{3}$/, '...');

  const textY = 310 - (displayLines.length * 38) / 2;
  const textEls = displayLines.map((l, i) =>
    `<text x="600" y="${textY + i * 38}" font-family="monospace" font-size="28" font-weight="500" fill="#ffffff" text-anchor="middle">${l}</text>`
  ).join('\n  ');

  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1200 630" width="1200" height="630">
  <!-- bg -->
  <rect width="1200" height="630" fill="#000"/>
  <!-- left accent bar -->
  <rect x="0" y="0" width="8" height="630" fill="#ff0099"/>
  <!-- header band -->
  <rect x="0" y="0" width="1200" height="80" fill="#0a0a0a"/>
  <!-- RADICAL wordmark -->
  <text x="60" y="54" font-family="monospace" font-size="48" font-weight="700" fill="#ff0099" letter-spacing="8">RADICAL</text>
  <!-- tagline -->
  <text x="60" y="74" font-family="monospace" font-size="13" fill="#555" letter-spacing="3">VIBE · VOTE · VETO  —  theradicalparty.com</text>
  <!-- PETITION label top right -->
  <rect x="980" y="18" width="180" height="44" fill="#ff0099"/>
  <text x="1070" y="46" font-family="monospace" font-size="18" font-weight="700" fill="#000" text-anchor="middle" letter-spacing="2">PETITION</text>

  <!-- petition text area -->
  <rect x="60" y="108" width="1080" height="380" fill="#0a0a0a" rx="0"/>
  <rect x="60" y="108" width="4" height="380" fill="#ff0099"/>
  <!-- quote mark -->
  <text x="100" y="185" font-family="monospace" font-size="80" fill="#1a1a1a" font-weight="700">"</text>
  <!-- wrapped petition text -->
  ${textEls}

  <!-- footer band -->
  <rect x="0" y="508" width="1200" height="122" fill="#0a0a0a"/>
  <line x1="0" y1="508" x2="1200" y2="508" stroke="#222" stroke-width="1"/>

  <!-- upvote count -->
  <text x="68" y="560" font-family="monospace" font-size="15" fill="#666" letter-spacing="1">SIGNATURES</text>
  <text x="68" y="598" font-family="monospace" font-size="40" font-weight="700" fill="#ff0099">${upvotes.toLocaleString()}</text>

  <!-- divider -->
  <line x1="300" y1="524" x2="300" y2="618" stroke="#222" stroke-width="1"/>

  <!-- author + date -->
  <text x="330" y="556" font-family="monospace" font-size="13" fill="#555" letter-spacing="1">PROPOSED BY</text>
  <text x="330" y="585" font-family="monospace" font-size="20" fill="#aaa">${author}</text>
  <text x="330" y="612" font-family="monospace" font-size="14" fill="#444">${date}</text>

  <!-- CTA -->
  <text x="1140" y="570" font-family="monospace" font-size="13" fill="#666" text-anchor="end">Sign this petition at</text>
  <text x="1140" y="592" font-family="monospace" font-size="16" fill="#ff0099" text-anchor="end" font-weight="700">theradicalparty.com</text>
</svg>`;
}

/**
 * Generates SVG text elements with proper line wrapping
 * @param {string} text - The text to wrap
 * @param {number} x - Starting x position
 * @param {number} y - Starting y position
 * @param {number} width - Maximum width for text wrapping
 * @returns {string} - SVG text elements
 */
function generateSVGTextLines(text, x, y, width) {
  // Simple word wrapping algorithm
  const words = text.split(' ');
  const lines = [];
  let currentLine = '';
  
  // Estimate characters per line based on width and average character width
  const avgCharWidth = 22; // Rough estimate for font size ~36px
  const charsPerLine = Math.floor(width / avgCharWidth);
  
  for (const word of words) {
    const testLine = currentLine ? `${currentLine} ${word}` : word;
    if (testLine.length <= charsPerLine) {
      currentLine = testLine;
    } else {
      lines.push(currentLine);
      currentLine = word;
    }
  }
  
  if (currentLine) {
    lines.push(currentLine);
  }
  
  // Limit to 6 lines to fit in the container
  const limitedLines = lines.slice(0, 6);
  if (lines.length > 6) {
    // Add ellipsis to the last line if truncated
    limitedLines[5] = limitedLines[5].slice(0, -3) + '...';
  }
  
  // Generate SVG text elements
  const lineHeight = 46;
  let svgTextElements = '';
  
  limitedLines.forEach((line, index) => {
    const lineY = y + index * lineHeight;
    svgTextElements += `<text x="${x}" y="${lineY}" font-family="'Roboto Mono', monospace" font-size="36" fill="#ffffff">${escapeHTML(line)}</text>\n`;
  });
  
  return svgTextElements;
}

/**
 * Escapes HTML special characters in a string
 * @param {string} text - The text to escape
 * @returns {string} - Escaped text
 */
function escapeHTML(text) {
  return text
    .replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;')
    .replace(/'/g, '&#039;');
}

// Update the getShareableImageUrl function to use the SVG endpoint
function getShareableImageUrl(proposal) {
  // Use the dynamic SVG endpoint with the proposal ID
  return `https://theradicalparty.com/api/petition-svg?id=${proposal.id}`;
}

// Update the serveCustomizedHtml function to use the SVG URL for meta tags
async function serveCustomizedHtml(proposalId, request, env) {
  console.log(`===== BEGIN serveCustomizedHtml for proposal ${proposalId} =====`);
  
  try {
    const url = new URL(request.url);
    const isTestMeta = url.searchParams.get('test_meta') === 'true';
    
    // Determine which proposal to use
    let proposal;
    let shareImageUrl;
    
    if (isTestMeta) {
      // Use test proposal data
      proposal = {
        id: 'test_proposal',
        text: 'This is a test proposal for meta tags',
        timestamp: Date.now(),
        author_name: 'Test User'
      };
      shareImageUrl = `https://${url.hostname}/api/petition-svg?id=test_proposal`;
    } else {
      // Fetch the actual proposal from the database
      proposal = await env.DB.prepare(`
        SELECT 
          p.id, p.text, p.timestamp,
          u.name as author_name
        FROM proposals p
        JOIN users u ON p.author_id = u.id
        WHERE p.id = ?
      `).bind(proposalId).first();
      
      if (!proposal) {
        console.error(`Proposal not found: ${proposalId}`);
        return await fetch(request);
      }
      
      // Generate SVG URL
      shareImageUrl = `https://${url.hostname}/api/petition-svg?id=${proposalId}`;
    }
    
    console.log(`Found proposal: ${JSON.stringify(proposal)}`);
    console.log(`Using share image URL: ${shareImageUrl}`);
    
    // Get the full URL for this proposal
    const fullProposalUrl = `https://${url.hostname}/?proposal=${proposalId}`;
    
    // Fetch the original HTML
    const response = await fetch(request);
    const html = await response.text();
    
    // First, remove all existing og:image and twitter:image tags
    let modifiedHtml = html.replace(/<meta\s+property=["']og:image(:[^"']*)?["'][^>]*>/g, '');
    modifiedHtml = modifiedHtml.replace(/<meta\s+name=["']twitter:image(:[^"']*)?["'][^>]*>/g, '');
    modifiedHtml = modifiedHtml.replace(/<meta\s+name=["']twitter:image:src["'][^>]*>/g, '');
    
    // Find the head end tag
    const headEndIndex = modifiedHtml.indexOf('</head>');
    if (headEndIndex === -1) {
      console.error("Could not find </head> tag in HTML");
      return new Response(modifiedHtml, {
        headers: response.headers
      });
    }
    
    // Create comprehensive meta tags
    const customMetaTags = `
      <!-- RADICAL SOCIAL SHARING META TAGS ${Date.now()} -->
      <!-- Primary Meta Tags -->
      <meta name="title" content="RADICAL Petition: ${proposal.text.substring(0, 60)}">
      <meta name="description" content="${proposal.text.substring(0, 150)}">
      
      <!-- Open Graph / Facebook -->
      <meta property="og:type" content="website">
      <meta property="og:url" content="${fullProposalUrl}">
      <meta property="og:title" content="RADICAL Petition: ${proposal.text.substring(0, 60)}">
      <meta property="og:description" content="${proposal.text.substring(0, 150)}">
      <meta property="og:image" content="${shareImageUrl}">
      <meta property="og:image:width" content="1200">
      <meta property="og:image:height" content="630">
      <meta property="og:image:alt" content="RADICAL Petition: ${proposal.text.substring(0, 60)}">
      
      <!-- Twitter -->
      <meta name="twitter:card" content="summary_large_image">
      <meta name="twitter:url" content="${fullProposalUrl}">
      <meta name="twitter:title" content="RADICAL Petition">
      <meta name="twitter:description" content="${proposal.text.substring(0, 150)}">
      <meta name="twitter:image" content="${shareImageUrl}">
      <meta name="twitter:image:alt" content="RADICAL Petition: ${proposal.text.substring(0, 60)}">
    `;
    
    // Insert our meta tags right before </head>
    let customizedHtml = modifiedHtml.substring(0, headEndIndex) + customMetaTags + modifiedHtml.substring(headEndIndex);
    
    console.log(`===== END serveCustomizedHtml for proposal ${proposalId} =====`);
    
    // Return the customized HTML with appropriate headers
    const originalHeaders = new Headers(response.headers);
    originalHeaders.set('Cache-Control', 'no-store, max-age=0');
    originalHeaders.set('X-Custom-Meta', isTestMeta ? 'test' : 'proposal');
    originalHeaders.set('X-Share-Image-Url', shareImageUrl); // Debug header
    
    return new Response(customizedHtml, {
      headers: originalHeaders
    });
  } catch (error) {
    console.error('Error generating customized HTML:', error);
    return await fetch(request);
  }
}

// ─── NEW FEATURES ──────────────────────────────────────────────────────────

const MILESTONES = [100, 500, 1000, 5000, 10000];
const MILESTONE_ACTIONS = {
  100:   'Going viral 🔥',
  500:   'Community backed 💪',
  1000:  'Published publicly 📢',
  5000:  'Written to the relevant minister 📬',
  10000: 'Mass media push 📺'
};

async function getLeaderboard(request, env) {
  try {
    const url = new URL(request.url);
    const userId = url.searchParams.get('userId') || '';
    const query = `
      SELECT
        p.id, p.text, p.timestamp, p.trending, p.meme_url,
        u.name as author_name,
        (SELECT COUNT(*) FROM votes WHERE proposal_id = p.id AND vote_type = 'upvote') as upvotes,
        (SELECT COUNT(*) FROM votes WHERE proposal_id = p.id AND vote_type = 'downvote') as downvotes,
        (SELECT vote_type FROM votes WHERE proposal_id = p.id AND user_id = ?) as user_vote,
        (SELECT COUNT(DISTINCT u2.postcode) FROM votes v2 JOIN users u2 ON v2.user_id = u2.id WHERE v2.proposal_id = p.id AND v2.vote_type = 'upvote' AND u2.postcode IS NOT NULL) as postcode_count
      FROM proposals p
      JOIN users u ON p.author_id = u.id
      WHERE (p.hidden = 0 OR p.hidden IS NULL)
      ORDER BY upvotes DESC
      LIMIT 10
    `;
    const results = await env.DB.prepare(query).bind(userId).all();
    if (results.results) {
      results.results.forEach(p => { p.userVote = p.user_vote; });
    }
    return createResponse({ data: results.results }, 200, 0);
  } catch (error) {
    return createResponse({ error: 'Failed to get leaderboard', details: logError(error, { action: 'get_leaderboard' }) }, 500);
  }
}

async function getSiteStats(request, env) {
  try {
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    const stats = await env.DB.prepare(`
      SELECT
        (SELECT COUNT(*) FROM votes WHERE timestamp >= ?) as votes_today,
        (SELECT COUNT(*) FROM users) as total_users,
        (SELECT COUNT(*) FROM proposals WHERE hidden = 0 OR hidden IS NULL) as total_proposals,
        (SELECT COUNT(*) FROM votes) as total_votes
    `).bind(today.getTime()).first();
    return createResponse(stats, 200, 30);
  } catch (error) {
    return createResponse({ error: 'Failed to get stats' }, 500);
  }
}

async function saveUserEmail(request, env) {
  try {
    const data = await request.json();
    const { userId, email, postcode } = data;
    if (!userId || !email) return createResponse({ error: 'Missing required fields' }, 400);
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (!emailRegex.test(email)) return createResponse({ error: 'Invalid email format' }, 400);
    const postcodeClean = postcode ? String(postcode).replace(/\D/g, '').slice(0, 4) : null;
    await env.DB.prepare(`UPDATE users SET email = ?, postcode = ?, notify_milestones = 1 WHERE id = ?`)
      .bind(email, postcodeClean || null, userId).run();
    return createResponse({ success: true }, 200, 0);
  } catch (error) {
    return createResponse({ error: 'Failed to save email', details: logError(error, { action: 'save_email' }) }, 500);
  }
}

async function flagProposal(request, env) {
  try {
    const data = await request.json();
    const { proposalId, userId } = data;
    if (!proposalId || !userId) return createResponse({ error: 'Missing required fields' }, 400);
    const existing = await env.DB.prepare(`SELECT id FROM proposal_flags WHERE proposal_id = ? AND user_id = ?`).bind(proposalId, userId).first();
    if (existing) return createResponse({ error: 'Already flagged' }, 400);
    const timestamp = Date.now();
    await env.DB.prepare(`INSERT INTO proposal_flags (proposal_id, user_id, timestamp) VALUES (?, ?, ?)`).bind(proposalId, userId, timestamp).run();
    await env.DB.prepare(`UPDATE proposals SET flag_count = COALESCE(flag_count, 0) + 1 WHERE id = ?`).bind(proposalId).run();
    const proposal = await env.DB.prepare(`SELECT flag_count FROM proposals WHERE id = ?`).bind(proposalId).first();
    if (proposal && proposal.flag_count >= 5) {
      await env.DB.prepare(`UPDATE proposals SET hidden = 1 WHERE id = ?`).bind(proposalId).run();
    }
    return createResponse({ success: true, proposalId }, 200, 0);
  } catch (error) {
    return createResponse({ error: 'Failed to flag proposal', details: logError(error, { action: 'flag_proposal' }) }, 500);
  }
}

async function checkAndNotifyMilestones(proposalId, env) {
  try {
    const row = await env.DB.prepare(`SELECT COUNT(*) as count FROM votes WHERE proposal_id = ? AND vote_type = 'upvote'`).bind(proposalId).first();
    const count = row.count;
    for (const milestone of MILESTONES) {
      if (count >= milestone) {
        const existing = await env.DB.prepare(`SELECT id FROM milestone_notifications WHERE proposal_id = ? AND milestone = ?`).bind(proposalId, milestone).first();
        if (!existing) {
          await env.DB.prepare(`INSERT INTO milestone_notifications (proposal_id, milestone, sent_at) VALUES (?, ?, ?)`).bind(proposalId, milestone, Date.now()).run();
          await sendMilestoneEmails(proposalId, milestone, env);
        }
      }
    }
  } catch (error) {
    console.error('Milestone check failed:', error);
  }
}

async function sendMilestoneEmails(proposalId, milestone, env) {
  if (!env.RESEND_API_KEY) return;
  try {
    const proposal = await env.DB.prepare(`
      SELECT p.text, u.name as author_name FROM proposals p JOIN users u ON p.author_id = u.id WHERE p.id = ?
    `).bind(proposalId).first();
    if (!proposal) return;
    const subscribers = await env.DB.prepare(`
      SELECT DISTINCT u.email FROM votes v JOIN users u ON v.user_id = u.id
      WHERE v.proposal_id = ? AND v.vote_type = 'upvote' AND u.email IS NOT NULL AND u.notify_milestones = 1
    `).bind(proposalId).all();
    const action = MILESTONE_ACTIONS[milestone];
    const proposalUrl = `https://theradicalparty.com/?proposal=${proposalId}`;
    for (const { email } of subscribers.results) {
      await fetch('https://api.resend.com/emails', {
        method: 'POST',
        headers: { 'Authorization': `Bearer ${env.RESEND_API_KEY}`, 'Content-Type': 'application/json' },
        body: JSON.stringify({
          from: 'RADICAL <noreply@theradicalparty.com>',
          to: [email],
          subject: `🔥 ${milestone.toLocaleString()} signatures — this petition is being ${action}`,
          html: `<div style="font-family:monospace;background:#000;color:#fff;padding:24px;max-width:600px">
            <h2 style="color:#ff0099">RADICAL</h2>
            <p>A petition you backed just hit <strong style="color:#ff0099">${milestone.toLocaleString()} signatures</strong>!</p>
            <blockquote style="border-left:3px solid #ff0099;margin:16px 0;padding:8px 16px;font-size:1.1em">"${proposal.text}"</blockquote>
            <p>What happens next: <strong>${action}</strong></p>
            <p><a href="${proposalUrl}" style="color:#ff0099">View the petition →</a></p>
            <hr style="border-color:#333;margin-top:32px">
            <p style="font-size:0.8em;color:#666">You're receiving this because you signed this petition on RADICAL. <a href="https://theradicalparty.com" style="color:#666">Unsubscribe</a></p>
          </div>`
        })
      }).catch(e => console.error(`Email to ${email} failed:`, e));
    }
  } catch (error) {
    console.error('sendMilestoneEmails error:', error);
  }
}

async function sendWeeklyDigest(env) {
  if (!env.RESEND_API_KEY) return;
  try {
    const weekAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
    const top5 = await env.DB.prepare(`
      SELECT p.id, p.text,
        (SELECT COUNT(*) FROM votes WHERE proposal_id = p.id AND vote_type = 'upvote') as upvotes
      FROM proposals p
      WHERE (p.hidden = 0 OR p.hidden IS NULL)
      ORDER BY upvotes DESC LIMIT 5
    `).all();
    const stats = await env.DB.prepare(`
      SELECT COUNT(*) as new_votes FROM votes WHERE timestamp >= ?
    `).bind(weekAgo).first();
    const subscribers = await env.DB.prepare(`
      SELECT DISTINCT email FROM users WHERE email IS NOT NULL AND notify_milestones = 1
    `).all();
    const proposalRows = top5.results.map((p, i) =>
      `<tr><td style="padding:8px;color:#ff0099">${i + 1}</td><td style="padding:8px">${escapeHTML(p.text.substring(0, 120))}${p.text.length > 120 ? '...' : ''}</td><td style="padding:8px;color:#ff0099;text-align:right">${p.upvotes} ▲</td></tr>`
    ).join('');
    const html = `<div style="font-family:monospace;background:#000;color:#fff;padding:24px;max-width:600px">
      <h2 style="color:#ff0099">RADICAL — Weekly Digest</h2>
      <p style="color:#aaa">${stats.new_votes} votes cast this week</p>
      <h3>🏆 Top Proposals This Week</h3>
      <table style="width:100%;border-collapse:collapse">${proposalRows}</table>
      <p style="margin-top:24px"><a href="https://theradicalparty.com" style="color:#ff0099;font-weight:bold">→ Vote now at theradicalparty.com</a></p>
      <hr style="border-color:#333;margin-top:32px">
      <p style="font-size:0.8em;color:#666">You're receiving this weekly digest from RADICAL.</p>
    </div>`;
    for (const { email } of subscribers.results) {
      await fetch('https://api.resend.com/emails', {
        method: 'POST',
        headers: { 'Authorization': `Bearer ${env.RESEND_API_KEY}`, 'Content-Type': 'application/json' },
        body: JSON.stringify({
          from: 'RADICAL <noreply@theradicalparty.com>',
          to: [email],
          subject: `RADICAL Weekly — ${stats.new_votes} votes this week`,
          html
        })
      }).catch(e => console.error(`Weekly digest to ${email} failed:`, e));
    }
    console.log(`Weekly digest sent to ${subscribers.results.length} subscribers`);
  } catch (error) {
    console.error('sendWeeklyDigest error:', error);
  }
}

async function handleJoinMovement(request, env) {
  try {
    const data = await request.json();
    const { fullName, dob, address, suburb, state, postcode, email, phone, onRoll, consent } = data;

    if (!fullName || !dob || !address || !suburb || !state || !postcode || !email || !onRoll || !consent) {
      return createResponse({ error: 'Missing required fields' }, 400);
    }

    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (!emailRegex.test(email)) {
      return createResponse({ error: 'Invalid email address' }, 400);
    }

    const timestamp = new Date().toLocaleString('en-AU', { timeZone: 'Australia/Sydney' });

    if (env.RESEND_API_KEY) {
      await fetch('https://api.resend.com/emails', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${env.RESEND_API_KEY}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          from: 'RADICAL <noreply@theradicalparty.com>',
          to: ['kingomartheoneandonly@protonmail.com'],
          subject: `New RADICAL Member: ${fullName}`,
          html: `<div style="font-family:monospace;background:#000;color:#fff;padding:24px;max-width:600px">
            <h2 style="color:#ff0099">NEW RADICAL PARTY MEMBER</h2>
            <p style="color:#aaa">Submitted: ${timestamp}</p>
            <table style="width:100%;border-collapse:collapse;margin-top:16px">
              <tr><td style="padding:8px;color:#ff0099;width:140px">Full Name</td><td style="padding:8px">${escapeHTML(fullName)}</td></tr>
              <tr style="background:#111"><td style="padding:8px;color:#ff0099">Date of Birth</td><td style="padding:8px">${escapeHTML(dob)}</td></tr>
              <tr><td style="padding:8px;color:#ff0099">Address</td><td style="padding:8px">${escapeHTML(address)}</td></tr>
              <tr style="background:#111"><td style="padding:8px;color:#ff0099">Suburb</td><td style="padding:8px">${escapeHTML(suburb)}</td></tr>
              <tr><td style="padding:8px;color:#ff0099">State</td><td style="padding:8px">${escapeHTML(state)}</td></tr>
              <tr style="background:#111"><td style="padding:8px;color:#ff0099">Postcode</td><td style="padding:8px">${escapeHTML(postcode)}</td></tr>
              <tr><td style="padding:8px;color:#ff0099">Email</td><td style="padding:8px">${escapeHTML(email)}</td></tr>
              <tr style="background:#111"><td style="padding:8px;color:#ff0099">Phone</td><td style="padding:8px">${phone ? escapeHTML(phone) : 'Not provided'}</td></tr>
              <tr><td style="padding:8px;color:#ff0099">On Electoral Roll</td><td style="padding:8px">Yes ✓</td></tr>
              <tr style="background:#111"><td style="padding:8px;color:#ff0099">Consented</td><td style="padding:8px">Yes ✓</td></tr>
            </table>
            <hr style="border-color:#333;margin-top:32px">
            <p style="font-size:0.8em;color:#666">RADICAL Party Membership Application</p>
          </div>`
        })
      });
    }

    return createResponse({ success: true }, 200, 0);
  } catch (error) {
    return createResponse({ error: 'Failed to process membership application', details: logError(error, { action: 'join_movement' }) }, 500);
  }
}