-- Migration: Create feedback emoji reactions table
-- Purpose: Add emoji reaction support to feedback entries

-- Create feedback_reactions table
CREATE TABLE feedback_reactions (
    id TEXT PRIMARY KEY,
    feedback_session_id TEXT NOT NULL,
    member_id TEXT NOT NULL,
    emoji TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (feedback_session_id) REFERENCES feedback_sessions(id) ON DELETE CASCADE,
    FOREIGN KEY (member_id) REFERENCES members(id) ON DELETE CASCADE,
    -- Ensure one reaction per user per emoji per feedback
    UNIQUE(feedback_session_id, member_id, emoji)
);

-- Create index for efficient querying
CREATE INDEX idx_feedback_reactions_session_id ON feedback_reactions(feedback_session_id);
CREATE INDEX idx_feedback_reactions_member_id ON feedback_reactions(member_id);

-- Migration: Drop feedback emoji reactions table
-- Purpose: Remove emoji reaction support from feedback entries

-- Drop feedback_reactions table
DROP TABLE IF EXISTS feedback_reactions;

export interface EmojiReaction {
  emoji: string
  count: number
  users: string[]
  hasReacted: boolean
}

export interface FeedbackEntry {
  id: string
  content: string
  topics: string[]
  author: string
  author_id: string
  timestamp: string
  isOwnFeedback: boolean
  isPublic: boolean
  reactions?: EmojiReaction[]
}

// ... existing code ...

import { useState, useCallback } from 'react'
import type { EmojiReaction } from '@/types/feedback'

interface UseEmojiReactionsProps {
  feedbackId: string
  initialReactions?: EmojiReaction[]
  onReactionUpdate?: (feedbackId: string, reactions: EmojiReaction[]) => void
}

export function useEmojiReactions({ 
  feedbackId, 
  initialReactions = [],
  onReactionUpdate 
}: UseEmojiReactionsProps) {
  const [reactions, setReactions] = useState<EmojiReaction[]>(initialReactions)
  const [isLoading, setIsLoading] = useState(false)

  const addReaction = useCallback(async (emoji: string, userId: string, username: string) => {
    setIsLoading(true)
    try {
      // Find existing reaction for this emoji
      const existingReactionIndex = reactions.findIndex(r => r.emoji === emoji)
      
      if (existingReactionIndex >= 0) {
        // Emoji already exists, check if user has already reacted
        const existingReaction = reactions[existingReactionIndex]
        const userHasReacted = existingReaction.users.includes(username)
        
        if (userHasReacted) {
          // Remove user's reaction
          const updatedReaction = {
            ...existingReaction,
            count: existingReaction.count - 1,
            users: existingReaction.users.filter(u => u !== username),
            hasReacted: false
          }
          
          const updatedReactions = [...reactions]
          if (updatedReaction.count === 0) {
            // Remove the reaction entirely if no users left
            updatedReactions.splice(existingReactionIndex, 1)
          } else {
            updatedReactions[existingReactionIndex] = updatedReaction
          }
          
          setReactions(updatedReactions)
          onReactionUpdate?.(feedbackId, updatedReactions)
        } else {
          // Add user's reaction
          const updatedReaction = {
            ...existingReaction,
            count: existingReaction.count + 1,
            users: [...existingReaction.users, username],
            hasReacted: true
          }
          
          const updatedReactions = [...reactions]
          updatedReactions[existingReactionIndex] = updatedReaction
          
          setReactions(updatedReactions)
          onReactionUpdate?.(feedbackId, updatedReactions)
        }
      } else {
        // Create new reaction
        const newReaction: EmojiReaction = {
          emoji,
          count: 1,
          users: [username],
          hasReacted: true
        }
        
        const updatedReactions = [...reactions, newReaction]
        setReactions(updatedReactions)
        onReactionUpdate?.(feedbackId, updatedReactions)
      }
    } catch (error) {
      console.error('Error updating emoji reaction:', error)
    } finally {
      setIsLoading(false)
    }
  }, [reactions, feedbackId, onReactionUpdate])

  const removeReaction = useCallback(async (emoji: string, userId: string, username: string) => {
    setIsLoading(true)
    try {
      const reactionIndex = reactions.findIndex(r => r.emoji === emoji)
      if (reactionIndex >= 0) {
        const reaction = reactions[reactionIndex]
        const updatedReaction = {
          ...reaction,
          count: reaction.count - 1,
          users: reaction.users.filter(u => u !== username),
          hasReacted: false
        }
        
        const updatedReactions = [...reactions]
        if (updatedReaction.count === 0) {
          updatedReactions.splice(reactionIndex, 1)
        } else {
          updatedReactions[reactionIndex] = updatedReaction
        }
        
        setReactions(updatedReactions)
        onReactionUpdate?.(feedbackId, updatedReactions)
      }
    } catch (error) {
      console.error('Error removing emoji reaction:', error)
    } finally {
      setIsLoading(false)
    }
  }, [reactions, feedbackId, onReactionUpdate])

  const toggleReaction = useCallback(async (emoji: string, userId: string, username: string) => {
    const existingReaction = reactions.find(r => r.emoji === emoji)
    const userHasReacted = existingReaction?.users.includes(username) ?? false
    
    if (userHasReacted) {
      await removeReaction(emoji, userId, username)
    } else {
      await addReaction(emoji, userId, username)
    }
  }, [reactions, addReaction, removeReaction])

  return {
    reactions,
    isLoading,
    addReaction,
    removeReaction,
    toggleReaction
  }
}

// SetupFeedbackRoutes configures all feedback-related routes
func SetupFeedbackRoutes(r chi.Router, deps *app.Dependencies) {
	r.Route("/api/feedback", func(r chi.Router) {
		r.Get("/", listFeedback(deps))
		r.Post("/", createFeedback(deps))
		r.Put("/{feedbackId}/visibility", toggleFeedbackVisibility(deps))
		r.Put("/{feedbackId}", updateFeedback(deps))
		r.Delete("/{feedbackId}", deleteFeedback(deps))
		
		// Emoji reaction routes
		r.Route("/{feedbackId}/reactions", func(r chi.Router) {
			r.Get("/", listFeedbackReactions(deps))
			r.Post("/", addFeedbackReaction(deps))
			r.Delete("/{emoji}", removeFeedbackReaction(deps))
		})
	})
}

func deleteFeedback(deps *app.Dependencies) func(w http.ResponseWriter, r *http.Request) {
	handler := handlers.NewDeleteFeedbackHandler(deps.FeedbackService)
	return handler.ServeHTTP
}

// Emoji reaction handlers
func listFeedbackReactions(deps *app.Dependencies) func(w http.ResponseWriter, r *http.Request) {
	handler := handlers.NewListFeedbackReactionsHandler(deps.FeedbackService)
	return handler.ServeHTTP
}

func addFeedbackReaction(deps *app.Dependencies) func(w http.ResponseWriter, r *http.Request) {
	handler := handlers.NewAddFeedbackReactionHandler(deps.FeedbackService)
	return handler.ServeHTTP
}

func removeFeedbackReaction(deps *app.Dependencies) func(w http.ResponseWriter, r *http.Request) {
	handler := handlers.NewRemoveFeedbackReactionHandler(deps.FeedbackService)
	return handler.ServeHTTP
}

	// Return success response
	h.errorHelper.WriteSuccessMessage(w, "Feedback deleted successfully", nil)
}

// ListFeedbackReactionsHandler handles GET /api/feedback/:id/reactions
type ListFeedbackReactionsHandler struct {
	feedbackService domain.FeedbackServiceInterface
	errorHelper     *ErrorResponseHelper
}

// NewListFeedbackReactionsHandler creates a new ListFeedbackReactionsHandler
func NewListFeedbackReactionsHandler(feedbackService domain.FeedbackServiceInterface) *ListFeedbackReactionsHandler {
	return &ListFeedbackReactionsHandler{
		feedbackService: feedbackService,
		errorHelper:     NewErrorResponseHelper(),
	}
}

// ServeHTTP implements http.Handler
func (h *ListFeedbackReactionsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// Get user claims from context
	claims, err := getUserClaimsFromContext(r)
	if err != nil {
		h.errorHelper.HandleAuthError(w, err.Error())
		return
	}

	// Extract feedback ID from URL path
	feedbackID := chi.URLParam(r, "feedbackId")
	if feedbackID == "" {
		h.errorHelper.HandleValidationError(w, "feedback_id", "Feedback ID is required")
		return
	}

	// TODO: Implement getting reactions from service
	// For now, return empty array
	reactions := []map[string]interface{}{}
	
	h.errorHelper.WriteSuccessResponse(w, reactions, http.StatusOK)
}

// AddFeedbackReactionHandler handles POST /api/feedback/:id/reactions
type AddFeedbackReactionHandler struct {
	feedbackService domain.FeedbackServiceInterface
	errorHelper     *ErrorResponseHelper
}

// NewAddFeedbackReactionHandler creates a new AddFeedbackReactionHandler
func NewAddFeedbackReactionHandler(feedbackService domain.FeedbackServiceInterface) *AddFeedbackReactionHandler {
	return &AddFeedbackReactionHandler{
		feedbackService: feedbackService,
		errorHelper:     NewErrorResponseHelper(),
	}
}

// ServeHTTP implements http.Handler
func (h *AddFeedbackReactionHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// Get user claims from context
	claims, err := getUserClaimsFromContext(r)
	if err != nil {
		h.errorHelper.HandleAuthError(w, err.Error())
		return
	}

	// Extract feedback ID from URL path
	feedbackID := chi.URLParam(r, "feedbackId")
	if feedbackID == "" {
		h.errorHelper.HandleValidationError(w, "feedback_id", "Feedback ID is required")
		return
	}

	// Parse JSON request body
	var reactionRequest struct {
		Emoji string `json:"emoji"`
	}

	if err := json.NewDecoder(r.Body).Decode(&reactionRequest); err != nil {
		h.errorHelper.HandleJSONParseError(w)
		return
	}

	// Validate emoji
	if reactionRequest.Emoji == "" {
		h.errorHelper.HandleValidationError(w, "emoji", "Emoji is required")
		return
	}

	// TODO: Implement adding reaction via service
	// For now, return success
	response := map[string]interface{}{
		"message": "Reaction added successfully",
		"emoji":   reactionRequest.Emoji,
	}
	
	h.errorHelper.WriteSuccessResponse(w, response, http.StatusCreated)
}

// RemoveFeedbackReactionHandler handles DELETE /api/feedback/:id/reactions/:emoji
type RemoveFeedbackReactionHandler struct {
	feedbackService domain.FeedbackServiceInterface
	errorHelper     *ErrorResponseHelper
}

// NewRemoveFeedbackReactionHandler creates a new RemoveFeedbackReactionHandler
func NewRemoveFeedbackReactionHandler(feedbackService domain.FeedbackServiceInterface) *RemoveFeedbackReactionHandler {
	return &RemoveFeedbackReactionHandler{
		feedbackService: feedbackService,
		errorHelper:     NewErrorResponseHelper(),
	}
}

// ServeHTTP implements http.Handler
func (h *RemoveFeedbackReactionHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// Get user claims from context
	claims, err := getUserClaimsFromContext(r)
	if err != nil {
		h.errorHelper.HandleAuthError(w, err.Error())
		return
	}

	// Extract feedback ID and emoji from URL path
	feedbackID := chi.URLParam(r, "feedbackId")
	emoji := chi.URLParam(r, "emoji")
	
	if feedbackID == "" {
		h.errorHelper.HandleValidationError(w, "feedback_id", "Feedback ID is required")
		return
	}
	
	if emoji == "" {
		h.errorHelper.HandleValidationError(w, "emoji", "Emoji is required")
		return
	}

	// TODO: Implement removing reaction via service
	// For now, return success
	response := map[string]interface{}{
		"message": "Reaction removed successfully",
		"emoji":   emoji,
	}
	
	h.errorHelper.WriteSuccessResponse(w, response, http.StatusOK)
}

	// TODO: Implement getting reactions from service
	// For now, return empty array
	reactions := []map[string]interface{}{}
	
	// Log the user for debugging (will be removed when implementing actual service)
	_ = claims.Email
	
	h.errorHelper.WriteSuccessResponse(w, reactions, http.StatusOK)

	// TODO: Implement adding reaction via service
	// For now, return success
	response := map[string]interface{}{
		"message": "Reaction added successfully",
		"emoji":   reactionRequest.Emoji,
		"user":    claims.Email, // Include user info for debugging
	}
	
	h.errorHelper.WriteSuccessResponse(w, response, http.StatusCreated)

	// TODO: Implement removing reaction via service
	// For now, return success
	response := map[string]interface{}{
		"message": "Reaction removed successfully",
		"emoji":   emoji,
		"user":    claims.Email, // Include user info for debugging
	}
	
	h.errorHelper.WriteSuccessResponse(w, response, http.StatusOK)

#!/usr/bin/env node

/**
 * Test script to validate emoji reactions implementation
 * This script tests the basic structure and UI components
 */

console.log("🎉 Testing Emoji Reactions Implementation");
console.log("=======================================");

// Test 1: Check that we can create emoji reaction objects
const testEmojiReaction = {
  emoji: "👍",
  count: 3,
  users: ["user1", "user2", "user3"],
  hasReacted: true
};

console.log("✅ Test 1 Passed: EmojiReaction object structure");
console.log("   Sample reaction:", testEmojiReaction);

// Test 2: Check default emojis
const DEFAULT_EMOJIS = ['👍', '👎', '😄', '🎉', '😕', '❤️', '🚀', '👏'];
console.log("✅ Test 2 Passed: Default emojis available");
console.log("   Default emojis:", DEFAULT_EMOJIS);

// Test 3: Test emoji reaction logic
function testEmojiLogic() {
  const reactions = [];
  
  // Add first reaction
  const newReaction = {
    emoji: "👍",
    count: 1,
    users: ["testuser"],
    hasReacted: true
  };
  reactions.push(newReaction);
  
  // Add same user to same emoji (should toggle)
  const existingReaction = reactions.find(r => r.emoji === "👍");
  if (existingReaction && existingReaction.users.includes("testuser")) {
    existingReaction.count--;
    existingReaction.users = existingReaction.users.filter(u => u !== "testuser");
    existingReaction.hasReacted = false;
  }
  
  return reactions[0].count === 0;
}

console.log("✅ Test 3 Passed: Emoji toggle logic");
console.log("   Toggle test result:", testEmojiLogic());

// Test 4: Test topic positioning
console.log("✅ Test 4 Note: Topic positioning");
console.log("   Topics should now be positioned in bottom-right corner");
console.log("   Using CSS: justify-end for right alignment");

// Test 5: Test API endpoints structure
const apiEndpoints = {
  listReactions: "GET /api/feedback/:id/reactions",
  addReaction: "POST /api/feedback/:id/reactions",
  removeReaction: "DELETE /api/feedback/:id/reactions/:emoji"
};

console.log("✅ Test 5 Passed: API endpoints defined");
console.log("   Endpoints:", JSON.stringify(apiEndpoints, null, 2));

console.log("\n🎯 Implementation Status:");
console.log("✅ Database schema created");
console.log("✅ TypeScript interfaces defined");
console.log("✅ React component updated");
console.log("✅ API routes structure added");
console.log("✅ Backend handlers created (placeholder)");
console.log("⏳ TODO: Implement full backend service logic");
console.log("⏳ TODO: Connect frontend to backend APIs");
console.log("⏳ TODO: Add comprehensive tests");

console.log("\n🚀 Ready for next development phase!");

# Create E2E tests for emoji reactions
e2e/specs/emoji-reactions.spec.ts

# Run the migration
cd database && ./local-migrate.sh

import { test, expect } from '@playwright/test';
import { 
  setupE2ETestPage, 
  generateUniqueTestName, 
  createBoardViaModal, 
  navigateToBoard,
  submitFeedbackViaUI,
  waitForElementToBeStable
} from '../utils/test-helpers';

test.describe('Emoji Reactions on Feedback - TDD Implementation', () => {
  
  test.use({ storageState: 'playwright/.auth/user.json' });

  test('should display topic tags in bottom-right corner of feedback entries', async ({ page }) => {
    console.log('\n🎯 === TEST: Topic Tag Positioning ===');
    
    // Setup test environment
    const boardName = generateUniqueTestName('Topic Position Test Board');
    const folderName = generateUniqueTestName('Topic Test Folder');
    
    await setupE2ETestPage(page);
    
    // Create board with topics
    await createBoardViaModal(page, {
      boardName,
      folderName,
      createNewFolder: true,
      topics: ['Team Collaboration', 'Code Quality'],
      skipTeamMembers: true
    });
    
    // Navigate to board
    await navigateToBoard(page, boardName);
    
    // Submit feedback to have entries to test
    await submitFeedbackViaUI(page, {
      topics: ['Team Collaboration', 'Code Quality'],
      comment: 'This feedback should have topics in bottom-right corner'
    });
    
    // Wait for feedback to appear
    await expect(page.locator('[data-testid="feedback-entry"]')).toBeVisible();
    
    // Test that topic tags are positioned correctly in bottom-right
    const feedbackEntry = page.locator('[data-testid="feedback-entry"]').first();
    const topicTags = feedbackEntry.locator('[data-testid="feedback-topic-tags"]');
    
    await expect(topicTags).toBeVisible();
    
    // Check CSS classes for right alignment
    await expect(topicTags).toHaveClass(/justify-end/);
    
    // Verify topics are present
    await expect(topicTags.locator('text=Team Collaboration')).toBeVisible();
    await expect(topicTags.locator('text=Code Quality')).toBeVisible();
    
    console.log('✅ Topic tags are correctly positioned in bottom-right corner');
  });

  test('should display emoji add button and show emoji picker when clicked', async ({ page }) => {
    console.log('\n🎯 === TEST: Emoji Picker Display ===');
    
    // Setup test environment
    const boardName = generateUniqueTestName('Emoji Picker Test Board');
    const folderName = generateUniqueTestName('Emoji Test Folder');
    
    await setupE2ETestPage(page);
    
    // Create board and submit feedback
    await createBoardViaModal(page, {
      boardName,
      folderName,
      createNewFolder: true,
      topics: ['Team Collaboration', 'Work-Life Balance'],
      skipTeamMembers: true
    });
    
    await navigateToBoard(page, boardName);
    
    await submitFeedbackViaUI(page, {
      topics: ['Team Collaboration', 'Work-Life Balance'],
      comment: 'This feedback should have emoji reactions available'
    });
    
    // Wait for feedback entry
    await expect(page.locator('[data-testid="feedback-entry"]')).toBeVisible();
    
    const feedbackEntry = page.locator('[data-testid="feedback-entry"]').first();
    
    // Test 1: Emoji add button should be visible
    const emojiAddButton = feedbackEntry.locator('button').filter({ hasText: '😊' });
    await expect(emojiAddButton).toBeVisible();
    console.log('✅ Emoji add button is visible');
    
    // Test 2: Click emoji add button should show picker
    await emojiAddButton.click();
    
    // Look for emoji picker dropdown
    const emojiPicker = feedbackEntry.locator('div').filter({ hasText: '👍' });
    await expect(emojiPicker).toBeVisible();
    console.log('✅ Emoji picker appears when add button is clicked');
    
    // Test 3: Emoji picker should contain default emojis
    const expectedEmojis = ['👍', '👎', '😄', '🎉', '😕', '❤️', '🚀', '👏'];
    
    for (const emoji of expectedEmojis) {
      const emojiButton = feedbackEntry.locator(`button:has-text("${emoji}")`);
      await expect(emojiButton).toBeVisible();
    }
    console.log('✅ All default emojis are present in picker');
    
    // Test 4: Clicking outside should close picker
    await page.locator('body').click();
    await expect(emojiPicker).not.toBeVisible();
    console.log('✅ Emoji picker closes when clicking outside');
  });

  test('should add emoji reaction and display count when emoji is selected', async ({ page }) => {
    console.log('\n🎯 === TEST: Adding Emoji Reactions ===');
    
    // Setup test environment
    const boardName = generateUniqueTestName('Add Reaction Test Board');
    const folderName = generateUniqueTestName('Reaction Test Folder');
    
    await setupE2ETestPage(page);
    
    await createBoardViaModal(page, {
      boardName,
      folderName,
      createNewFolder: true,
      topics: ['Team Collaboration', 'Code Quality'],
      skipTeamMembers: true
    });
    
    await navigateToBoard(page, boardName);
    
    await submitFeedbackViaUI(page, {
      topics: ['Team Collaboration'],
      comment: 'This feedback will receive emoji reactions'
    });
    
    // Wait for feedback entry
    const feedbackEntry = page.locator('[data-testid="feedback-entry"]').first();
    await expect(feedbackEntry).toBeVisible();
    
    // Open emoji picker
    const emojiAddButton = feedbackEntry.locator('button').filter({ hasText: '😊' });
    await emojiAddButton.click();
    
    // Select thumbs up emoji
    const thumbsUpButton = feedbackEntry.locator('button:has-text("👍")').first();
    await thumbsUpButton.click();
    
    // Test: Reaction should appear with count of 1
    const reactionButton = feedbackEntry.locator('button').filter({ hasText: '👍' }).filter({ hasText: '1' });
    await expect(reactionButton).toBeVisible();
    console.log('✅ Emoji reaction appears with count of 1');
    
    // Test: Clicking same emoji again should toggle it off
    await reactionButton.click();
    
    // Reaction should disappear (count goes to 0)
    await expect(reactionButton).not.toBeVisible();
    console.log('✅ Clicking same emoji toggles reaction off');
    
    // Test: Add multiple different reactions
    await emojiAddButton.click();
    await feedbackEntry.locator('button:has-text("🎉")').first().click();
    
    await emojiAddButton.click();
    await feedbackEntry.locator('button:has-text("❤️")').first().click();
    
    // Both reactions should be visible
    await expect(feedbackEntry.locator('button').filter({ hasText: '🎉' }).filter({ hasText: '1' })).toBeVisible();
    await expect(feedbackEntry.locator('button').filter({ hasText: '❤️' }).filter({ hasText: '1' })).toBeVisible();
    console.log('✅ Multiple different emoji reactions can be added');
  });

  test('should persist emoji reactions after page refresh', async ({ page }) => {
    console.log('\n🎯 === TEST: Emoji Reaction Persistence ===');
    
    // Setup test environment
    const boardName = generateUniqueTestName('Persistence Test Board');
    const folderName = generateUniqueTestName('Persistence Test Folder');
    
    await setupE2ETestPage(page);
    
    await createBoardViaModal(page, {
      boardName,
      folderName,
      createNewFolder: true,
      topics: ['Team Collaboration'],
      skipTeamMembers: true
    });
    
    await navigateToBoard(page, boardName);
    
    await submitFeedbackViaUI(page, {
      topics: ['Team Collaboration'],
      comment: 'This feedback will test reaction persistence'
    });
    
    // Add emoji reaction
    const feedbackEntry = page.locator('[data-testid="feedback-entry"]').first();
    const emojiAddButton = feedbackEntry.locator('button').filter({ hasText: '😊' });
    await emojiAddButton.click();
    
    const rocketButton = feedbackEntry.locator('button:has-text("🚀")').first();
    await rocketButton.click();
    
    // Verify reaction is added
    const reactionButton = feedbackEntry.locator('button').filter({ hasText: '🚀' }).filter({ hasText: '1' });
    await expect(reactionButton).toBeVisible();
    
    // Refresh page
    await page.reload();
    await expect(page.locator('[data-testid="board-view"]')).toBeVisible();
    
    // Wait for feedback to reload
    await expect(page.locator('[data-testid="feedback-entry"]')).toBeVisible();
    
    // Test: Reaction should still be present after refresh
    const persistedReaction = page.locator('[data-testid="feedback-entry"]')
      .first()
      .locator('button')
      .filter({ hasText: '🚀' })
      .filter({ hasText: '1' });
    
    await expect(persistedReaction).toBeVisible();
    console.log('✅ Emoji reactions persist after page refresh');
  });

  test('should handle API errors gracefully when adding reactions', async ({ page }) => {
    console.log('\n🎯 === TEST: Error Handling ===');
    
    // Setup test environment
    const boardName = generateUniqueTestName('Error Test Board');
    const folderName = generateUniqueTestName('Error Test Folder');
    
    await setupE2ETestPage(page);
    
    await createBoardViaModal(page, {
      boardName,
      folderName,
      createNewFolder: true,
      topics: ['Team Collaboration'],
      skipTeamMembers: true
    });
    
    await navigateToBoard(page, boardName);
    
    await submitFeedbackViaUI(page, {
      topics: ['Team Collaboration'],
      comment: 'This feedback will test error handling'
    });
    
    // Intercept API calls to simulate errors
    await page.route('**/api/feedback/*/reactions', route => {
      route.fulfill({
        status: 500,
        body: JSON.stringify({ error: 'Internal server error' })
      });
    });
    
    const feedbackEntry = page.locator('[data-testid="feedback-entry"]').first();
    const emojiAddButton = feedbackEntry.locator('button').filter({ hasText: '😊' });
    await emojiAddButton.click();
    
    // Try to add reaction (should fail gracefully)
    const thumbsUpButton = feedbackEntry.locator('button:has-text("👍")').first();
    await thumbsUpButton.click();
    
    // The UI should handle the error gracefully - reaction shouldn't appear
    // or should show some error state
    await page.waitForTimeout(1000); // Give time for API call to fail
    
    const reactionButton = feedbackEntry.locator('button').filter({ hasText: '👍' }).filter({ hasText: '1' });
    await expect(reactionButton).not.toBeVisible();
    console.log('✅ API errors are handled gracefully');
  });

  test('should display hover tooltip showing users who reacted', async ({ page }) => {
    console.log('\n🎯 === TEST: Reaction Tooltips ===');
    
    // Setup test environment
    const boardName = generateUniqueTestName('Tooltip Test Board');
    const folderName = generateUniqueTestName('Tooltip Test Folder');
    
    await setupE2ETestPage(page);
    
    await createBoardViaModal(page, {
      boardName,
      folderName,
      createNewFolder: true,
      topics: ['Team Collaboration'],
      skipTeamMembers: true
    });
    
    await navigateToBoard(page, boardName);
    
    await submitFeedbackViaUI(page, {
      topics: ['Team Collaboration'],
      comment: 'This feedback will test reaction tooltips'
    });
    
    // Add emoji reaction
    const feedbackEntry = page.locator('[data-testid="feedback-entry"]').first();
    const emojiAddButton = feedbackEntry.locator('button').filter({ hasText: '😊' });
    await emojiAddButton.click();
    
    const heartButton = feedbackEntry.locator('button:has-text("❤️")').first();
    await heartButton.click();
    
    // Find the reaction button
    const reactionButton = feedbackEntry.locator('button').filter({ hasText: '❤️' }).filter({ hasText: '1' });
    await expect(reactionButton).toBeVisible();
    
    // Test: Hover should show tooltip with user information
    await reactionButton.hover();
    
    // Look for tooltip with user information
    // Note: This test assumes the tooltip shows user names/emails
    // The exact implementation may vary, but we should see some user info
    const tooltip = page.locator('[title*="reacted with ❤️"]');
    await expect(tooltip).toBeVisible();
    console.log('✅ Tooltip displays user information on hover');
  });

  test.skip('should update reaction counts in real-time for multiple users', async ({ page }) => {
    // This test would require multi-user testing setup
    // Skipping for now but would test real-time collaboration features
    console.log('⏭️ Skipping real-time multi-user test - requires additional setup');
  });

  test('should maintain layout consistency with emoji reactions added', async ({ page }) => {
    console.log('\n🎯 === TEST: Layout Consistency ===');
    
    // Setup test environment
    const boardName = generateUniqueTestName('Layout Test Board');
    const folderName = generateUniqueTestName('Layout Test Folder');
    
    await setupE2ETestPage(page);
    
    await createBoardViaModal(page, {
      boardName,
      folderName,
      createNewFolder: true,
      topics: ['Team Collaboration', 'Work-Life Balance', 'Code Quality'],
      skipTeamMembers: true
    });
    
    await navigateToBoard(page, boardName);
    
    // Submit feedback with multiple topics
    await submitFeedbackViaUI(page, {
      topics: ['Team Collaboration', 'Work-Life Balance', 'Code Quality'],
      comment: 'This feedback has multiple topics and will receive emoji reactions to test layout'
    });
    
    const feedbackEntry = page.locator('[data-testid="feedback-entry"]').first();
    
    // Test initial layout: topics should be in bottom-right
    const topicTags = feedbackEntry.locator('[data-testid="feedback-topic-tags"]');
    await expect(topicTags).toHaveClass(/justify-end/);
    
    // Add multiple emoji reactions
    const emojiAddButton = feedbackEntry.locator('button').filter({ hasText: '😊' });
    
    const emojisToAdd = ['👍', '🎉', '❤️', '🚀'];
    for (const emoji of emojisToAdd) {
      await emojiAddButton.click();
      await feedbackEntry.locator(`button:has-text("${emoji}")`).first().click();
    }
    
    // Verify all reactions are visible
    for (const emoji of emojisToAdd) {
      const reaction = feedbackEntry.locator('button').filter({ hasText: emoji }).filter({ hasText: '1' });
      await expect(reaction).toBeVisible();
    }
    
    // Test: Topics should still be in bottom-right corner
    await expect(topicTags).toHaveClass(/justify-end/);
    
    // Test: Emoji reactions should be in bottom-left area
    const reactionSection = feedbackEntry.locator('div').filter({ hasText: '👍' }).first();
    await expect(reactionSection).toBeVisible();
    
    // Test: Layout should not be broken
    await expect(feedbackEntry).toBeVisible();
    await expect(topicTags.locator('text=Team Collaboration')).toBeVisible();
    
    console.log('✅ Layout remains consistent with emoji reactions and multiple topics');
  });
});

test.describe('Emoji Reactions - API Integration Tests', () => {
  
  test.use({ storageState: 'playwright/.auth/user.json' });

  test('should call correct API endpoints when adding/removing reactions', async ({ page }) => {
    console.log('\n🎯 === TEST: API Integration ===');
    
    // Track API calls
    const apiCalls: Array<{ method: string; url: string; body?: any }> = [];
    
    page.on('request', request => {
      if (request.url().includes('/api/feedback/') && request.url().includes('/reactions')) {
        apiCalls.push({
          method: request.method(),
          url: request.url(),
          body: request.postDataJSON()
        });
      }
    });
    
    // Setup test environment
    const boardName = generateUniqueTestName('API Test Board');
    const folderName = generateUniqueTestName('API Test Folder');
    
    await setupE2ETestPage(page);
    
    await createBoardViaModal(page, {
      boardName,
      folderName,
      createNewFolder: true,
      topics: ['Team Collaboration'],
      skipTeamMembers: true
    });
    
    await navigateToBoard(page, boardName);
    
    await submitFeedbackViaUI(page, {
      topics: ['Team Collaboration'],
      comment: 'This feedback will test API integration'
    });
    
    // Add emoji reaction and verify API call
    const feedbackEntry = page.locator('[data-testid="feedback-entry"]').first();
    const emojiAddButton = feedbackEntry.locator('button').filter({ hasText: '😊' });
    await emojiAddButton.click();
    
    const thumbsUpButton = feedbackEntry.locator('button:has-text("👍")').first();
    await thumbsUpButton.click();
    
    // Wait for API call
    await page.waitForTimeout(1000);
    
    // Verify API calls were made
    const postCalls = apiCalls.filter(call => call.method === 'POST');
    expect(postCalls.length).toBeGreaterThan(0);
    
    // Check that POST call includes emoji data
    const addReactionCall = postCalls.find(call => call.body && call.body.emoji === '👍');
    expect(addReactionCall).toBeTruthy();
    
    console.log('✅ Correct API endpoints are called for emoji reactions');
    console.log(`API calls made: ${JSON.stringify(apiCalls, null, 2)}`);
  });
});

    // Test 1: Emoji add button should be visible
    const emojiAddButton = feedbackEntry.getByTestId('emoji-add-button');
    await expect(emojiAddButton).toBeVisible();
    console.log('✅ Emoji add button is visible');
    
    // Test 2: Click emoji add button should show picker
    await emojiAddButton.click();
    
    // Look for emoji picker dropdown using test ID
    const emojiPicker = feedbackEntry.getByTestId('emoji-picker-dropdown');
    await expect(emojiPicker).toBeVisible();
    console.log('✅ Emoji picker appears when add button is clicked');
    
    // Test 3: Emoji picker should contain default emojis
    const expectedEmojis = ['👍', '👎', '😄', '🎉', '😕', '❤️', '🚀', '👏'];
    
    for (const emoji of expectedEmojis) {
      const emojiButton = emojiPicker.getByTestId(`emoji-option-${emoji}`);
      await expect(emojiButton).toBeVisible();
    }
    console.log('✅ All default emojis are present in picker');
    
    // Test 4: Clicking outside should close picker
    await page.locator('body').click();
    await expect(emojiPicker).not.toBeVisible();

  test('should add emoji reaction and display count when emoji is selected', async ({ page }) => {
    console.log('\n🎯 === TEST: Adding Emoji Reactions ===');
    
    // Monitor API requests
    const apiRequests: Array<{ method: string; url: string; body?: any }> = [];
    page.on('request', request => {
      if (request.url().includes('/api/')) {
        const body = request.postDataJSON();
        apiRequests.push({
          method: request.method(),
          url: request.url(),
          body: body
        });
        console.log(`🌐 API Request: ${request.method()} ${request.url()}`, body ? JSON.stringify(body) : '');
      }
    });
    
    // Setup test environment
    const boardName = generateUniqueTestName('Add Reaction Test Board');
    const folderName = generateUniqueTestName('Reaction Test Folder');
    
    await setupE2ETestPage(page);
    
    await createBoardViaModal(page, {
      boardName,
      folderName,
      createNewFolder: true,
      topics: ['Team Collaboration', 'Code Quality'],
      skipTeamMembers: true
    });
    
    await navigateToBoard(page, boardName);
    
    await submitFeedbackViaUI(page, {
      topics: ['Team Collaboration'],
      comment: 'This feedback will receive emoji reactions'
    });
    
    // Wait for feedback entry
    const feedbackEntry = page.locator('[data-testid="feedback-entry"]').first();
    await expect(feedbackEntry).toBeVisible();
    
    // Open emoji picker using test ID
    const emojiAddButton = feedbackEntry.getByTestId('emoji-add-button');
    await expect(emojiAddButton).toBeVisible();
    await emojiAddButton.click();
    
    // Wait for emoji picker to appear
    const emojiPicker = feedbackEntry.getByTestId('emoji-picker-dropdown');
    await expect(emojiPicker).toBeVisible();
    
    // Select thumbs up emoji using test ID
    const thumbsUpButton = emojiPicker.getByTestId('emoji-option-👍');
    await expect(thumbsUpButton).toBeVisible();
    await thumbsUpButton.click();

    await createBoardViaModal(page, {
      boardName,
      folderName,
      createNewFolder: true,
      topics: ['Team Collaboration', 'Code Quality'],
      skipTeamMembers: true
    });

  test('should persist emoji reactions after page refresh', async ({ page }) => {
    console.log('\n🎯 === TEST: Emoji Reaction Persistence ===');
    
    // Setup test environment
    const boardName = generateUniqueTestName('Persistence Test Board');
    const folderName = generateUniqueTestName('Persistence Test Folder');
    
    await setupE2ETestPage(page);
    
    await createBoardViaModal(page, {
      boardName,
      folderName,
      createNewFolder: true,
      topics: ['Team Collaboration', 'Code Quality'],
      skipTeamMembers: true
    });

    // Add emoji reaction
    const feedbackEntry = page.locator('[data-testid="feedback-entry"]').first();
    const emojiAddButton = feedbackEntry.getByTestId('emoji-add-button');
    await emojiAddButton.click();
    
    const emojiPicker = feedbackEntry.getByTestId('emoji-picker-dropdown');
    await expect(emojiPicker).toBeVisible();
    
    const rocketButton = emojiPicker.getByTestId('emoji-option-🚀');
    await rocketButton.click();

    // Verify reaction is added
    const reactionButton = feedbackEntry.getByTestId('emoji-reaction-🚀');
    await expect(reactionButton).toBeVisible();
    await expect(reactionButton).toContainText('1');

    // Test: Reaction should still be present after refresh
    const refreshedFeedbackEntry = page.locator('[data-testid="feedback-entry"]').first();
    const persistedReaction = refreshedFeedbackEntry.getByTestId('emoji-reaction-🚀');
    
    await expect(persistedReaction).toBeVisible();
    await expect(persistedReaction).toContainText('1');

🗄️  Resetting database for E2E tests...
🗑️  Removing existing database...
🔄 Running database migrations...
🚀 Running all pending migrations...
✅ All migrations applied successfully

🗄️ Resetting database for E2E tests...
🚀 Running all pending migrations...
✅ All migrations applied successfully

	// DeleteFeedback deletes a feedback session (owner only)
	DeleteFeedback(ctx context.Context, feedbackID string, userID string) error
	// AddEmojiReaction adds or toggles an emoji reaction to feedback
	AddEmojiReaction(ctx context.Context, feedbackID string, userID string, emoji string) error
	// RemoveEmojiReaction removes an emoji reaction from feedback
	RemoveEmojiReaction(ctx context.Context, feedbackID string, userID string, emoji string) error
	// GetEmojiReactions gets all emoji reactions for a feedback entry
	GetEmojiReactions(ctx context.Context, feedbackID string) ([]EmojiReaction, error)

// UpdateFeedbackRequest represents the data needed to update feedback content and topics
type UpdateFeedbackRequest struct {
	FeedbackID     string
	UserID         string
	Content        string
	SelectedTopics []string
}

// EmojiReaction represents an emoji reaction to feedback
type EmojiReaction struct {
	Emoji     string   `json:"emoji"`
	Count     int      `json:"count"`
	Users     []string `json:"users"`
	HasReacted bool    `json:"hasReacted"` // Whether the requesting user has reacted with this emoji
}

// FeedbackEntry represents a feedback entry with all related data
type FeedbackEntry struct {
	ID        string          `json:"id"`
	Content   string          `json:"content"`
	Topics    []string        `json:"topics"`
	Author    string          `json:"author"`    // Display name for the author
	AuthorID  string          `json:"author_id"` // Internal user ID
	CreatedAt time.Time       `json:"created_at"`
	IsPublic  bool            `json:"is_public"`
	IsOwn     bool            `json:"is_own"` // Whether this feedback belongs to the requesting user
	Reactions []EmojiReaction `json:"reactions,omitempty"`
}

  return nil
}

// AddEmojiReaction adds or toggles an emoji reaction to feedback
func (r *feedbackRepository) AddEmojiReaction(ctx context.Context, feedbackID string, userID string, emoji string) error {
	// Get fresh database connection
	db, err := database.GetDB()
	if err != nil {
		return err
	}
	defer db.Close()

	// Verify user has access to this feedback (must be board member)
	_, err = r.accessControlService.CheckFeedbackAccess(db, userID, feedbackID)
	if err != nil {
		return err
	}

	// Get member ID for this user
	var memberID string
	err = database.QueryRowWithRetry(db, `
		SELECT m.id FROM members m 
		INNER JOIN feedback_sessions fs ON m.board_id = fs.board_id
		WHERE fs.id = ? AND m.user_id = ?
	`, feedbackID, userID).Scan(&memberID)
	if err != nil {
		if err == sql.ErrNoRows {
			return domain.ErrUnauthorized
		}
		return err
	}

	// Check if reaction already exists
	var existingID string
	err = database.QueryRowWithRetry(db, `
		SELECT id FROM feedback_reactions 
		WHERE feedback_session_id = ? AND member_id = ? AND emoji = ?
	`, feedbackID, memberID, emoji).Scan(&existingID)

	if err == nil {
		// Reaction exists, remove it (toggle off)
		_, err = database.ExecWithRetry(db, `
			DELETE FROM feedback_reactions 
			WHERE id = ?
		`, existingID)
		return err
	} else if err == sql.ErrNoRows {
		// Reaction doesn't exist, add it
		reactionID := uuid.New().String()
		_, err = database.ExecWithRetry(db, `
			INSERT INTO feedback_reactions (id, feedback_session_id, member_id, emoji, created_at)
			VALUES (?, ?, ?, ?, ?)
		`, reactionID, feedbackID, memberID, emoji, time.Now())
		return err
	}

	return err
}

// RemoveEmojiReaction removes an emoji reaction from feedback
func (r *feedbackRepository) RemoveEmojiReaction(ctx context.Context, feedbackID string, userID string, emoji string) error {
	// Get fresh database connection
	db, err := database.GetDB()
	if err != nil {
		return err
	}
	defer db.Close()

	// Verify user has access to this feedback
	_, err = r.accessControlService.CheckFeedbackAccess(db, userID, feedbackID)
	if err != nil {
		return err
	}

	// Get member ID for this user
	var memberID string
	err = database.QueryRowWithRetry(db, `
		SELECT m.id FROM members m 
		INNER JOIN feedback_sessions fs ON m.board_id = fs.board_id
		WHERE fs.id = ? AND m.user_id = ?
	`, feedbackID, userID).Scan(&memberID)
	if err != nil {
		if err == sql.ErrNoRows {
			return domain.ErrUnauthorized
		}
		return err
	}

	// Remove the reaction
	result, err := database.ExecWithRetry(db, `
		DELETE FROM feedback_reactions 
		WHERE feedback_session_id = ? AND member_id = ? AND emoji = ?
	`, feedbackID, memberID, emoji)
	if err != nil {
		return err
	}

	// Check if reaction was actually removed
	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return err
	}

	if rowsAffected == 0 {
		return domain.ErrNotFound // Reaction not found
	}

	return nil
}

// GetEmojiReactions gets all emoji reactions for a feedback entry
func (r *feedbackRepository) GetEmojiReactions(ctx context.Context, feedbackID string) ([]repositories.EmojiReaction, error) {
	// Get fresh database connection
	db, err := database.GetDB()
	if err != nil {
		return nil, err
	}
	defer db.Close()

	// Query reactions grouped by emoji
	rows, err := database.QueryWithRetry(db, `
		SELECT 
			fr.emoji,
			COUNT(*) as count,
			GROUP_CONCAT(m.user_id) as users
		FROM feedback_reactions fr
		INNER JOIN members m ON fr.member_id = m.id
		WHERE fr.feedback_session_id = ?
		GROUP BY fr.emoji
		ORDER BY fr.emoji
	`, feedbackID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var reactions []repositories.EmojiReaction
	for rows.Next() {
		var emoji, usersStr string
		var count int

		err := rows.Scan(&emoji, &count, &usersStr)
		if err != nil {
			return nil, err
		}

		// Parse users
		var users []string
		if usersStr != "" {
			users = strings.Split(usersStr, ",")
		}

		reaction := repositories.EmojiReaction{
			Emoji:      emoji,
			Count:      count,
			Users:      users,
			HasReacted: false, // Will be set by caller based on requesting user
		}
		reactions = append(reactions, reaction)
	}

	if err = rows.Err(); err != nil {
		return nil, err
	}

	// Return empty array if no reactions found
	if reactions == nil {
		reactions = []repositories.EmojiReaction{}
	}

	return reactions, nil
}

	if rowsAffected == 0 {
		return domain.ErrNotFound // Feedback not found
	}

	return nil
}

// AddEmojiReaction adds or toggles an emoji reaction to feedback
func (r *feedbackRepository) AddEmojiReaction(ctx context.Context, feedbackID string, userID string, emoji string) error {
	// Get fresh database connection
	db, err := database.GetDB()
	if err != nil {
		return err
	}
	defer db.Close()

	// Verify user has access to this feedback (must be board member)
	_, err = r.accessControlService.CheckFeedbackAccess(db, userID, feedbackID)
	if err != nil {
		return err
	}

	// Get member ID for this user
	var memberID string
	err = database.QueryRowWithRetry(db, `
		SELECT m.id FROM members m 
		INNER JOIN feedback_sessions fs ON m.board_id = fs.board_id
		WHERE fs.id = ? AND m.user_id = ?
	`, feedbackID, userID).Scan(&memberID)
	if err != nil {
		if err == sql.ErrNoRows {
			return domain.ErrUnauthorized
		}
		return err
	}

	// Check if reaction already exists
	var existingID string
	err = database.QueryRowWithRetry(db, `
		SELECT id FROM feedback_reactions 
		WHERE feedback_session_id = ? AND member_id = ? AND emoji = ?
	`, feedbackID, memberID, emoji).Scan(&existingID)

	if err == nil {
		// Reaction exists, remove it (toggle off)
		_, err = database.ExecWithRetry(db, `
			DELETE FROM feedback_reactions 
			WHERE id = ?
		`, existingID)
		return err
	} else if err == sql.ErrNoRows {
		// Reaction doesn't exist, add it
		reactionID := uuid.New().String()
		_, err = database.ExecWithRetry(db, `
			INSERT INTO feedback_reactions (id, feedback_session_id, member_id, emoji, created_at)
			VALUES (?, ?, ?, ?, ?)
		`, reactionID, feedbackID, memberID, emoji, time.Now())
		return err
	}

	return err
}

// RemoveEmojiReaction removes an emoji reaction from feedback
func (r *feedbackRepository) RemoveEmojiReaction(ctx context.Context, feedbackID string, userID string, emoji string) error {
	// Get fresh database connection
	db, err := database.GetDB()
	if err != nil {
		return err
	}
	defer db.Close()

	// Verify user has access to this feedback
	_, err = r.accessControlService.CheckFeedbackAccess(db, userID, feedbackID)
	if err != nil {
		return err
	}

	// Get member ID for this user
	var memberID string
	err = database.QueryRowWithRetry(db, `
		SELECT m.id FROM members m 
		INNER JOIN feedback_sessions fs ON m.board_id = fs.board_id
		WHERE fs.id = ? AND m.user_id = ?
	`, feedbackID, userID).Scan(&memberID)
	if err != nil {
		if err == sql.ErrNoRows {
			return domain.ErrUnauthorized
		}
		return err
	}

	// Remove the reaction
	result, err := database.ExecWithRetry(db, `
		DELETE FROM feedback_reactions 
		WHERE feedback_session_id = ? AND member_id = ? AND emoji = ?
	`, feedbackID, memberID, emoji)
	if err != nil {
		return err
	}

	// Check if reaction was actually removed
	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return err
	}

	if rowsAffected == 0 {
		return domain.ErrNotFound // Reaction not found
	}

	return nil
}

// GetEmojiReactions gets all emoji reactions for a feedback entry
func (r *feedbackRepository) GetEmojiReactions(ctx context.Context, feedbackID string) ([]repositories.EmojiReaction, error) {
	// Get fresh database connection
	db, err := database.GetDB()
	if err != nil {
		return nil, err
	}
	defer db.Close()

	// Query reactions grouped by emoji
	rows, err := database.QueryWithRetry(db, `
		SELECT 
			fr.emoji,
			COUNT(*) as count,
			GROUP_CONCAT(m.user_id) as users
		FROM feedback_reactions fr
		INNER JOIN members m ON fr.member_id = m.id
		WHERE fr.feedback_session_id = ?
		GROUP BY fr.emoji
		ORDER BY fr.emoji
	`, feedbackID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var reactions []repositories.EmojiReaction
	for rows.Next() {
		var emoji, usersStr string
		var count int

		err := rows.Scan(&emoji, &count, &usersStr)
		if err != nil {
			return nil, err
		}

		// Parse users
		var users []string
		if usersStr != "" {
			users = strings.Split(usersStr, ",")
		}

		reaction := repositories.EmojiReaction{
			Emoji:      emoji,
			Count:      count,
			Users:      users,
			HasReacted: false, // Will be set by caller based on requesting user
		}
		reactions = append(reactions, reaction)
	}

	if err = rows.Err(); err != nil {
		return nil, err
	}

	// Return empty array if no reactions found
	if reactions == nil {
		reactions = []repositories.EmojiReaction{}
	}

	return reactions, nil
}

// ... existing code ...

// AddEmojiReaction adds or toggles an emoji reaction to feedback
func (r *feedbackRepository) AddEmojiReaction(ctx context.Context, feedbackID string, userID string, emoji string) error {
	// Get fresh database connection
	db, err := database.GetDB()
	if err != nil {
		return err
	}
	defer db.Close()

	// Verify user has access to this feedback (must be board member)
	_, err = r.accessControlService.CheckFeedbackAccess(db, userID, feedbackID)
	if err != nil {
		return err
	}

	// Get member ID for this user
	var memberID string
	err = database.QueryRowWithRetry(db, `
		SELECT m.id FROM members m 
		INNER JOIN feedback_sessions fs ON m.board_id = fs.board_id
		WHERE fs.id = ? AND m.user_id = ?
	`, feedbackID, userID).Scan(&memberID)
	if err != nil {
		if err == sql.ErrNoRows {
			return domain.ErrUnauthorized
		}
		return err
	}

	// Check if reaction already exists
	var existingID string
	err = database.QueryRowWithRetry(db, `
		SELECT id FROM feedback_reactions 
		WHERE feedback_session_id = ? AND member_id = ? AND emoji = ?
	`, feedbackID, memberID, emoji).Scan(&existingID)

	if err == nil {
		// Reaction exists, remove it (toggle off)
		_, err = database.ExecWithRetry(db, `
			DELETE FROM feedback_reactions 
			WHERE id = ?
		`, existingID)
		return err
	} else if err == sql.ErrNoRows {
		// Reaction doesn't exist, add it
		reactionID := uuid.New().String()
		_, err = database.ExecWithRetry(db, `
			INSERT INTO feedback_reactions (id, feedback_session_id, member_id, emoji, created_at)
			VALUES (?, ?, ?, ?, ?)
		`, reactionID, feedbackID, memberID, emoji, time.Now())
		return err
	}

	return err
}

// RemoveEmojiReaction removes an emoji reaction from feedback
func (r *feedbackRepository) RemoveEmojiReaction(ctx context.Context, feedbackID string, userID string, emoji string) error {
	// Get fresh database connection
	db, err := database.GetDB()
	if err != nil {
		return err
	}
	defer db.Close()

	// Verify user has access to this feedback
	_, err = r.accessControlService.CheckFeedbackAccess(db, userID, feedbackID)
	if err != nil {
		return err
	}

	// Get member ID for this user
	var memberID string
	err = database.QueryRowWithRetry(db, `
		SELECT m.id FROM members m 
		INNER JOIN feedback_sessions fs ON m.board_id = fs.board_id
		WHERE fs.id = ? AND m.user_id = ?
	`, feedbackID, userID).Scan(&memberID)
	if err != nil {
		if err == sql.ErrNoRows {
			return domain.ErrUnauthorized
		}
		return err
	}

	// Remove the reaction
	result, err := database.ExecWithRetry(db, `
		DELETE FROM feedback_reactions 
		WHERE feedback_session_id = ? AND member_id = ? AND emoji = ?
	`, feedbackID, memberID, emoji)
	if err != nil {
		return err
	}

	// Check if reaction was actually removed
	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return err
	}

	if rowsAffected == 0 {
		return domain.ErrNotFound // Reaction not found
	}

	return nil
}

// GetEmojiReactions gets all emoji reactions for a feedback entry
func (r *feedbackRepository) GetEmojiReactions(ctx context.Context, feedbackID string) ([]repositories.EmojiReaction, error) {
	// Get fresh database connection
	db, err := database.GetDB()
	if err != nil {
		return nil, err
	}
	defer db.Close()

	// Query reactions grouped by emoji
	rows, err := database.QueryWithRetry(db, `
		SELECT 
			fr.emoji,
			COUNT(*) as count,
			GROUP_CONCAT(m.user_id) as users
		FROM feedback_reactions fr
		INNER JOIN members m ON fr.member_id = m.id
		WHERE fr.feedback_session_id = ?
		GROUP BY fr.emoji
		ORDER BY fr.emoji
	`, feedbackID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var reactions []repositories.EmojiReaction
	for rows.Next() {
		var emoji, usersStr string
		var count int

		err := rows.Scan(&emoji, &count, &usersStr)
		if err != nil {
			return nil, err
		}

		// Parse users
		var users []string
		if usersStr != "" {
			users = strings.Split(usersStr, ",")
		}

		reaction := repositories.EmojiReaction{
			Emoji:      emoji,
			Count:      count,
			Users:      users,
			HasReacted: false, // Will be set by caller based on requesting user
		}
		reactions = append(reactions, reaction)
	}

	if err = rows.Err(); err != nil {
		return nil, err
	}

	// Return empty array if no reactions found
	if reactions == nil {
		reactions = []repositories.EmojiReaction{}
	}

	return reactions, nil
}