import { VerifyService } from '../services/verify';
import { enhance3DSecureUrl } from './payment-utils';
import { PAYMENT_CONSTANTS } from './payment-constants';
import { store } from 'redux/store';
import { updateModalState } from '../redux/reducer';

export type ResponseHandlerResult = {
  success: boolean;
  requiresOTP?: boolean;
  requires3D?: boolean;
  requiresCVV?: boolean;
  requiresRTA?: boolean;
  sessionExpired?: boolean;
  otpType?: 'OTP' | 'RTA' | 'CVV';
  data?: any;
  message?: string;
  redirectUrl?: string;
};

export const handleMasterpassResponse = async (
  response: any
): Promise<ResponseHandlerResult> => {
  const responseCode =
    response.responseCode || response.data?.result?.responseCode;

  switch (responseCode) {
    case PAYMENT_CONSTANTS.RESPONSE_CODES.RTA_VERIFICATION_REQUIRED:
      return {
        success: false,
        requiresOTP: true,
        requiresRTA: true,
        otpType: 'RTA',
        data: response.data || response
      };

    case PAYMENT_CONSTANTS.RESPONSE_CODES.BANK_OTP_REQUIRED:
    case PAYMENT_CONSTANTS.RESPONSE_CODES.MASTERPASS_OTP_REQUIRED:
      return {
        success: false,
        requiresOTP: true,
        otpType: 'OTP',
        data: response.data || response
      };

    case PAYMENT_CONSTANTS.RESPONSE_CODES.THREE_D_SECURE_REQUIRED:
      const url3d = response.url3d || response.data?.result?.url3d;
      if (!url3d) {
        return {
          success: false,
          message: '3D Secure URL not provided'
        };
      }

      const enhancedUrl = enhance3DSecureUrl(url3d);
      return {
        success: false,
        requires3D: true,
        redirectUrl: enhancedUrl
      };

    case PAYMENT_CONSTANTS.RESPONSE_CODES.CVV_VERIFICATION_REQUIRED:
      return {
        success: false,
        requiresOTP: true,
        requiresCVV: true,
        otpType: 'CVV',
        data: response.data || response
      };

    case PAYMENT_CONSTANTS.RESPONSE_CODES.SUCCESS:
      return {
        success: true,
        data: response.data || response
      };

    default:
      if (response.success || response.statusCode === 200) {
        return {
          success: true,
          data: response.data || response
        };
      }

      return {
        success: false,
        message:
          response.exception?.message ||
          response.error ||
          response.description ||
          response.result?.description ||
          'Unknown error occurred'
      };
  }
};

export const handleVerification = async (
  otp: string,
  token?: string,
  merchantId?: string
): Promise<ResponseHandlerResult> => {
  try {
    const verifyService = new VerifyService(token, merchantId);
    const response = await verifyService.verifyOtp({ otpCode: otp });

    if (response.statusCode === 200) {
      return {
        success: true,
        data: response
      };
    }

    if (response.statusCode === 202) {
      const responseCode = response.result?.responseCode;
      const description = response.result?.description;

      switch (responseCode) {
        case PAYMENT_CONSTANTS.RESPONSE_CODES.BANK_OTP_REQUIRED:
        case PAYMENT_CONSTANTS.RESPONSE_CODES.MASTERPASS_OTP_REQUIRED:
          return {
            success: false,
            requiresOTP: true,
            otpType: 'OTP',
            data: response,
            message: description
          };

        case PAYMENT_CONSTANTS.RESPONSE_CODES.RTA_VERIFICATION_REQUIRED:
          return {
            success: false,
            requiresOTP: true,
            requiresRTA: true,
            otpType: 'RTA',
            data: response,
            message: description
          };

        case PAYMENT_CONSTANTS.RESPONSE_CODES.CVV_VERIFICATION_REQUIRED:
          return {
            success: false,
            requiresOTP: true,
            requiresCVV: true,
            otpType: 'CVV',
            data: response,
            message: description
          };

        case PAYMENT_CONSTANTS.RESPONSE_CODES.THREE_D_SECURE_REQUIRED:
          const url3d = response.result?.url3d || response.result?.url3D;
          if (!url3d) {
            return {
              success: false,
              message: description || '3D Secure URL not provided'
            };
          }

          const enhancedUrl = enhance3DSecureUrl(url3d);
          return {
            success: false,
            requires3D: true,
            redirectUrl: enhancedUrl,
            message: description
          };

        default:
          return {
            success: true,
            data: response
          };
      }
    }

    const exceptionCode = response.exception?.code;
    if (exceptionCode === PAYMENT_CONSTANTS.EXCEPTION_CODES.TOKEN_HAS_EXPIRED) {
      return {
        success: false,
        sessionExpired: true,
        message: response.exception?.message || 'Session has expired'
      };
    }

    return {
      success: false,
      message:
        response.exception?.message ||
        response.result?.description ||
        'Verification failed'
    };
  } catch (error) {
    return {
      success: false,
      message:
        error instanceof Error ? error.message : 'An unexpected error occurred'
    };
  }
};

export const handleResendOtp = async (
  token?: string,
  merchantId?: string
): Promise<ResponseHandlerResult> => {
  try {
    const verifyService = new VerifyService(token, merchantId);
    const state = store.getState();
    const otpToken = state.masterpassRest.modalState.verificationData?.result?.token;

    const response = await verifyService.resendOtp(otpToken);

    if (response.statusCode === 200 || response.statusCode === 202) {
      const newToken = response.result?.token;
      if (newToken) {
        store.dispatch(updateModalState({
          verificationData: response
        }));
      }

      return {
        success: true,
        data: response,
        message: 'OTP sent successfully'
      };
    }

    return {
      success: false,
      message:
        response.exception?.message ||
        response.result?.description ||
        'Failed to resend OTP'
    };
  } catch (error) {
    return {
      success: false,
      message:
        error instanceof Error ? error.message : 'An unexpected error occurred'
    };
  }
};