// api/rapids/rogues/operations/getRogueApList.methods.ts
import { IExecuteFunctions, INodeExecutionData, IDataObject } from 'n8n-workflow';
import { apiRequest } from '../../../../helpers/apiRequest';
import { handleApiError } from '../../../../helpers/errorHandler';
import { logger } from '../../../../helpers/logger';
import { formatResponse } from '../../../../helpers/responseFormatter';
import { handlePagination } from '../../../../helpers/pagination';

/**
 * Get rogue APs over a time period
 *
 * @param this The n8n execution context
 * @returns List of rogue APs
 */
export async function getRogueApList(this: IExecuteFunctions): Promise<INodeExecutionData[]> {
	try {
		const returnAll = this.getNodeParameter('returnAll', 0, true) as boolean;
		const limit = this.getNodeParameter('limit', 0, 100) as number;
		const additionalFields = this.getNodeParameter('additionalFields', 0, {}) as IDataObject;

		logger.debug('rapids:rogues:getRogueApList', 'Retrieving rogue AP list');

		// Build query parameters
		const queryParams: IDataObject = {};

		// Time range parameters
		try {
			const timeRange = this.getNodeParameter('timeRange', 0, {}) as IDataObject;
			if (timeRange.from_timestamp) {
				queryParams.from_timestamp = Math.floor(
					new Date(timeRange.from_timestamp as string).getTime() / 1000,
				);
			}
			if (timeRange.to_timestamp) {
				queryParams.to_timestamp = Math.floor(
					new Date(timeRange.to_timestamp as string).getTime() / 1000,
				);
			}
		} catch (e) {
			// Time range not specified
		}

		// Handle site parameter - must be an array for rogue_aps
		if (additionalFields.site) {
			if (typeof additionalFields.site === 'string' && additionalFields.site.trim() !== '') {
				// Convert the string to an array with a single value - this is critical
				queryParams.site = [additionalFields.site.trim()];
				logger.debug(
					'rapids:rogues:getRogueApList',
					`Site parameter set to array: ${JSON.stringify(queryParams.site)}`,
				);
			}
		}

		// Handle group parameter - must be an array
		if (additionalFields.group) {
			if (typeof additionalFields.group === 'string' && additionalFields.group.trim() !== '') {
				queryParams.group = [additionalFields.group.trim()];
				logger.debug(
					'rapids:rogues:getRogueApList',
					`Group parameter set to array: ${JSON.stringify(queryParams.group)}`,
				);
			}
		}

		// Handle label parameter - must be an array
		if (additionalFields.label) {
			if (typeof additionalFields.label === 'string' && additionalFields.label.trim() !== '') {
				queryParams.label = [additionalFields.label.trim()];
				logger.debug(
					'rapids:rogues:getRogueApList',
					`Label parameter set to array: ${JSON.stringify(queryParams.label)}`,
				);
			}
		}

		// Handle swarm_id parameter - regular string
		if (additionalFields.swarm_id && typeof additionalFields.swarm_id === 'string') {
			queryParams.swarm_id = additionalFields.swarm_id.trim();
		}

		// Set pagination parameters
		if (!returnAll) {
			queryParams.limit = limit;
		}

		const endpoint = '/rapids/v1/rogue_aps';

		// Log the final query parameters for debugging
		logger.debug('rapids:rogues:getRogueApList:params', JSON.stringify(queryParams));

		// Log request details
		logger.debug('rapids:rogues:getRogueApList:request', {
			method: 'GET',
			endpoint,
			queryParams,
		});

		// Use pagination or direct request
		if (returnAll) {
			return await handlePagination.call(
				this,
				endpoint,
				'GET',
				{},
				queryParams,
				{
					path: ['rogue_aps'],
					fallbackPaths: [['data', 'rogue_aps']],
				},
				true,
				undefined,
				1000,
			);
		} else {
			const response = await apiRequest.call(this, 'GET', endpoint, {}, queryParams);

			// Log response details
			if (response) {
				logger.debug('rapids:rogues:getRogueApList:response', {
					count: response.count,
					total: response.total,
					items: response.rogue_aps ? response.rogue_aps.length : 0,
				});

				if (response.rogue_aps && response.rogue_aps.length > 0) {
					logger.debug('rapids:rogues:getRogueApList:firstItem', {
						id: response.rogue_aps[0].id,
						ssid: response.rogue_aps[0].ssid,
						classification: response.rogue_aps[0].classification,
					});
				}
			}

			return formatResponse(response);
		}
	} catch (error) {
		logger.error('rapids:rogues:getRogueApList:error', error.message || 'Unknown error');
		return handleApiError.call(this, error, 'Failed to retrieve rogue AP list');
	}
}