const express = require('express');
const router = express.Router();
const { GroupRepository, GroupMemberRepository } = require('../repositories');
const logger = require('../../../src/utils/logger');

/**
 * Get all groups for the site
 * GET /api/plugins/voting/groups
 */
router.get('/', async (req, res) => {
  try {
    const siteId = req.query.site_id || req.user?.siteId;
    
    const groupRepo = new GroupRepository();
    const filters = { site_id: siteId };
    const options = {
      orderBy: 'created_at',
      orderDirection: 'desc'
    };
    
    const groups = await groupRepo.findWithFilters(filters, options);
    
    res.json({
      success: true,
      data: groups
    });
  } catch (error) {
    logger.error('Failed to get groups:', error);
    res.status(500).json({
      success: false,
      error: 'Failed to retrieve groups',
      message: error.message
    });
  }
});

/**
 * Get a specific group by ID
 * GET /api/plugins/voting/groups/:id
 */
router.get('/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const groupRepo = new GroupRepository();
    const group = await groupRepo.findOne({ id });
    
    if (!group) {
      return res.status(404).json({
        success: false,
        error: 'Group not found'
      });
    }
    
    res.json({
      success: true,
      data: group
    });
  } catch (error) {
    logger.error('Failed to get group:', error);
    res.status(500).json({
      success: false,
      error: 'Failed to retrieve group',
      message: error.message
    });
  }
});

/**
 * Create a new group
 * POST /api/plugins/voting/groups
 */
router.post('/', async (req, res) => {
  try {
    const groupRepo = new GroupRepository();
    const groupData = {
      ...req.body,
      created_by: req.user?.id,
      created_at: new Date().toISOString(),
      updated_at: new Date().toISOString()
    };
    
    const group = await groupRepo.create(groupData);
    
    res.status(201).json({
      success: true,
      data: group,
      message: 'Group created successfully'
    });
  } catch (error) {
    logger.error('Failed to create group:', error);
    res.status(500).json({
      success: false,
      error: 'Failed to create group',
      message: error.message
    });
  }
});

/**
 * Update a group
 * PUT /api/plugins/voting/groups/:id
 */
router.put('/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const groupRepo = new GroupRepository();
    
    const updateData = {
      ...req.body,
      updated_at: new Date().toISOString()
    };
    
    const group = await groupRepo.updateById(id, updateData);
    
    if (!group) {
      return res.status(404).json({
        success: false,
        error: 'Group not found'
      });
    }
    
    res.json({
      success: true,
      data: group,
      message: 'Group updated successfully'
    });
  } catch (error) {
    logger.error('Failed to update group:', error);
    res.status(500).json({
      success: false,
      error: 'Failed to update group',
      message: error.message
    });
  }
});

/**
 * Delete a group
 * DELETE /api/plugins/voting/groups/:id
 */
router.delete('/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const groupRepo = new GroupRepository();
    
    const deleted = await groupRepo.deleteById(id);
    
    if (!deleted) {
      return res.status(404).json({
        success: false,
        error: 'Group not found'
      });
    }
    
  res.json({
    success: true,
    message: 'Group deleted successfully'
  });
} catch (error) {
  logger.error('Failed to delete group:', error);
  res.status(500).json({
    success: false,
    error: 'Failed to delete group',
    message: error.message
  });
}
});

/**
 * Add member to group
 * POST /api/plugins/voting/groups/:id/members
 */
router.post('/:id/members', async (req, res) => {
  try {
    const { id } = req.params;
    const { person_id } = req.body;
    
    if (!person_id) {
      return res.status(400).json({
        success: false,
        error: 'Missing required field: person_id'
      });
    }
    
    const memberRepo = new GroupMemberRepository();
    const member = await memberRepo.addMember(id, person_id);
    
    res.status(201).json({
      success: true,
      data: member,
      message: 'Member added successfully'
    });
  } catch (error) {
    logger.error('Failed to add member:', error);
    res.status(500).json({
      success: false,
      error: 'Failed to add member',
      message: error.message
    });
  }
});

/**
 * Remove member from group
 * DELETE /api/plugins/voting/groups/:id/members/:personId
 */
router.delete('/:id/members/:personId', async (req, res) => {
  try {
    const { id, personId } = req.params;
    
    const memberRepo = new GroupMemberRepository();
    const deleted = await memberRepo.removeMember(id, personId);
    
    if (!deleted) {
      return res.status(404).json({
        success: false,
        error: 'Member not found'
      });
    }
    
    res.json({
      success: true,
      message: 'Member removed successfully'
    });
  } catch (error) {
    logger.error('Failed to remove member:', error);
    res.status(500).json({
      success: false,
      error: 'Failed to remove member',
      message: error.message
    });
  }
});

/**
 * Get all members of a group
 * GET /api/plugins/voting/groups/:id/members
 */
router.get('/:id/members', async (req, res) => {
  try {
    const { id } = req.params;
    
    const memberRepo = new GroupMemberRepository();
    const members = await memberRepo.getGroupMembers(id);
    
    res.json({
      success: true,
      data: members
    });
  } catch (error) {
    logger.error('Failed to get group members:', error);
    res.status(500).json({
      success: false,
      error: 'Failed to retrieve group members',
      message: error.message
    });
  }
});

module.exports = router;