const { logger } = require('../../middleware/logger');

class PoolMemberRepository {
  constructor(uow) {
    this.uow = uow;
  }

  async listMembers(poolId) {
    const conn = this.uow.connection;
    try {
      logger.info('PoolMemberRepository.listMembers:start', { poolId });
      const [rows] = await conn.execute(
        `SELECT 
          u.id,
          u.email,
          u.user_type,
          u.role,
          pp.first_name,
          pp.last_name,
          cp.company_name,
          pm.joined_at
        FROM pool_members pm
        JOIN users u ON u.id = pm.user_id
        LEFT JOIN personal_profiles pp ON u.id = pp.user_id
        LEFT JOIN company_profiles cp ON u.id = cp.user_id
        WHERE pm.pool_id = ?
        ORDER BY pm.joined_at DESC`,
        [poolId]
      );
      logger.info('PoolMemberRepository.listMembers:success', { poolId, count: rows.length });
      return rows;
    } catch (error) {
      logger.error('PoolMemberRepository.listMembers:error', { poolId, error: error.message });
      throw error;
    }
  }

  async addMembers(poolId, userIds, actorUserId = null) {
    const conn = this.uow.connection;
    if (!Array.isArray(userIds) || userIds.length === 0) return [];

    try {
      logger.info('PoolMemberRepository.addMembers:start', { poolId, count: userIds.length, actorUserId });
      const placeholders = userIds.map(() => '(?, ?, ?)').join(', ');
      const params = [];
      for (const userId of userIds) {
        params.push(poolId, userId, actorUserId);
      }

      await conn.execute(
        `INSERT INTO pool_members (pool_id, user_id, created_by)
         VALUES ${placeholders}
         ON DUPLICATE KEY UPDATE updated_at = CURRENT_TIMESTAMP`,
        params
      );

      logger.info('PoolMemberRepository.addMembers:success', { poolId, count: userIds.length });
      return true;
    } catch (error) {
      logger.error('PoolMemberRepository.addMembers:error', { poolId, error: error.message });
      throw error;
    }
  }
}

module.exports = PoolMemberRepository;