import { IExecuteFunctions, INodeExecutionData, IDataObject } from 'n8n-workflow';
import { apiRequest } from '../../../../helpers/apiRequest';
import { logger } from '../../../../helpers/logger';
import { handleApiError } from '../../../../helpers/errorHandler';

/**
 * Get Swarms
 * GET /monitoring/v1/swarms
 *
 * @param this The n8n execution context
 * @returns Formatted API response
 */
export async function getSwarms(this: IExecuteFunctions): Promise<INodeExecutionData[]> {
	try {
		const returnAll = this.getNodeParameter('returnAll', 0, false) as boolean;

		// Get additional fields
		const additionalFields = this.getNodeParameter('additionalFields', 0, {}) as IDataObject;
		const status = additionalFields.status as string;
		const public_ip_address = additionalFields.public_ip_address as string;
		const fields = additionalFields.fields as string;
		const calculate_total = additionalFields.calculate_total as boolean;
		const sort = additionalFields.sort as string;
		const swarm_name = additionalFields.swarm_name as string;

		// Construct request options
		const options: IDataObject = {};

		if (additionalFields.status !== undefined) {
			options.qs = options.qs || {};
			options.qs.status = status;
		}
		if (additionalFields.public_ip_address !== undefined) {
			options.qs = options.qs || {};
			options.qs.public_ip_address = public_ip_address;
		}
		if (additionalFields.fields !== undefined) {
			options.qs = options.qs || {};
			options.qs.fields = fields;
		}
		if (additionalFields.calculate_total !== undefined) {
			options.qs = options.qs || {};
			options.qs.calculate_total = calculate_total;
		}
		if (additionalFields.sort !== undefined) {
			options.qs = options.qs || {};
			options.qs.sort = sort;
		}
		if (additionalFields.swarm_name !== undefined) {
			options.qs = options.qs || {};
			options.qs.swarm_name = swarm_name;
		}

		// Construct API endpoint
		const endpoint = '/monitoring/v1/swarms';

		// Handle pagination
		if (returnAll) {
			const responseData: IDataObject[] = await apiRequestAllItems.call(
				this,
				'GET',
				endpoint,
				options,
			);
			return [{ json: responseData }];
		}

		// Make API request
		const responseData = await apiRequest.call(this, 'GET', endpoint, options);

		// Format and return response
		return [{ json: responseData }];
	} catch (error) {
		logger.error('monitoring:swarm:getSwarms:error', { message: error.message });
		return handleApiError.call(this, error, 'Failed to execute get swarms');
	}
}

/**
 * Helper for pagination to fetch all items from a paginated API endpoint
 *
 * @param this The n8n execution context
 * @param method HTTP method to use
 * @param endpoint API endpoint to call
 * @param options Request options
 * @returns Combined array of all items across pages
 */
async function apiRequestAllItems(
	this: IExecuteFunctions,
	method: string,
	endpoint: string,
	options: IDataObject = {},
): Promise<IDataObject[]> {
	const returnData: IDataObject[] = [];
	let responseData;

	const limit = this.getNodeParameter('limit', 0, 0) as number;
	options.qs = options.qs || {};

	let hasMore = true;
	let offset = 0;
	options.qs.limit = limit > 0 ? (limit > 100 ? 100 : limit) : 100;

	do {
		options.qs.offset = offset;
		responseData = await apiRequest.call(this, method, endpoint, options);

		// This needs to be adjusted based on actual API response format
		const items = responseData.items || responseData.data || responseData;

		if (Array.isArray(items)) {
			returnData.push.apply(returnData, items);
		} else {
			returnData.push(items as IDataObject);
		}

		// If limit is set, honor it
		if (limit > 0 && returnData.length >= limit) {
			returnData.splice(limit);
			hasMore = false;
		} else if (items && Array.isArray(items)) {
			// If less items than requested were returned, assume no more items
			if (items.length < options.qs.limit) {
				hasMore = false;
			} else {
				offset += options.qs.limit;
			}
		} else {
			hasMore = false;
		}
	} while (hasMore);

	return returnData;
}