type ApiErrorType =
  | 'policy_violation'
  | 'permission_denied'
  | 'not_found'
  | 'unknown'
  | 'already_created'
  | 'passkey_not_allowed'
  | 'fetch_error'
  | 'unsupported_chain_id'
  | 'insufficient_credit'
  | 'invalid_nonce'
  | 'rate_limit_exceeded'
  | 'recipient_not_allowed';
type CreateWalletErrorType = 'already_created' | 'passkey_not_allowed';
type RecoverWalletErrorType =
  | 'wallet_not_found'
  | 'passkey_not_allowed'
  | 'passkey_not_found';
type TransferErrorType =
  | 'transfer_failed'
  | 'passkey_not_allowed'
  | 'not_initialized';
type ExecuteOperationErrorType = 'not_initialized';

type DistributionErrorType =
  | 'no_enough_cool_time'
  | 'exceed_max_distribute_amount'
  | 'insufficient_funds_in_distribution_request'
  | 'distribute_invalid_request'
  | 'generate_secret_failed';

type SDKErrorType =
  | CreateWalletErrorType
  | RecoverWalletErrorType
  | TransferErrorType
  | ExecuteOperationErrorType
  | DistributionErrorType
  | ApiErrorType;

export class PrexSDKError extends Error {
  constructor(
    public readonly error: SDKErrorType,
    public readonly details: string
  ) {
    super(details);
  }

  static fromError(error: Error): PrexSDKError {
    if (error.message.includes('rule check failed')) {
      return new PrexSDKError('policy_violation', error.message);
    } else if (error.message.includes('insufficient_credit')) {
      return new PrexSDKError('insufficient_credit', error.message);
    } else if (error.message.includes('Unsupported chainId')) {
      return new PrexSDKError('unsupported_chain_id', error.message);
    } else if (error.message.includes('no_enough_cool_time')) {
      return new PrexSDKError('no_enough_cool_time', error.message);
    } else if (error.message.includes('exceed_max_distribute_amount')) {
      return new PrexSDKError('exceed_max_distribute_amount', error.message);
    } else if (error.message.includes('invalid_nonce')) {
      return new PrexSDKError('invalid_nonce', error.message);
    } else if (
      error.message.includes('insufficient_funds_in_distribution_request')
    ) {
      return new PrexSDKError(
        'insufficient_funds_in_distribution_request',
        error.message
      );
    } else if (error.message.includes('distribute_invalid_request')) {
      return new PrexSDKError('distribute_invalid_request', error.message);
    } else if (error.message.includes('Permission Denied')) {
      return new PrexSDKError('permission_denied', error.message);
    } else if (error.message.includes('rate limit exceeded')) {
      return new PrexSDKError('rate_limit_exceeded', error.message);
    } else if (error.message.includes('recipient not allowed')) {
      return new PrexSDKError('recipient_not_allowed', error.message);
    } else if (error.message.includes('Not Found')) {
      return new PrexSDKError('not_found', error.message);
    } else if (error.message.includes('Failed to fetch')) {
      return new PrexSDKError('fetch_error', error.message);
    } else if (error.message.includes('transfer_from_failed')) {
      return new PrexSDKError(
        'transfer_failed',
        'There is either an insufficient token balance, or it has not been approved'
      );
    } else {
      return new PrexSDKError('unknown', error.message);
    }
  }
}

export const normalizeErrorFn =
  (fallbackMessage: string) =>
  (error: unknown): Error => {
    if (error instanceof Error) {
      return error;
    }
    // try to check errors of the following form: {error: string; error_description?: string}
    if (
      error !== null &&
      typeof error === 'object' &&
      'error' in error &&
      typeof error.error === 'string'
    ) {
      if (
        'error_description' in error &&
        typeof error.error_description === 'string'
      ) {
        return new Error(error.error);
      }
      return new Error(error.error);
    }
    return new Error(fallbackMessage);
  };