// Mock Stripe SDK
const mockStripeCheckoutSessionsRetrieve = jest.fn();
const mockStripeAccountsCreate = jest.fn();
const mockStripeAccountsRetrieve = jest.fn();
const mockStripeAccountLinksCreate = jest.fn();
const mockStripeTransfersCreate = jest.fn();
const mockStripeRefundsCreate = jest.fn();
const mockStripeRefundsRetrieve = jest.fn();
const mockStripePaymentIntentsCreate = jest.fn();
const mockStripeCustomersCreate = jest.fn();
const mockStripeCheckoutSessionsCreate = jest.fn();
const mockStripeAccountSessionsCreate = jest.fn();
const mockStripePaymentMethodsRetrieve = jest.fn();

jest.mock('stripe', () => {
  return jest.fn(() => ({
    checkout: {
      sessions: {
        retrieve: mockStripeCheckoutSessionsRetrieve,
        create: mockStripeCheckoutSessionsCreate
      }
    },
    accounts: {
      create: mockStripeAccountsCreate,
      retrieve: mockStripeAccountsRetrieve
    },
    accountLinks: {
      create: mockStripeAccountLinksCreate
    },
    accountSessions: {
      create: mockStripeAccountSessionsCreate
    },
    transfers: {
      create: mockStripeTransfersCreate
    },
    refunds: {
      create: mockStripeRefundsCreate,
      retrieve: mockStripeRefundsRetrieve
    },
    paymentIntents: {
      create: mockStripePaymentIntentsCreate
    },
    customers: {
      create: mockStripeCustomersCreate
    },
    paymentMethods: {
      retrieve: mockStripePaymentMethodsRetrieve
    }
  }));
});

const mockLoggerError = jest.fn();
const mockLoggerWarn = jest.fn();
const mockLoggerInfo = jest.fn();
jest.mock('../../../utils/logger', () => ({
  error: mockLoggerError,
  info: mockLoggerInfo,
  warn: mockLoggerWarn,
  withRequestId: jest.fn(() => ({
    error: jest.fn(),
    info: jest.fn(),
    warn: jest.fn(),
  })),
}));

// Mock User model
const mockUserFindOne = jest.fn();
const mockUserUpdate = jest.fn();
jest.mock('../../../models', () => ({
  User: {
    findOne: mockUserFindOne
  }
}));

// Mock email services
const mockSendAccountDisconnectedEmail = jest.fn();
jest.mock('../../../services/email', () => ({
  payment: {
    sendAccountDisconnectedEmail: mockSendAccountDisconnectedEmail
  }
}));

const StripeService = require('../../../services/stripeService');

describe('StripeService', () => {
  beforeEach(() => {
    jest.clearAllMocks();

    // Set environment variables for tests
    process.env.FRONTEND_URL = 'http://localhost:3000';
  });

  describe('getCheckoutSession', () => {
    it('should retrieve checkout session successfully', async () => {
      const mockSession = {
        id: 'cs_123456789',
        status: 'complete',
        setup_intent: {
          id: 'seti_123456789',
          payment_method: {
            id: 'pm_123456789',
            type: 'card'
          }
        }
      };

      mockStripeCheckoutSessionsRetrieve.mockResolvedValue(mockSession);

      const result = await StripeService.getCheckoutSession('cs_123456789');

      expect(mockStripeCheckoutSessionsRetrieve).toHaveBeenCalledWith('cs_123456789', {
        expand: ['setup_intent', 'setup_intent.payment_method']
      });
      expect(result).toEqual(mockSession);
    });

    it('should handle checkout session retrieval errors', async () => {
      const stripeError = new Error('Session not found');
      mockStripeCheckoutSessionsRetrieve.mockRejectedValue(stripeError);

      await expect(StripeService.getCheckoutSession('invalid_session'))
        .rejects.toThrow('Session not found');

      expect(mockLoggerError).toHaveBeenCalledWith(
        'Error retrieving checkout session',
        expect.objectContaining({
          error: stripeError.message,
        })
      );
    });

    it('should handle missing session ID', async () => {
      const stripeError = new Error('Invalid session ID');
      mockStripeCheckoutSessionsRetrieve.mockRejectedValue(stripeError);

      await expect(StripeService.getCheckoutSession(null))
        .rejects.toThrow('Invalid session ID');
    });
  });

  describe('createConnectedAccount', () => {
    it('should create connected account with default country', async () => {
      const mockAccount = {
        id: 'acct_123456789',
        type: 'express',
        email: 'test@example.com',
        country: 'US',
        capabilities: {
          transfers: { status: 'pending' }
        }
      };

      mockStripeAccountsCreate.mockResolvedValue(mockAccount);

      const result = await StripeService.createConnectedAccount({
        email: 'test@example.com'
      });

      expect(mockStripeAccountsCreate).toHaveBeenCalledWith({
        type: 'express',
        email: 'test@example.com',
        country: 'US',
        capabilities: {
          transfers: { requested: true }
        }
      });
      expect(result).toEqual(mockAccount);
    });

    it('should create connected account with custom country', async () => {
      const mockAccount = {
        id: 'acct_123456789',
        type: 'express',
        email: 'test@example.com',
        country: 'CA',
        capabilities: {
          transfers: { status: 'pending' }
        }
      };

      mockStripeAccountsCreate.mockResolvedValue(mockAccount);

      const result = await StripeService.createConnectedAccount({
        email: 'test@example.com',
        country: 'CA'
      });

      expect(mockStripeAccountsCreate).toHaveBeenCalledWith({
        type: 'express',
        email: 'test@example.com',
        country: 'CA',
        capabilities: {
          transfers: { requested: true }
        }
      });
      expect(result).toEqual(mockAccount);
    });

    it('should handle connected account creation errors', async () => {
      const stripeError = new Error('Invalid email address');
      mockStripeAccountsCreate.mockRejectedValue(stripeError);

      await expect(StripeService.createConnectedAccount({
        email: 'invalid-email'
      })).rejects.toThrow('Invalid email address');

      expect(mockLoggerError).toHaveBeenCalledWith(
        'Error creating connected account',
        expect.objectContaining({
          error: stripeError.message,
        })
      );
    });

    it('should handle missing email parameter', async () => {
      const stripeError = new Error('Email is required');
      mockStripeAccountsCreate.mockRejectedValue(stripeError);

      await expect(StripeService.createConnectedAccount({}))
        .rejects.toThrow('Email is required');
    });
  });

  describe('createAccountLink', () => {
    it('should create account link successfully', async () => {
      const mockAccountLink = {
        object: 'account_link',
        url: 'https://connect.stripe.com/setup/e/acct_123456789',
        created: Date.now(),
        expires_at: Date.now() + 3600
      };

      mockStripeAccountLinksCreate.mockResolvedValue(mockAccountLink);

      const result = await StripeService.createAccountLink(
        'acct_123456789',
        'http://localhost:3000/refresh',
        'http://localhost:3000/return'
      );

      expect(mockStripeAccountLinksCreate).toHaveBeenCalledWith({
        account: 'acct_123456789',
        refresh_url: 'http://localhost:3000/refresh',
        return_url: 'http://localhost:3000/return',
        type: 'account_onboarding'
      });
      expect(result).toEqual(mockAccountLink);
    });

    it('should handle account link creation errors', async () => {
      const stripeError = new Error('Account not found');
      mockStripeAccountLinksCreate.mockRejectedValue(stripeError);

      await expect(StripeService.createAccountLink(
        'invalid_account',
        'http://localhost:3000/refresh',
        'http://localhost:3000/return'
      )).rejects.toThrow('Account not found');

      expect(mockLoggerError).toHaveBeenCalledWith(
        'Error creating account link',
        expect.objectContaining({
          error: stripeError.message,
        })
      );
    });

    it('should handle invalid URLs', async () => {
      const stripeError = new Error('Invalid URL format');
      mockStripeAccountLinksCreate.mockRejectedValue(stripeError);

      await expect(StripeService.createAccountLink(
        'acct_123456789',
        'invalid-url',
        'invalid-url'
      )).rejects.toThrow('Invalid URL format');
    });
  });

  describe('getAccountStatus', () => {
    it('should retrieve account status successfully', async () => {
      const mockAccount = {
        id: 'acct_123456789',
        details_submitted: true,
        payouts_enabled: true,
        capabilities: {
          transfers: { status: 'active' }
        },
        requirements: {
          pending_verification: [],
          currently_due: [],
          past_due: []
        },
        other_field: 'should_be_filtered_out'
      };

      mockStripeAccountsRetrieve.mockResolvedValue(mockAccount);

      const result = await StripeService.getAccountStatus('acct_123456789');

      expect(mockStripeAccountsRetrieve).toHaveBeenCalledWith('acct_123456789');
      expect(result).toEqual({
        id: 'acct_123456789',
        details_submitted: true,
        payouts_enabled: true,
        capabilities: {
          transfers: { status: 'active' }
        },
        requirements: {
          pending_verification: [],
          currently_due: [],
          past_due: []
        }
      });
    });

    it('should handle account status retrieval errors', async () => {
      const stripeError = new Error('Account not found');
      mockStripeAccountsRetrieve.mockRejectedValue(stripeError);

      await expect(StripeService.getAccountStatus('invalid_account'))
        .rejects.toThrow('Account not found');

      expect(mockLoggerError).toHaveBeenCalledWith(
        'Error retrieving account status',
        expect.objectContaining({
          error: stripeError.message,
        })
      );
    });

    it('should handle accounts with incomplete data', async () => {
      const mockAccount = {
        id: 'acct_123456789',
        details_submitted: false,
        payouts_enabled: false,
        capabilities: null,
        requirements: null
      };

      mockStripeAccountsRetrieve.mockResolvedValue(mockAccount);

      const result = await StripeService.getAccountStatus('acct_123456789');

      expect(result).toEqual({
        id: 'acct_123456789',
        details_submitted: false,
        payouts_enabled: false,
        capabilities: null,
        requirements: null
      });
    });
  });

  describe('createTransfer', () => {
    it('should create transfer with default currency and idempotency key', async () => {
      const mockTransfer = {
        id: 'tr_123456789',
        amount: 5000, // $50.00 in cents
        currency: 'usd',
        destination: 'acct_123456789',
        metadata: {
          rentalId: '1',
          ownerId: '2'
        }
      };

      mockStripeTransfersCreate.mockResolvedValue(mockTransfer);

      const result = await StripeService.createTransfer({
        amount: 50.00,
        destination: 'acct_123456789',
        metadata: {
          rentalId: '1',
          ownerId: '2'
        }
      });

      expect(mockStripeTransfersCreate).toHaveBeenCalledWith(
        {
          amount: 5000, // Converted to cents
          currency: 'usd',
          destination: 'acct_123456789',
          metadata: {
            rentalId: '1',
            ownerId: '2'
          }
        },
        { idempotencyKey: 'transfer_rental_1' }
      );
      expect(result).toEqual(mockTransfer);
    });

    it('should create transfer with custom currency and no idempotency key when no rentalId', async () => {
      const mockTransfer = {
        id: 'tr_123456789',
        amount: 5000,
        currency: 'eur',
        destination: 'acct_123456789',
        metadata: {}
      };

      mockStripeTransfersCreate.mockResolvedValue(mockTransfer);

      const result = await StripeService.createTransfer({
        amount: 50.00,
        currency: 'eur',
        destination: 'acct_123456789'
      });

      expect(mockStripeTransfersCreate).toHaveBeenCalledWith(
        {
          amount: 5000,
          currency: 'eur',
          destination: 'acct_123456789',
          metadata: {}
        },
        undefined
      );
      expect(result).toEqual(mockTransfer);
    });

    it('should handle decimal amounts correctly', async () => {
      const mockTransfer = {
        id: 'tr_123456789',
        amount: 12534, // $125.34 in cents
        currency: 'usd',
        destination: 'acct_123456789',
        metadata: {}
      };

      mockStripeTransfersCreate.mockResolvedValue(mockTransfer);

      await StripeService.createTransfer({
        amount: 125.34,
        destination: 'acct_123456789'
      });

      expect(mockStripeTransfersCreate).toHaveBeenCalledWith(
        {
          amount: 12534, // Properly converted to cents
          currency: 'usd',
          destination: 'acct_123456789',
          metadata: {}
        },
        undefined
      );
    });

    it('should handle transfer creation errors', async () => {
      const stripeError = new Error('Insufficient funds');
      mockStripeTransfersCreate.mockRejectedValue(stripeError);

      await expect(StripeService.createTransfer({
        amount: 50.00,
        destination: 'acct_123456789'
      })).rejects.toThrow('Insufficient funds');

      expect(mockLoggerError).toHaveBeenCalledWith(
        'Error creating transfer',
        expect.objectContaining({
          error: stripeError.message,
        })
      );
    });

    it('should handle rounding for very small amounts', async () => {
      const mockTransfer = {
        id: 'tr_123456789',
        amount: 1, // $0.005 rounded to 1 cent
        currency: 'usd',
        destination: 'acct_123456789',
        metadata: {}
      };

      mockStripeTransfersCreate.mockResolvedValue(mockTransfer);

      await StripeService.createTransfer({
        amount: 0.005, // Should round to 1 cent
        destination: 'acct_123456789'
      });

      expect(mockStripeTransfersCreate).toHaveBeenCalledWith(
        {
          amount: 1,
          currency: 'usd',
          destination: 'acct_123456789',
          metadata: {}
        },
        undefined
      );
    });
  });

  describe('createRefund', () => {
    it('should create refund with default parameters and idempotency key', async () => {
      const mockRefund = {
        id: 're_123456789',
        amount: 5000, // $50.00 in cents
        payment_intent: 'pi_123456789',
        reason: 'requested_by_customer',
        status: 'succeeded',
        metadata: {
          rentalId: '1'
        }
      };

      mockStripeRefundsCreate.mockResolvedValue(mockRefund);

      const result = await StripeService.createRefund({
        paymentIntentId: 'pi_123456789',
        amount: 50.00,
        metadata: {
          rentalId: '1'
        }
      });

      expect(mockStripeRefundsCreate).toHaveBeenCalledWith(
        {
          payment_intent: 'pi_123456789',
          amount: 5000, // Converted to cents
          metadata: {
            rentalId: '1'
          },
          reason: 'requested_by_customer'
        },
        { idempotencyKey: 'refund_rental_1_5000' }
      );
      expect(result).toEqual(mockRefund);
    });

    it('should create refund with custom reason and no idempotency key when no rentalId', async () => {
      const mockRefund = {
        id: 're_123456789',
        amount: 10000,
        payment_intent: 'pi_123456789',
        reason: 'fraudulent',
        status: 'succeeded',
        metadata: {}
      };

      mockStripeRefundsCreate.mockResolvedValue(mockRefund);

      const result = await StripeService.createRefund({
        paymentIntentId: 'pi_123456789',
        amount: 100.00,
        reason: 'fraudulent'
      });

      expect(mockStripeRefundsCreate).toHaveBeenCalledWith(
        {
          payment_intent: 'pi_123456789',
          amount: 10000,
          metadata: {},
          reason: 'fraudulent'
        },
        undefined
      );
      expect(result).toEqual(mockRefund);
    });

    it('should handle decimal amounts correctly', async () => {
      const mockRefund = {
        id: 're_123456789',
        amount: 12534, // $125.34 in cents
        payment_intent: 'pi_123456789',
        reason: 'requested_by_customer',
        status: 'succeeded',
        metadata: {}
      };

      mockStripeRefundsCreate.mockResolvedValue(mockRefund);

      await StripeService.createRefund({
        paymentIntentId: 'pi_123456789',
        amount: 125.34
      });

      expect(mockStripeRefundsCreate).toHaveBeenCalledWith(
        {
          payment_intent: 'pi_123456789',
          amount: 12534, // Properly converted to cents
          metadata: {},
          reason: 'requested_by_customer'
        },
        undefined
      );
    });

    it('should handle refund creation errors', async () => {
      const stripeError = new Error('Payment intent not found');
      mockStripeRefundsCreate.mockRejectedValue(stripeError);

      await expect(StripeService.createRefund({
        paymentIntentId: 'pi_invalid',
        amount: 50.00
      })).rejects.toThrow('Payment intent not found');

      expect(mockLoggerError).toHaveBeenCalledWith(
        'Error creating refund',
        expect.objectContaining({
          error: stripeError.message,
        })
      );
    });

    it('should handle partial refund scenarios', async () => {
      const mockRefund = {
        id: 're_123456789',
        amount: 2500, // Partial refund of $25.00
        payment_intent: 'pi_123456789',
        reason: 'requested_by_customer',
        status: 'succeeded',
        metadata: {
          type: 'partial'
        }
      };

      mockStripeRefundsCreate.mockResolvedValue(mockRefund);

      const result = await StripeService.createRefund({
        paymentIntentId: 'pi_123456789',
        amount: 25.00,
        metadata: {
          type: 'partial'
        }
      });

      expect(result.amount).toBe(2500);
      expect(result.metadata.type).toBe('partial');
    });
  });

  describe('getRefund', () => {
    it('should retrieve refund successfully', async () => {
      const mockRefund = {
        id: 're_123456789',
        amount: 5000,
        payment_intent: 'pi_123456789',
        reason: 'requested_by_customer',
        status: 'succeeded',
        created: Date.now()
      };

      mockStripeRefundsRetrieve.mockResolvedValue(mockRefund);

      const result = await StripeService.getRefund('re_123456789');

      expect(mockStripeRefundsRetrieve).toHaveBeenCalledWith('re_123456789');
      expect(result).toEqual(mockRefund);
    });

    it('should handle refund retrieval errors', async () => {
      const stripeError = new Error('Refund not found');
      mockStripeRefundsRetrieve.mockRejectedValue(stripeError);

      await expect(StripeService.getRefund('re_invalid'))
        .rejects.toThrow('Refund not found');

      expect(mockLoggerError).toHaveBeenCalledWith(
        'Error retrieving refund',
        expect.objectContaining({
          error: stripeError.message,
        })
      );
    });

    it('should handle null refund ID', async () => {
      const stripeError = new Error('Invalid refund ID');
      mockStripeRefundsRetrieve.mockRejectedValue(stripeError);

      await expect(StripeService.getRefund(null))
        .rejects.toThrow('Invalid refund ID');
    });
  });

  describe('chargePaymentMethod', () => {
    it('should charge payment method successfully with idempotency key', async () => {
      const mockPaymentIntent = {
        id: 'pi_123456789',
        status: 'succeeded',
        client_secret: 'pi_123456789_secret_test',
        amount: 5000,
        currency: 'usd',
        created: 1234567890,
        latest_charge: {
          payment_method_details: {
            type: 'card',
            card: {
              brand: 'visa',
              last4: '4242'
            }
          }
        }
      };

      mockStripePaymentIntentsCreate.mockResolvedValue(mockPaymentIntent);

      const result = await StripeService.chargePaymentMethod(
        'pm_123456789',
        50.00,
        'cus_123456789',
        { rentalId: '1' }
      );

      expect(mockStripePaymentIntentsCreate).toHaveBeenCalledWith(
        {
          amount: 5000, // Converted to cents
          currency: 'usd',
          payment_method: 'pm_123456789',
          customer: 'cus_123456789',
          confirm: true,
          off_session: true,
          return_url: 'http://localhost:3000/complete-payment',
          metadata: { rentalId: '1' },
          expand: ['latest_charge.payment_method_details']
        },
        { idempotencyKey: 'charge_rental_1' }
      );

      expect(result).toEqual({
        paymentIntentId: 'pi_123456789',
        status: 'succeeded',
        clientSecret: 'pi_123456789_secret_test',
        paymentMethod: {
          type: 'card',
          brand: 'visa',
          last4: '4242'
        },
        chargedAt: new Date(1234567890 * 1000),
        amountCharged: 50.00
      });
    });

    it('should handle payment method charge errors', async () => {
      const stripeError = new Error('Payment method declined');
      mockStripePaymentIntentsCreate.mockRejectedValue(stripeError);

      await expect(StripeService.chargePaymentMethod(
        'pm_invalid',
        50.00,
        'cus_123456789'
      )).rejects.toThrow('The payment could not be processed.');

      expect(mockLoggerError).toHaveBeenCalledWith(
        'Payment failed',
        expect.objectContaining({
          code: expect.any(String),
        })
      );
    });

    it('should use default frontend URL when not set and no idempotency key without rentalId', async () => {
      delete process.env.FRONTEND_URL;

      const mockPaymentIntent = {
        id: 'pi_123456789',
        status: 'succeeded',
        client_secret: 'pi_123456789_secret_test'
      };

      mockStripePaymentIntentsCreate.mockResolvedValue(mockPaymentIntent);

      await StripeService.chargePaymentMethod(
        'pm_123456789',
        50.00,
        'cus_123456789'
      );

      expect(mockStripePaymentIntentsCreate).toHaveBeenCalledWith(
        expect.objectContaining({
          return_url: 'http://localhost:3000/complete-payment'
        }),
        undefined
      );
    });

    it('should handle decimal amounts correctly', async () => {
      const mockPaymentIntent = {
        id: 'pi_123456789',
        status: 'succeeded',
        client_secret: 'pi_123456789_secret_test'
      };

      mockStripePaymentIntentsCreate.mockResolvedValue(mockPaymentIntent);

      await StripeService.chargePaymentMethod(
        'pm_123456789',
        125.34,
        'cus_123456789'
      );

      expect(mockStripePaymentIntentsCreate).toHaveBeenCalledWith(
        expect.objectContaining({
          amount: 12534 // Properly converted to cents
        }),
        undefined
      );
    });

    it('should handle payment requiring authentication', async () => {
      const mockPaymentIntent = {
        id: 'pi_123456789',
        status: 'requires_action',
        client_secret: 'pi_123456789_secret_test',
        next_action: {
          type: 'use_stripe_sdk'
        }
      };

      mockStripePaymentIntentsCreate.mockResolvedValue(mockPaymentIntent);

      const result = await StripeService.chargePaymentMethod(
        'pm_123456789',
        50.00,
        'cus_123456789'
      );

      expect(result.status).toBe('requires_action');
      expect(result.clientSecret).toBe('pi_123456789_secret_test');
    });
  });

  describe('createCustomer', () => {
    it('should create customer successfully', async () => {
      const mockCustomer = {
        id: 'cus_123456789',
        email: 'test@example.com',
        name: 'John Doe',
        metadata: {
          userId: '123'
        },
        created: Date.now()
      };

      mockStripeCustomersCreate.mockResolvedValue(mockCustomer);

      const result = await StripeService.createCustomer({
        email: 'test@example.com',
        name: 'John Doe',
        metadata: {
          userId: '123'
        }
      });

      expect(mockStripeCustomersCreate).toHaveBeenCalledWith({
        email: 'test@example.com',
        name: 'John Doe',
        metadata: {
          userId: '123'
        }
      });
      expect(result).toEqual(mockCustomer);
    });

    it('should create customer with minimal data', async () => {
      const mockCustomer = {
        id: 'cus_123456789',
        email: 'test@example.com',
        name: null,
        metadata: {}
      };

      mockStripeCustomersCreate.mockResolvedValue(mockCustomer);

      const result = await StripeService.createCustomer({
        email: 'test@example.com'
      });

      expect(mockStripeCustomersCreate).toHaveBeenCalledWith({
        email: 'test@example.com',
        name: undefined,
        metadata: {}
      });
      expect(result).toEqual(mockCustomer);
    });

    it('should handle customer creation errors', async () => {
      const stripeError = new Error('Invalid email format');
      mockStripeCustomersCreate.mockRejectedValue(stripeError);

      await expect(StripeService.createCustomer({
        email: 'invalid-email'
      })).rejects.toThrow('Invalid email format');

      expect(mockLoggerError).toHaveBeenCalledWith(
        'Error creating customer',
        expect.objectContaining({
          error: stripeError.message,
        })
      );
    });

    it('should handle duplicate customer errors', async () => {
      const stripeError = new Error('Customer already exists');
      mockStripeCustomersCreate.mockRejectedValue(stripeError);

      await expect(StripeService.createCustomer({
        email: 'existing@example.com',
        name: 'Existing User'
      })).rejects.toThrow('Customer already exists');
    });
  });

  describe('createSetupCheckoutSession', () => {
    it('should create setup checkout session successfully', async () => {
      const mockSession = {
        id: 'cs_123456789',
        url: null,
        client_secret: 'cs_123456789_secret_test',
        customer: 'cus_123456789',
        mode: 'setup',
        ui_mode: 'embedded',
        metadata: {
          type: 'payment_method_setup',
          userId: '123'
        }
      };

      mockStripeCheckoutSessionsCreate.mockResolvedValue(mockSession);

      const result = await StripeService.createSetupCheckoutSession({
        customerId: 'cus_123456789',
        metadata: {
          userId: '123'
        }
      });

      expect(mockStripeCheckoutSessionsCreate).toHaveBeenCalledWith({
        customer: 'cus_123456789',
        payment_method_types: ['card', 'link'],
        mode: 'setup',
        ui_mode: 'embedded',
        redirect_on_completion: 'never',
        payment_method_options: {
          card: {
            request_three_d_secure: 'any',
          },
        },
        metadata: {
          type: 'payment_method_setup',
          userId: '123'
        }
      });
      expect(result).toEqual(mockSession);
    });

    it('should create setup checkout session with minimal data', async () => {
      const mockSession = {
        id: 'cs_123456789',
        url: null,
        client_secret: 'cs_123456789_secret_test',
        customer: 'cus_123456789',
        mode: 'setup',
        ui_mode: 'embedded',
        metadata: {
          type: 'payment_method_setup'
        }
      };

      mockStripeCheckoutSessionsCreate.mockResolvedValue(mockSession);

      const result = await StripeService.createSetupCheckoutSession({
        customerId: 'cus_123456789'
      });

      expect(mockStripeCheckoutSessionsCreate).toHaveBeenCalledWith({
        customer: 'cus_123456789',
        payment_method_types: ['card', 'link'],
        mode: 'setup',
        ui_mode: 'embedded',
        redirect_on_completion: 'never',
        payment_method_options: {
          card: {
            request_three_d_secure: 'any',
          },
        },
        metadata: {
          type: 'payment_method_setup'
        }
      });
      expect(result).toEqual(mockSession);
    });

    it('should handle setup checkout session creation errors', async () => {
      const stripeError = new Error('Customer not found');
      mockStripeCheckoutSessionsCreate.mockRejectedValue(stripeError);

      await expect(StripeService.createSetupCheckoutSession({
        customerId: 'cus_invalid'
      })).rejects.toThrow('Customer not found');

      expect(mockLoggerError).toHaveBeenCalledWith(
        'Error creating setup checkout session',
        expect.objectContaining({
          error: stripeError.message,
        })
      );
    });

    it('should handle missing customer ID', async () => {
      const stripeError = new Error('Customer ID is required');
      mockStripeCheckoutSessionsCreate.mockRejectedValue(stripeError);

      await expect(StripeService.createSetupCheckoutSession({}))
        .rejects.toThrow('Customer ID is required');
    });
  });

  describe('Error handling and edge cases', () => {
    it('should handle very large monetary amounts', async () => {
      const mockTransfer = {
        id: 'tr_123456789',
        amount: 99999999, // $999,999.99 in cents
        currency: 'usd',
        destination: 'acct_123456789',
        metadata: {}
      };

      mockStripeTransfersCreate.mockResolvedValue(mockTransfer);

      await StripeService.createTransfer({
        amount: 999999.99,
        destination: 'acct_123456789'
      });

      expect(mockStripeTransfersCreate).toHaveBeenCalledWith(
        {
          amount: 99999999,
          currency: 'usd',
          destination: 'acct_123456789',
          metadata: {}
        },
        undefined
      );
    });

    it('should handle zero amounts', async () => {
      const mockRefund = {
        id: 're_123456789',
        amount: 0,
        payment_intent: 'pi_123456789',
        reason: 'requested_by_customer',
        status: 'succeeded',
        metadata: {}
      };

      mockStripeRefundsCreate.mockResolvedValue(mockRefund);

      await StripeService.createRefund({
        paymentIntentId: 'pi_123456789',
        amount: 0
      });

      expect(mockStripeRefundsCreate).toHaveBeenCalledWith(
        {
          payment_intent: 'pi_123456789',
          amount: 0,
          metadata: {},
          reason: 'requested_by_customer'
        },
        undefined
      );
    });

    it('should handle network timeout errors', async () => {
      const timeoutError = new Error('Request timeout');
      timeoutError.type = 'StripeConnectionError';
      mockStripeTransfersCreate.mockRejectedValue(timeoutError);

      await expect(StripeService.createTransfer({
        amount: 50.00,
        destination: 'acct_123456789'
      })).rejects.toThrow('Request timeout');

      expect(mockLoggerError).toHaveBeenCalledWith(
        'Error creating transfer',
        expect.objectContaining({
          error: timeoutError.message,
        })
      );
    });

    it('should handle API key errors', async () => {
      const apiKeyError = new Error('Invalid API key');
      apiKeyError.type = 'StripeAuthenticationError';
      mockStripeCustomersCreate.mockRejectedValue(apiKeyError);

      await expect(StripeService.createCustomer({
        email: 'test@example.com'
      })).rejects.toThrow('Invalid API key');

      expect(mockLoggerError).toHaveBeenCalledWith(
        'Error creating customer',
        expect.objectContaining({
          error: apiKeyError.message,
        })
      );
    });
  });

  describe('Idempotency key generation', () => {
    it('should generate different refund idempotency keys for different amounts on same rental', async () => {
      mockStripeRefundsCreate.mockResolvedValue({ id: 're_123' });

      // First refund - $30
      await StripeService.createRefund({
        paymentIntentId: 'pi_123',
        amount: 30.00,
        metadata: { rentalId: 'rental-uuid-123' }
      });

      // Second refund - $20
      await StripeService.createRefund({
        paymentIntentId: 'pi_123',
        amount: 20.00,
        metadata: { rentalId: 'rental-uuid-123' }
      });

      // Verify different idempotency keys were used
      expect(mockStripeRefundsCreate).toHaveBeenNthCalledWith(
        1,
        expect.any(Object),
        { idempotencyKey: 'refund_rental_rental-uuid-123_3000' }
      );
      expect(mockStripeRefundsCreate).toHaveBeenNthCalledWith(
        2,
        expect.any(Object),
        { idempotencyKey: 'refund_rental_rental-uuid-123_2000' }
      );
    });

    it('should generate consistent transfer idempotency key for same rental', async () => {
      mockStripeTransfersCreate.mockResolvedValue({ id: 'tr_123' });

      const rentalId = 'rental-uuid-456';

      // Call twice with same rental
      await StripeService.createTransfer({
        amount: 100.00,
        destination: 'acct_123',
        metadata: { rentalId }
      });

      await StripeService.createTransfer({
        amount: 100.00,
        destination: 'acct_123',
        metadata: { rentalId }
      });

      // Both should have the same idempotency key
      expect(mockStripeTransfersCreate).toHaveBeenNthCalledWith(
        1,
        expect.any(Object),
        { idempotencyKey: 'transfer_rental_rental-uuid-456' }
      );
      expect(mockStripeTransfersCreate).toHaveBeenNthCalledWith(
        2,
        expect.any(Object),
        { idempotencyKey: 'transfer_rental_rental-uuid-456' }
      );
    });

    it('should generate consistent charge idempotency key for same rental', async () => {
      mockStripePaymentIntentsCreate.mockResolvedValue({
        id: 'pi_123',
        status: 'succeeded',
        client_secret: 'secret',
        created: Date.now() / 1000,
        latest_charge: null
      });

      const rentalId = 'rental-uuid-789';

      await StripeService.chargePaymentMethod(
        'pm_123',
        100.00,
        'cus_123',
        { rentalId }
      );

      expect(mockStripePaymentIntentsCreate).toHaveBeenCalledWith(
        expect.any(Object),
        { idempotencyKey: 'charge_rental_rental-uuid-789' }
      );
    });
  });

  describe('createAccountSession', () => {
    it('should create account session successfully', async () => {
      const mockSession = {
        object: 'account_session',
        client_secret: 'acct_sess_secret_123',
        expires_at: Date.now() + 3600
      };

      mockStripeAccountSessionsCreate.mockResolvedValue(mockSession);

      const result = await StripeService.createAccountSession('acct_123456789');

      expect(mockStripeAccountSessionsCreate).toHaveBeenCalledWith({
        account: 'acct_123456789',
        components: {
          account_onboarding: { enabled: true }
        }
      });
      expect(result).toEqual(mockSession);
    });

    it('should handle account session creation errors', async () => {
      const stripeError = new Error('Account not found');
      mockStripeAccountSessionsCreate.mockRejectedValue(stripeError);

      await expect(StripeService.createAccountSession('invalid_account'))
        .rejects.toThrow('Account not found');

      expect(mockLoggerError).toHaveBeenCalledWith(
        'Error creating account session',
        expect.objectContaining({
          error: stripeError.message,
        })
      );
    });

    it('should handle invalid account ID', async () => {
      const stripeError = new Error('Invalid account ID format');
      mockStripeAccountSessionsCreate.mockRejectedValue(stripeError);

      await expect(StripeService.createAccountSession(null))
        .rejects.toThrow('Invalid account ID format');
    });
  });

  describe('getPaymentMethod', () => {
    it('should retrieve payment method successfully', async () => {
      const mockPaymentMethod = {
        id: 'pm_123456789',
        type: 'card',
        card: {
          brand: 'visa',
          last4: '4242',
          exp_month: 12,
          exp_year: 2025
        },
        customer: 'cus_123456789'
      };

      mockStripePaymentMethodsRetrieve.mockResolvedValue(mockPaymentMethod);

      const result = await StripeService.getPaymentMethod('pm_123456789');

      expect(mockStripePaymentMethodsRetrieve).toHaveBeenCalledWith('pm_123456789');
      expect(result).toEqual(mockPaymentMethod);
    });

    it('should handle payment method retrieval errors', async () => {
      const stripeError = new Error('Payment method not found');
      mockStripePaymentMethodsRetrieve.mockRejectedValue(stripeError);

      await expect(StripeService.getPaymentMethod('pm_invalid'))
        .rejects.toThrow('Payment method not found');

      expect(mockLoggerError).toHaveBeenCalledWith(
        'Error retrieving payment method',
        expect.objectContaining({
          error: stripeError.message,
          paymentMethodId: 'pm_invalid'
        })
      );
    });

    it('should handle null payment method ID', async () => {
      const stripeError = new Error('Invalid payment method ID');
      mockStripePaymentMethodsRetrieve.mockRejectedValue(stripeError);

      await expect(StripeService.getPaymentMethod(null))
        .rejects.toThrow('Invalid payment method ID');
    });
  });

  describe('isAccountDisconnectedError', () => {
    it('should return true for account_invalid error code', () => {
      const error = { code: 'account_invalid', message: 'Account is invalid' };
      expect(StripeService.isAccountDisconnectedError(error)).toBe(true);
    });

    it('should return true for platform_api_key_expired error code', () => {
      const error = { code: 'platform_api_key_expired', message: 'API key expired' };
      expect(StripeService.isAccountDisconnectedError(error)).toBe(true);
    });

    it('should return true for error message containing "cannot transfer"', () => {
      const error = { code: 'some_code', message: 'You cannot transfer to this account' };
      expect(StripeService.isAccountDisconnectedError(error)).toBe(true);
    });

    it('should return true for error message containing "not connected"', () => {
      const error = { code: 'some_code', message: 'This account is not connected to your platform' };
      expect(StripeService.isAccountDisconnectedError(error)).toBe(true);
    });

    it('should return true for error message containing "no longer connected"', () => {
      const error = { code: 'some_code', message: 'This account is no longer connected' };
      expect(StripeService.isAccountDisconnectedError(error)).toBe(true);
    });

    it('should return true for error message containing "account has been deauthorized"', () => {
      const error = { code: 'some_code', message: 'The account has been deauthorized' };
      expect(StripeService.isAccountDisconnectedError(error)).toBe(true);
    });

    it('should return false for unrelated error codes', () => {
      const error = { code: 'card_declined', message: 'Card was declined' };
      expect(StripeService.isAccountDisconnectedError(error)).toBe(false);
    });

    it('should return false for unrelated error messages', () => {
      const error = { code: 'some_code', message: 'Insufficient funds in account' };
      expect(StripeService.isAccountDisconnectedError(error)).toBe(false);
    });

    it('should handle error with no message', () => {
      const error = { code: 'some_code' };
      expect(StripeService.isAccountDisconnectedError(error)).toBe(false);
    });

    it('should handle error with undefined message', () => {
      const error = { code: 'some_code', message: undefined };
      expect(StripeService.isAccountDisconnectedError(error)).toBe(false);
    });
  });

  describe('handleDisconnectedAccount', () => {
    beforeEach(() => {
      mockUserFindOne.mockReset();
      mockSendAccountDisconnectedEmail.mockReset();
    });

    it('should clear user stripe connection data', async () => {
      const mockUser = {
        id: 123,
        email: 'test@example.com',
        firstName: 'John',
        lastName: 'Doe',
        update: mockUserUpdate.mockResolvedValue(true)
      };
      mockUserFindOne.mockResolvedValue(mockUser);
      mockSendAccountDisconnectedEmail.mockResolvedValue(true);

      await StripeService.handleDisconnectedAccount('acct_123456789');

      expect(mockUserFindOne).toHaveBeenCalledWith({
        where: { stripeConnectedAccountId: 'acct_123456789' }
      });
      expect(mockUserUpdate).toHaveBeenCalledWith({
        stripeConnectedAccountId: null,
        stripePayoutsEnabled: false
      });
    });

    it('should send account disconnected email', async () => {
      const mockUser = {
        id: 123,
        email: 'test@example.com',
        firstName: 'John',
        lastName: 'Doe',
        update: mockUserUpdate.mockResolvedValue(true)
      };
      mockUserFindOne.mockResolvedValue(mockUser);
      mockSendAccountDisconnectedEmail.mockResolvedValue(true);

      await StripeService.handleDisconnectedAccount('acct_123456789');

      expect(mockSendAccountDisconnectedEmail).toHaveBeenCalledWith('test@example.com', {
        ownerName: 'John',
        hasPendingPayouts: true,
        pendingPayoutCount: 1
      });
    });

    it('should do nothing when user not found', async () => {
      mockUserFindOne.mockResolvedValue(null);

      await StripeService.handleDisconnectedAccount('acct_nonexistent');

      expect(mockUserFindOne).toHaveBeenCalledWith({
        where: { stripeConnectedAccountId: 'acct_nonexistent' }
      });
      expect(mockUserUpdate).not.toHaveBeenCalled();
      expect(mockSendAccountDisconnectedEmail).not.toHaveBeenCalled();
    });

    it('should handle email sending errors gracefully', async () => {
      const mockUser = {
        id: 123,
        email: 'test@example.com',
        firstName: 'John',
        lastName: 'Doe',
        update: mockUserUpdate.mockResolvedValue(true)
      };
      mockUserFindOne.mockResolvedValue(mockUser);
      mockSendAccountDisconnectedEmail.mockRejectedValue(new Error('Email service down'));

      // Should not throw
      await expect(StripeService.handleDisconnectedAccount('acct_123456789'))
        .resolves.not.toThrow();

      // Should have logged the error
      expect(mockLoggerError).toHaveBeenCalledWith(
        'Failed to clean up disconnected account',
        expect.objectContaining({
          accountId: 'acct_123456789'
        })
      );
    });

    it('should handle user update errors gracefully', async () => {
      const mockUser = {
        id: 123,
        email: 'test@example.com',
        firstName: 'John',
        lastName: 'Doe',
        update: jest.fn().mockRejectedValue(new Error('Database error'))
      };
      mockUserFindOne.mockResolvedValue(mockUser);

      // Should not throw
      await expect(StripeService.handleDisconnectedAccount('acct_123456789'))
        .resolves.not.toThrow();

      expect(mockLoggerError).toHaveBeenCalledWith(
        'Failed to clean up disconnected account',
        expect.objectContaining({
          accountId: 'acct_123456789'
        })
      );
    });

    it('should use lastName as fallback when firstName is not available', async () => {
      const mockUser = {
        id: 123,
        email: 'test@example.com',
        firstName: null,
        lastName: 'Doe',
        update: mockUserUpdate.mockResolvedValue(true)
      };
      mockUserFindOne.mockResolvedValue(mockUser);
      mockSendAccountDisconnectedEmail.mockResolvedValue(true);

      await StripeService.handleDisconnectedAccount('acct_123456789');

      expect(mockSendAccountDisconnectedEmail).toHaveBeenCalledWith('test@example.com', {
        ownerName: 'Doe',
        hasPendingPayouts: true,
        pendingPayoutCount: 1
      });
    });
  });

  describe('createTransfer - disconnected account handling', () => {
    beforeEach(() => {
      mockUserFindOne.mockReset();
      mockSendAccountDisconnectedEmail.mockReset();
      mockLoggerWarn.mockReset();
    });

    it('should call handleDisconnectedAccount when account_invalid error occurs', async () => {
      const disconnectedError = new Error('The account has been deauthorized');
      disconnectedError.code = 'account_invalid';
      mockStripeTransfersCreate.mockRejectedValue(disconnectedError);

      const mockUser = {
        id: 123,
        email: 'test@example.com',
        firstName: 'John',
        update: mockUserUpdate.mockResolvedValue(true)
      };
      mockUserFindOne.mockResolvedValue(mockUser);
      mockSendAccountDisconnectedEmail.mockResolvedValue(true);

      await expect(StripeService.createTransfer({
        amount: 50.00,
        destination: 'acct_disconnected'
      })).rejects.toThrow('The account has been deauthorized');

      // Wait for async handleDisconnectedAccount to complete
      await new Promise(resolve => setTimeout(resolve, 10));

      expect(mockLoggerWarn).toHaveBeenCalledWith(
        'Transfer failed - account appears disconnected',
        expect.objectContaining({
          destination: 'acct_disconnected',
          errorCode: 'account_invalid'
        })
      );
    });

    it('should still throw the original error after cleanup', async () => {
      const disconnectedError = new Error('Cannot transfer to this account');
      disconnectedError.code = 'account_invalid';
      mockStripeTransfersCreate.mockRejectedValue(disconnectedError);

      mockUserFindOne.mockResolvedValue(null);

      await expect(StripeService.createTransfer({
        amount: 50.00,
        destination: 'acct_disconnected'
      })).rejects.toThrow('Cannot transfer to this account');
    });

    it('should log warning for disconnected account errors', async () => {
      const disconnectedError = new Error('This account is no longer connected');
      disconnectedError.code = 'some_error';
      disconnectedError.type = 'StripeInvalidRequestError';
      mockStripeTransfersCreate.mockRejectedValue(disconnectedError);

      mockUserFindOne.mockResolvedValue(null);

      await expect(StripeService.createTransfer({
        amount: 50.00,
        destination: 'acct_disconnected'
      })).rejects.toThrow('This account is no longer connected');

      expect(mockLoggerWarn).toHaveBeenCalledWith(
        'Transfer failed - account appears disconnected',
        expect.objectContaining({
          destination: 'acct_disconnected'
        })
      );
    });

    it('should not call handleDisconnectedAccount for non-disconnection errors', async () => {
      const normalError = new Error('Insufficient balance');
      normalError.code = 'insufficient_balance';
      mockStripeTransfersCreate.mockRejectedValue(normalError);

      await expect(StripeService.createTransfer({
        amount: 50.00,
        destination: 'acct_123'
      })).rejects.toThrow('Insufficient balance');

      expect(mockLoggerWarn).not.toHaveBeenCalledWith(
        'Transfer failed - account appears disconnected',
        expect.any(Object)
      );
    });
  });

  describe('chargePaymentMethod - additional cases', () => {
    it('should handle authentication_required error and return requires_action', async () => {
      const authError = new Error('Authentication required');
      authError.code = 'authentication_required';
      authError.payment_intent = {
        id: 'pi_requires_auth',
        client_secret: 'pi_requires_auth_secret'
      };
      mockStripePaymentIntentsCreate.mockRejectedValue(authError);

      const result = await StripeService.chargePaymentMethod(
        'pm_123',
        50.00,
        'cus_123'
      );

      expect(result.status).toBe('requires_action');
      expect(result.requiresAction).toBe(true);
      expect(result.paymentIntentId).toBe('pi_requires_auth');
      expect(result.clientSecret).toBe('pi_requires_auth_secret');
    });

    it('should handle us_bank_account payment method type', async () => {
      const mockPaymentIntent = {
        id: 'pi_bank',
        status: 'succeeded',
        client_secret: 'pi_bank_secret',
        created: Date.now() / 1000,
        latest_charge: {
          payment_method_details: {
            type: 'us_bank_account',
            us_bank_account: {
              last4: '6789',
              bank_name: 'Test Bank'
            }
          }
        }
      };

      mockStripePaymentIntentsCreate.mockResolvedValue(mockPaymentIntent);

      const result = await StripeService.chargePaymentMethod(
        'pm_bank_123',
        50.00,
        'cus_123'
      );

      expect(result.status).toBe('succeeded');
      expect(result.paymentMethod).toEqual({
        type: 'bank',
        brand: 'bank_account',
        last4: '6789'
      });
    });

    it('should handle unknown payment method type', async () => {
      const mockPaymentIntent = {
        id: 'pi_unknown',
        status: 'succeeded',
        client_secret: 'pi_unknown_secret',
        created: Date.now() / 1000,
        latest_charge: {
          payment_method_details: {
            type: 'crypto_wallet'
          }
        }
      };

      mockStripePaymentIntentsCreate.mockResolvedValue(mockPaymentIntent);

      const result = await StripeService.chargePaymentMethod(
        'pm_crypto_123',
        50.00,
        'cus_123'
      );

      expect(result.status).toBe('succeeded');
      expect(result.paymentMethod).toEqual({
        type: 'crypto_wallet',
        brand: 'crypto_wallet',
        last4: null
      });
    });

    it('should handle payment with no charge details', async () => {
      const mockPaymentIntent = {
        id: 'pi_no_charge',
        status: 'succeeded',
        client_secret: 'pi_no_charge_secret',
        created: Date.now() / 1000,
        latest_charge: null
      };

      mockStripePaymentIntentsCreate.mockResolvedValue(mockPaymentIntent);

      const result = await StripeService.chargePaymentMethod(
        'pm_123',
        50.00,
        'cus_123'
      );

      expect(result.status).toBe('succeeded');
      expect(result.paymentMethod).toBeNull();
    });

    it('should handle card with missing details gracefully', async () => {
      const mockPaymentIntent = {
        id: 'pi_card_no_details',
        status: 'succeeded',
        client_secret: 'pi_card_secret',
        created: Date.now() / 1000,
        latest_charge: {
          payment_method_details: {
            type: 'card',
            card: {} // Missing brand and last4
          }
        }
      };

      mockStripePaymentIntentsCreate.mockResolvedValue(mockPaymentIntent);

      const result = await StripeService.chargePaymentMethod(
        'pm_123',
        50.00,
        'cus_123'
      );

      expect(result.status).toBe('succeeded');
      expect(result.paymentMethod).toEqual({
        type: 'card',
        brand: 'card',
        last4: '****'
      });
    });
  });
});