/**
 * Copyright IBM Corp. 2024, 2025
 */
import { IpcError, Logger } from '@apic/studio-shared';
import { AppConstants } from '../constants/app-constants.js';
import { GatewaysJson } from '../index.js';
import { sendToGateway, validationManager } from '../service/gateway-service.js';
import { WMGWRuntimeSDK } from '@apic/wmgw-smith-sdk';

export const processDeployment = async (gatewaysJsonContent: GatewaysJson, zipBuffer: Buffer) => {
  const gatewayResponses = [];

  if (gatewaysJsonContent.gateways && gatewaysJsonContent.gateways.length > 0) {
    Logger.info('Starting deployment process', {
      gatewayCount: gatewaysJsonContent.gateways.length,
    });

    for (const gateway of gatewaysJsonContent.gateways) {
      const { gatewayURL, gatewayUser, gatewaySecret, is_mcsp_enabled } = gateway;
      Logger.debug('Deploying to gateway', { gatewayURL });

      let transformedZipBuffer: Buffer = zipBuffer;
      const wmgwSdk = new WMGWRuntimeSDK();

      try {
        transformedZipBuffer = await wmgwSdk.transformer.transform(zipBuffer);
      } catch (e) {
        Logger.error(
          'Failed to transform ZIP Buffer',
          e instanceof Error ? e : new Error(String(e)),
          { context: 'Transforming Buffer' }
        );
      }

      try {
        const response = await sendToGateway(
          gatewayURL,
          gatewayUser,
          gatewaySecret,
          is_mcsp_enabled,
          transformedZipBuffer,
          gatewaysJsonContent
        );
        Logger.debug('Gateway deployment successful', {
          response: response.data,
        });
        gatewayResponses.push(response);
      } catch (error) {
        if (error instanceof Error) {
          const errorMessage = `Error sending to ${gatewayURL}: ${error.message}`;
          Logger.error('Deployment failed', error, {
            context: 'deploying to',
            gatewayURL,
          });
          gatewayResponses.push({
            success: false,
            statusCode: 400,
            message: errorMessage,
            data: null,
            errors: [errorMessage],
          });
        } else {
          const unknownErrorMessage = `Unknown error sending to ${gatewayURL}`;
          Logger.error('Unknown deployment error', new Error(unknownErrorMessage), {
            gatewayURL,
          });
          gatewayResponses.push({
            success: false,
            statusCode: 400,
            message: unknownErrorMessage,
            data: null,
            errors: [unknownErrorMessage],
          });
        }
      }
    }
  } else {
    Logger.warn('No gateways to deploy.');
  }

  Logger.info('Deployment process completed.');
  return gatewayResponses;
};

export async function validateGateways(
  url: string,
  authHeader: string
): Promise<{ data: string; status: number }> {
  if (!url || !authHeader) {
    throw new IpcError(
      'Invalid parameters: URL and Authorization Header are required.',
      400,
      'Invalid parameters: URL and Authorization Header are required.'
    );
  }

  return validationManager(`${url}${AppConstants.GATEWAY_VALIDATION_URL}`, authHeader);
}