import { IDeckRepository } from '../../../Domain/IRepository/IDeckRepository';
import { GetDecksByPageQuery } from './GetDecksByPageQuery';
import { ShortDeckDto } from '../../DTOs/DeckDto';
import { DeckMapper } from '../../DTOs/Mappers/DeckMapper';
import { AdminBypassService } from '../../Services/AdminBypassService';
import { logRequest, logError } from '../../Services/Logger';

export class GetDecksByPageQueryHandler {
  constructor(private readonly deckRepo: IDeckRepository) {}

  async execute(query: GetDecksByPageQuery): Promise<{ decks: ShortDeckDto[], totalCount: number }> {
    try {
      // Validate pagination parameters
      if (query.from < 0 || query.to < query.from) {
        throw new Error('Invalid pagination parameters');
      }

      const limit = query.to - query.from + 1;
      if (limit > 100) {
        throw new Error('Page size too large. Maximum 100 records per request');
      }

      // Log admin bypass if applicable
      if (query.isAdmin) {
        AdminBypassService.logAdminBypass(
          'GET_DECKS_PAGE_BYPASS',
          query.userId,
          'paginated-decks',
          {
            from: query.from,
            to: query.to,
            includesDeleted: query.includeDeleted || false,
            operation: 'read'
          }
        );
      }

      logRequest('Get decks by page query started', undefined, undefined, {
        userId: query.userId,
        userOrgId: query.userOrgId,
        isAdmin: query.isAdmin,
        from: query.from,
        to: query.to,
        includeDeleted: query.includeDeleted || false
      });

      // Use paginated filtered deck finding method
      const result = await this.deckRepo.findFilteredDecks(
        query.userId, 
        query.userOrgId,
        query.isAdmin,
        query.from,
        query.to
      );
      
      logRequest('Get decks by page query completed', undefined, undefined, {
        userId: query.userId,
        userOrgId: query.userOrgId,
        isAdmin: query.isAdmin,
        from: query.from,
        to: query.to,
        returned: result.decks.length,
        totalCount: result.totalCount,
        includeDeleted: query.includeDeleted || false
      });
      
      return {
        decks: DeckMapper.toShortDtoList(result.decks, query.userId),
        totalCount: result.totalCount
      };
    } catch (error) {
      logError('GetDecksByPageQueryHandler error', error instanceof Error ? error : new Error(String(error)));
      
      // Re-throw validation errors as-is
      if (error instanceof Error && (error.message.includes('Invalid pagination') || error.message.includes('Page size'))) {
        throw error;
      }
      
      throw new Error('Failed to retrieve decks page');
    }
  }
}