import { store } from 'redux/store';
import {
  DirectPaymentRequest,
  DirectPaymentResponse,
  MPResponse,
  type PaymentProcessRequest
} from '../types/payment.types';
import { withUnhandledRejectionHandler } from '../utils/session-handler';

export interface PaymentResponse {
  success: boolean;
  data?: any;
  error?: string;
}

export class PaymentService {
  private _token: string;
  private _merchantId: string;

  constructor(token?: string, merchantId?: string) {
    this._token = token || store.getState().masterpassRest.token || '';
    this._merchantId =
      merchantId || store.getState().masterpassRest.tokenData?.MerchantId || '';
    this.initialize();
  }

  private initialize(): void {
    window.Masterpass.setToken(this._token);
    window.Masterpass.setMerchantId(this._merchantId);
  }

  private extractErrorMessage(error: unknown, fallback: string): string {
    if (error instanceof Error) return error.message;
    if (typeof error === 'string') return error;
    return fallback;
  }

  async processPayment(
    paymentData: PaymentProcessRequest
  ): Promise<PaymentResponse> {
    return withUnhandledRejectionHandler(
      () =>
        new Promise((resolve) => {
          try {
            this.initialize();

            window.Masterpass.paymentService.payment(
              {
                requestReferenceNo: paymentData.requestReferenceNo,
                cvc: paymentData.cvc,
                cardAlias: paymentData.cardAlias,
                accountKey: paymentData.accountKey,
                amount: paymentData.amount,
                orderNo: paymentData.orderNo,
                currencyCode: paymentData.currencyCode,
                paymentType: paymentData.paymentType,
                acquirerIcaNumber: paymentData.acquirerIcaNumber,
                installmentCount: paymentData.installmentCount,
                authenticationMethod: paymentData.authenticationMethod,
                secure3DModel: paymentData.secure3DModel,
                terminalGroupId: paymentData.terminalGroupId,
                ...(paymentData.additionalFields || {})
              },
              (statusCode, response) => {
                if (response && response.statusCode === 200) {
                  resolve({
                    success: true,
                    data: response
                  });
                } else {
                  resolve({
                    success: false,
                    error: response?.description || 'Payment failed',
                    data: response
                  });
                }
              }
            );
          } catch (error) {
            resolve({
              success: false,
              error: this.extractErrorMessage(error, 'Payment service initialization failed')
            });
          }
        }),
      {
        success: false,
        error: 'Session has expired',
        data: {
          statusCode: 401,
          exception: {
            code: 'TOKEN_HAS_EXPIRED',
            message: 'Session has expired'
          }
        }
      }
    );
  }

  async directPayment(
    paymentData: DirectPaymentRequest
  ): Promise<PaymentResponse> {
    return withUnhandledRejectionHandler(
      () =>
        new Promise((resolve) => {
          try {
            this.initialize();

            window.Masterpass.paymentService.directPayment(
              {
                requestReferenceNo: paymentData.requestReferenceNo,
                cvc: paymentData.cvc,
                cardNumber: paymentData.cardNumber,
                cardHolderName: paymentData.cardHolderName,
                expiryDate: paymentData.expiryDate,
                accountKey: paymentData.accountKey,
                amount: paymentData.amount,
                orderNo: paymentData.orderNo,
                currencyCode: paymentData.currencyCode,
                paymentType: paymentData.paymentType,
                acquirerIcaNumber: paymentData.acquirerIcaNumber,
                installmentCount: paymentData.installmentCount,
                authenticationMethod: paymentData.authenticationMethod,
                secure3DModel: paymentData.secure3DModel,
                terminalGroupId: paymentData.terminalGroupId,
                ...(paymentData.additionalFields || {})
              },
              (
                statusCode: number,
                response: MPResponse<DirectPaymentResponse>
              ) => {
                if (response && response.statusCode === 200) {
                  resolve({
                    success: true,
                    data: response
                  });
                } else {
                  resolve({
                    success: false,
                    error:
                      response?.result?.responseDescription ||
                      response?.exception?.message ||
                      'Direct payment failed',
                    data: response
                  });
                }
              }
            );
          } catch (error) {
            resolve({
              success: false,
              error: this.extractErrorMessage(error, 'Direct payment service initialization failed')
            });
          }
        }),
      {
        success: false,
        error: 'Session has expired',
        data: {
          statusCode: 401,
          exception: {
            code: 'TOKEN_HAS_EXPIRED',
            message: 'Session has expired'
          }
        }
      }
    );
  }
}