const request = require('supertest');
const express = require('express');
const jwt = require('jsonwebtoken');

// Mock dependencies
jest.mock('jsonwebtoken');
jest.mock('../../../models', () => ({
  User: {
    findByPk: jest.fn(),
    create: jest.fn(),
    findOne: jest.fn()
  },
  Item: {}
}));

jest.mock('../../../services/stripeService', () => ({
  getCheckoutSession: jest.fn(),
  createConnectedAccount: jest.fn(),
  createAccountLink: jest.fn(),
  getAccountStatus: jest.fn(),
  createCustomer: jest.fn(),
  createSetupCheckoutSession: jest.fn()
}));

// Mock auth middleware
jest.mock('../../../middleware/auth', () => ({
  authenticateToken: (req, res, next) => {
    // Mock authenticated user
    if (req.headers.authorization) {
      req.user = { id: 1 };
      next();
    } else {
      res.status(401).json({ error: 'No token provided' });
    }
  }
}));

const { User } = require('../../../models');
const StripeService = require('../../../services/stripeService');
const stripeRoutes = require('../../../routes/stripe');

// Set up Express app for testing
const app = express();
app.use(express.json());
app.use('/stripe', stripeRoutes);

describe('Stripe Routes', () => {
  let consoleSpy, consoleErrorSpy;

  beforeEach(() => {
    jest.clearAllMocks();

    // Set up console spies
    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
  });

  afterEach(() => {
    consoleSpy.mockRestore();
    consoleErrorSpy.mockRestore();
  });

  describe('GET /checkout-session/:sessionId', () => {
    it('should retrieve checkout session successfully', async () => {
      const mockSession = {
        status: 'complete',
        payment_status: 'paid',
        customer_details: {
          email: 'test@example.com'
        },
        setup_intent: {
          id: 'seti_123456789',
          status: 'succeeded'
        },
        metadata: {
          userId: '1'
        }
      };

      StripeService.getCheckoutSession.mockResolvedValue(mockSession);

      const response = await request(app)
        .get('/stripe/checkout-session/cs_123456789');

      expect(response.status).toBe(200);
      expect(response.body).toEqual({
        status: 'complete',
        payment_status: 'paid',
        customer_email: 'test@example.com',
        setup_intent: {
          id: 'seti_123456789',
          status: 'succeeded'
        },
        metadata: {
          userId: '1'
        }
      });

      expect(StripeService.getCheckoutSession).toHaveBeenCalledWith('cs_123456789');
    });

    it('should handle missing customer_details gracefully', async () => {
      const mockSession = {
        status: 'complete',
        payment_status: 'paid',
        customer_details: null,
        setup_intent: null,
        metadata: {}
      };

      StripeService.getCheckoutSession.mockResolvedValue(mockSession);

      const response = await request(app)
        .get('/stripe/checkout-session/cs_123456789');

      expect(response.status).toBe(200);
      expect(response.body).toEqual({
        status: 'complete',
        payment_status: 'paid',
        customer_email: undefined,
        setup_intent: null,
        metadata: {}
      });
    });

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

      const response = await request(app)
        .get('/stripe/checkout-session/invalid_session');

      expect(response.status).toBe(500);
      expect(response.body).toEqual({ error: 'Session not found' });
      expect(consoleErrorSpy).toHaveBeenCalledWith(
        'Error retrieving checkout session:',
        error
      );
    });

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

      const response = await request(app)
        .get('/stripe/checkout-session/');

      expect(response.status).toBe(404);
    });
  });

  describe('POST /accounts', () => {
    const mockUser = {
      id: 1,
      email: 'test@example.com',
      stripeConnectedAccountId: null,
      update: jest.fn()
    };

    beforeEach(() => {
      mockUser.update.mockReset();
      mockUser.stripeConnectedAccountId = null;
    });

    it('should create connected account successfully', async () => {
      const mockAccount = {
        id: 'acct_123456789',
        email: 'test@example.com',
        country: 'US'
      };

      User.findByPk.mockResolvedValue(mockUser);
      StripeService.createConnectedAccount.mockResolvedValue(mockAccount);
      mockUser.update.mockResolvedValue(mockUser);

      const response = await request(app)
        .post('/stripe/accounts')
        .set('Authorization', 'Bearer valid_token');

      expect(response.status).toBe(200);
      expect(response.body).toEqual({
        stripeConnectedAccountId: 'acct_123456789',
        success: true
      });

      expect(User.findByPk).toHaveBeenCalledWith(1);
      expect(StripeService.createConnectedAccount).toHaveBeenCalledWith({
        email: 'test@example.com',
        country: 'US'
      });
      expect(mockUser.update).toHaveBeenCalledWith({
        stripeConnectedAccountId: 'acct_123456789'
      });
    });

    it('should return error if user not found', async () => {
      User.findByPk.mockResolvedValue(null);

      const response = await request(app)
        .post('/stripe/accounts')
        .set('Authorization', 'Bearer valid_token');

      expect(response.status).toBe(404);
      expect(response.body).toEqual({ error: 'User not found' });
      expect(StripeService.createConnectedAccount).not.toHaveBeenCalled();
    });

    it('should return error if user already has connected account', async () => {
      const userWithAccount = {
        ...mockUser,
        stripeConnectedAccountId: 'acct_existing'
      };

      User.findByPk.mockResolvedValue(userWithAccount);

      const response = await request(app)
        .post('/stripe/accounts')
        .set('Authorization', 'Bearer valid_token');

      expect(response.status).toBe(400);
      expect(response.body).toEqual({ error: 'User already has a connected account' });
      expect(StripeService.createConnectedAccount).not.toHaveBeenCalled();
    });

    it('should require authentication', async () => {
      const response = await request(app)
        .post('/stripe/accounts');

      expect(response.status).toBe(401);
      expect(response.body).toEqual({ error: 'No token provided' });
    });

    it('should handle Stripe account creation errors', async () => {
      const error = new Error('Invalid email address');

      User.findByPk.mockResolvedValue(mockUser);
      StripeService.createConnectedAccount.mockRejectedValue(error);

      const response = await request(app)
        .post('/stripe/accounts')
        .set('Authorization', 'Bearer valid_token');

      expect(response.status).toBe(500);
      expect(response.body).toEqual({ error: 'Invalid email address' });
      expect(consoleErrorSpy).toHaveBeenCalledWith(
        'Error creating connected account:',
        error
      );
    });

    it('should handle database update errors', async () => {
      const mockAccount = { id: 'acct_123456789' };
      const dbError = new Error('Database update failed');

      User.findByPk.mockResolvedValue(mockUser);
      StripeService.createConnectedAccount.mockResolvedValue(mockAccount);
      mockUser.update.mockRejectedValue(dbError);

      const response = await request(app)
        .post('/stripe/accounts')
        .set('Authorization', 'Bearer valid_token');

      expect(response.status).toBe(500);
      expect(response.body).toEqual({ error: 'Database update failed' });
    });
  });

  describe('POST /account-links', () => {
    const mockUser = {
      id: 1,
      stripeConnectedAccountId: 'acct_123456789'
    };

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

      User.findByPk.mockResolvedValue(mockUser);
      StripeService.createAccountLink.mockResolvedValue(mockAccountLink);

      const response = await request(app)
        .post('/stripe/account-links')
        .set('Authorization', 'Bearer valid_token')
        .send({
          refreshUrl: 'http://localhost:3000/refresh',
          returnUrl: 'http://localhost:3000/return'
        });

      expect(response.status).toBe(200);
      expect(response.body).toEqual({
        url: mockAccountLink.url,
        expiresAt: mockAccountLink.expires_at
      });

      expect(StripeService.createAccountLink).toHaveBeenCalledWith(
        'acct_123456789',
        'http://localhost:3000/refresh',
        'http://localhost:3000/return'
      );
    });

    it('should return error if no connected account found', async () => {
      const userWithoutAccount = {
        id: 1,
        stripeConnectedAccountId: null
      };

      User.findByPk.mockResolvedValue(userWithoutAccount);

      const response = await request(app)
        .post('/stripe/account-links')
        .set('Authorization', 'Bearer valid_token')
        .send({
          refreshUrl: 'http://localhost:3000/refresh',
          returnUrl: 'http://localhost:3000/return'
        });

      expect(response.status).toBe(400);
      expect(response.body).toEqual({ error: 'No connected account found' });
      expect(StripeService.createAccountLink).not.toHaveBeenCalled();
    });

    it('should return error if user not found', async () => {
      User.findByPk.mockResolvedValue(null);

      const response = await request(app)
        .post('/stripe/account-links')
        .set('Authorization', 'Bearer valid_token')
        .send({
          refreshUrl: 'http://localhost:3000/refresh',
          returnUrl: 'http://localhost:3000/return'
        });

      expect(response.status).toBe(400);
      expect(response.body).toEqual({ error: 'No connected account found' });
    });

    it('should validate required URLs', async () => {
      User.findByPk.mockResolvedValue(mockUser);

      const response = await request(app)
        .post('/stripe/account-links')
        .set('Authorization', 'Bearer valid_token')
        .send({
          refreshUrl: 'http://localhost:3000/refresh'
          // Missing returnUrl
        });

      expect(response.status).toBe(400);
      expect(response.body).toEqual({ error: 'refreshUrl and returnUrl are required' });
      expect(StripeService.createAccountLink).not.toHaveBeenCalled();
    });

    it('should validate both URLs are provided', async () => {
      User.findByPk.mockResolvedValue(mockUser);

      const response = await request(app)
        .post('/stripe/account-links')
        .set('Authorization', 'Bearer valid_token')
        .send({
          returnUrl: 'http://localhost:3000/return'
          // Missing refreshUrl
        });

      expect(response.status).toBe(400);
      expect(response.body).toEqual({ error: 'refreshUrl and returnUrl are required' });
    });

    it('should require authentication', async () => {
      const response = await request(app)
        .post('/stripe/account-links')
        .send({
          refreshUrl: 'http://localhost:3000/refresh',
          returnUrl: 'http://localhost:3000/return'
        });

      expect(response.status).toBe(401);
    });

    it('should handle Stripe account link creation errors', async () => {
      const error = new Error('Account not found');

      User.findByPk.mockResolvedValue(mockUser);
      StripeService.createAccountLink.mockRejectedValue(error);

      const response = await request(app)
        .post('/stripe/account-links')
        .set('Authorization', 'Bearer valid_token')
        .send({
          refreshUrl: 'http://localhost:3000/refresh',
          returnUrl: 'http://localhost:3000/return'
        });

      expect(response.status).toBe(500);
      expect(response.body).toEqual({ error: 'Account not found' });
      expect(consoleErrorSpy).toHaveBeenCalledWith(
        'Error creating account link:',
        error
      );
    });
  });

  describe('GET /account-status', () => {
    const mockUser = {
      id: 1,
      stripeConnectedAccountId: 'acct_123456789'
    };

    it('should get account status successfully', async () => {
      const mockAccountStatus = {
        id: 'acct_123456789',
        details_submitted: true,
        payouts_enabled: true,
        capabilities: {
          transfers: { status: 'active' }
        },
        requirements: {
          pending_verification: [],
          currently_due: [],
          past_due: []
        }
      };

      User.findByPk.mockResolvedValue(mockUser);
      StripeService.getAccountStatus.mockResolvedValue(mockAccountStatus);

      const response = await request(app)
        .get('/stripe/account-status')
        .set('Authorization', 'Bearer valid_token');

      expect(response.status).toBe(200);
      expect(response.body).toEqual({
        accountId: 'acct_123456789',
        detailsSubmitted: true,
        payoutsEnabled: true,
        capabilities: {
          transfers: { status: 'active' }
        },
        requirements: {
          pending_verification: [],
          currently_due: [],
          past_due: []
        }
      });

      expect(StripeService.getAccountStatus).toHaveBeenCalledWith('acct_123456789');
    });

    it('should return error if no connected account found', async () => {
      const userWithoutAccount = {
        id: 1,
        stripeConnectedAccountId: null
      };

      User.findByPk.mockResolvedValue(userWithoutAccount);

      const response = await request(app)
        .get('/stripe/account-status')
        .set('Authorization', 'Bearer valid_token');

      expect(response.status).toBe(400);
      expect(response.body).toEqual({ error: 'No connected account found' });
      expect(StripeService.getAccountStatus).not.toHaveBeenCalled();
    });

    it('should return error if user not found', async () => {
      User.findByPk.mockResolvedValue(null);

      const response = await request(app)
        .get('/stripe/account-status')
        .set('Authorization', 'Bearer valid_token');

      expect(response.status).toBe(400);
      expect(response.body).toEqual({ error: 'No connected account found' });
    });

    it('should require authentication', async () => {
      const response = await request(app)
        .get('/stripe/account-status');

      expect(response.status).toBe(401);
    });

    it('should handle Stripe account status retrieval errors', async () => {
      const error = new Error('Account not found');

      User.findByPk.mockResolvedValue(mockUser);
      StripeService.getAccountStatus.mockRejectedValue(error);

      const response = await request(app)
        .get('/stripe/account-status')
        .set('Authorization', 'Bearer valid_token');

      expect(response.status).toBe(500);
      expect(response.body).toEqual({ error: 'Account not found' });
      expect(consoleErrorSpy).toHaveBeenCalledWith(
        'Error getting account status:',
        error
      );
    });
  });

  describe('POST /create-setup-checkout-session', () => {
    const mockUser = {
      id: 1,
      email: 'test@example.com',
      firstName: 'John',
      lastName: 'Doe',
      stripeCustomerId: null,
      update: jest.fn()
    };

    beforeEach(() => {
      mockUser.update.mockReset();
      mockUser.stripeCustomerId = null;
    });

    it('should create setup checkout session for new customer', async () => {
      const mockCustomer = {
        id: 'cus_123456789',
        email: 'test@example.com'
      };

      const mockSession = {
        id: 'cs_123456789',
        client_secret: 'cs_123456789_secret_test'
      };

      const rentalData = {
        itemId: '123',
        startDate: '2023-12-01',
        endDate: '2023-12-03'
      };

      User.findByPk.mockResolvedValue(mockUser);
      StripeService.createCustomer.mockResolvedValue(mockCustomer);
      StripeService.createSetupCheckoutSession.mockResolvedValue(mockSession);
      mockUser.update.mockResolvedValue(mockUser);

      const response = await request(app)
        .post('/stripe/create-setup-checkout-session')
        .set('Authorization', 'Bearer valid_token')
        .send({ rentalData });

      expect(response.status).toBe(200);
      expect(response.body).toEqual({
        clientSecret: 'cs_123456789_secret_test',
        sessionId: 'cs_123456789'
      });

      expect(User.findByPk).toHaveBeenCalledWith(1);
      expect(StripeService.createCustomer).toHaveBeenCalledWith({
        email: 'test@example.com',
        name: 'John Doe',
        metadata: {
          userId: '1'
        }
      });
      expect(mockUser.update).toHaveBeenCalledWith({ stripeCustomerId: 'cus_123456789' });
      expect(StripeService.createSetupCheckoutSession).toHaveBeenCalledWith({
        customerId: 'cus_123456789',
        metadata: {
          rentalData: JSON.stringify(rentalData)
        }
      });
    });

    it('should use existing customer ID if available', async () => {
      const userWithCustomer = {
        ...mockUser,
        stripeCustomerId: 'cus_existing123'
      };

      const mockSession = {
        id: 'cs_123456789',
        client_secret: 'cs_123456789_secret_test'
      };

      User.findByPk.mockResolvedValue(userWithCustomer);
      StripeService.createSetupCheckoutSession.mockResolvedValue(mockSession);

      const response = await request(app)
        .post('/stripe/create-setup-checkout-session')
        .set('Authorization', 'Bearer valid_token')
        .send({});

      expect(response.status).toBe(200);
      expect(response.body).toEqual({
        clientSecret: 'cs_123456789_secret_test',
        sessionId: 'cs_123456789'
      });

      expect(StripeService.createCustomer).not.toHaveBeenCalled();
      expect(userWithCustomer.update).not.toHaveBeenCalled();
      expect(StripeService.createSetupCheckoutSession).toHaveBeenCalledWith({
        customerId: 'cus_existing123',
        metadata: {}
      });
    });

    it('should handle session without rental data', async () => {
      const mockCustomer = {
        id: 'cus_123456789'
      };

      const mockSession = {
        id: 'cs_123456789',
        client_secret: 'cs_123456789_secret_test'
      };

      User.findByPk.mockResolvedValue(mockUser);
      StripeService.createCustomer.mockResolvedValue(mockCustomer);
      StripeService.createSetupCheckoutSession.mockResolvedValue(mockSession);
      mockUser.update.mockResolvedValue(mockUser);

      const response = await request(app)
        .post('/stripe/create-setup-checkout-session')
        .set('Authorization', 'Bearer valid_token')
        .send({});

      expect(response.status).toBe(200);
      expect(StripeService.createSetupCheckoutSession).toHaveBeenCalledWith({
        customerId: 'cus_123456789',
        metadata: {}
      });
    });

    it('should return error if user not found', async () => {
      User.findByPk.mockResolvedValue(null);

      const response = await request(app)
        .post('/stripe/create-setup-checkout-session')
        .set('Authorization', 'Bearer valid_token')
        .send({});

      expect(response.status).toBe(404);
      expect(response.body).toEqual({ error: 'User not found' });
      expect(StripeService.createCustomer).not.toHaveBeenCalled();
      expect(StripeService.createSetupCheckoutSession).not.toHaveBeenCalled();
    });

    it('should require authentication', async () => {
      const response = await request(app)
        .post('/stripe/create-setup-checkout-session')
        .send({});

      expect(response.status).toBe(401);
    });

    it('should handle customer creation errors', async () => {
      const error = new Error('Invalid email address');

      User.findByPk.mockResolvedValue(mockUser);
      StripeService.createCustomer.mockRejectedValue(error);

      const response = await request(app)
        .post('/stripe/create-setup-checkout-session')
        .set('Authorization', 'Bearer valid_token')
        .send({});

      expect(response.status).toBe(500);
      expect(response.body).toEqual({ error: 'Invalid email address' });
      expect(consoleErrorSpy).toHaveBeenCalledWith(
        'Error creating setup checkout session:',
        error
      );
    });

    it('should handle database update errors', async () => {
      const mockCustomer = { id: 'cus_123456789' };
      const dbError = new Error('Database update failed');

      User.findByPk.mockResolvedValue(mockUser);
      StripeService.createCustomer.mockResolvedValue(mockCustomer);
      mockUser.update.mockRejectedValue(dbError);

      const response = await request(app)
        .post('/stripe/create-setup-checkout-session')
        .set('Authorization', 'Bearer valid_token')
        .send({});

      expect(response.status).toBe(500);
      expect(response.body).toEqual({ error: 'Database update failed' });
    });

    it('should handle session creation errors', async () => {
      const mockCustomer = { id: 'cus_123456789' };
      const sessionError = new Error('Session creation failed');

      User.findByPk.mockResolvedValue(mockUser);
      StripeService.createCustomer.mockResolvedValue(mockCustomer);
      mockUser.update.mockResolvedValue(mockUser);
      StripeService.createSetupCheckoutSession.mockRejectedValue(sessionError);

      const response = await request(app)
        .post('/stripe/create-setup-checkout-session')
        .set('Authorization', 'Bearer valid_token')
        .send({});

      expect(response.status).toBe(500);
      expect(response.body).toEqual({ error: 'Session creation failed' });
    });

    it('should handle complex rental data', async () => {
      const mockCustomer = { id: 'cus_123456789' };
      const mockSession = {
        id: 'cs_123456789',
        client_secret: 'cs_123456789_secret_test'
      };

      const complexRentalData = {
        itemId: '123',
        startDate: '2023-12-01',
        endDate: '2023-12-03',
        totalAmount: 150.00,
        additionalServices: ['cleaning', 'delivery'],
        notes: 'Special instructions'
      };

      User.findByPk.mockResolvedValue(mockUser);
      StripeService.createCustomer.mockResolvedValue(mockCustomer);
      StripeService.createSetupCheckoutSession.mockResolvedValue(mockSession);
      mockUser.update.mockResolvedValue(mockUser);

      const response = await request(app)
        .post('/stripe/create-setup-checkout-session')
        .set('Authorization', 'Bearer valid_token')
        .send({ rentalData: complexRentalData });

      expect(response.status).toBe(200);
      expect(StripeService.createSetupCheckoutSession).toHaveBeenCalledWith({
        customerId: 'cus_123456789',
        metadata: {
          rentalData: JSON.stringify(complexRentalData)
        }
      });
    });
  });

  describe('Error handling and edge cases', () => {
    it('should handle malformed JSON in rental data', async () => {
      const mockUser = {
        id: 1,
        email: 'test@example.com',
        firstName: 'John',
        lastName: 'Doe',
        stripeCustomerId: 'cus_123456789'
      };

      User.findByPk.mockResolvedValue(mockUser);

      // This should work fine as Express will parse valid JSON
      const response = await request(app)
        .post('/stripe/create-setup-checkout-session')
        .set('Authorization', 'Bearer valid_token')
        .set('Content-Type', 'application/json')
        .send('{"rentalData":{"itemId":"123"}}');

      expect(response.status).toBe(200);
    });

    it('should handle very large session IDs', async () => {
      const longSessionId = 'cs_' + 'a'.repeat(100);
      const error = new Error('Session ID too long');

      StripeService.getCheckoutSession.mockRejectedValue(error);

      const response = await request(app)
        .get(`/stripe/checkout-session/${longSessionId}`);

      expect(response.status).toBe(500);
      expect(response.body).toEqual({ error: 'Session ID too long' });
    });

    it('should handle concurrent requests for same user', async () => {
      const mockUser = {
        id: 1,
        email: 'test@example.com',
        stripeConnectedAccountId: null,
        update: jest.fn().mockResolvedValue({})
      };

      const mockAccount = { id: 'acct_123456789' };

      User.findByPk.mockResolvedValue(mockUser);
      StripeService.createConnectedAccount.mockResolvedValue(mockAccount);

      // Simulate concurrent requests
      const [response1, response2] = await Promise.all([
        request(app)
          .post('/stripe/accounts')
          .set('Authorization', 'Bearer valid_token'),
        request(app)
          .post('/stripe/accounts')
          .set('Authorization', 'Bearer valid_token')
      ]);

      // Both should succeed (in this test scenario)
      expect(response1.status).toBe(200);
      expect(response2.status).toBe(200);
    });
  });
});