const request = require('supertest');

// Mock Redis
const mockRedis = { get: jest.fn(), set: jest.fn(), hset: jest.fn(), hgetall: jest.fn(), expire: jest.fn() };
jest.mock('../../src/utils/redis', () => ({ getRedisClient: () => mockRedis }));

// Mock Supabase
const mockSupabaseFrom = jest.fn();
const mockSupabaseAuth = { getUser: jest.fn() };
jest.mock('../../src/utils/supabase', () => ({
  getSupabaseClient: () => ({ auth: mockSupabaseAuth, from: mockSupabaseFrom }),
  getSupabaseServiceClient: () => ({ auth: mockSupabaseAuth, from: mockSupabaseFrom }),
}));

// Mock Stripe
jest.mock('stripe', () => {
  return jest.fn().mockImplementation(() => ({
    customers: {
      create: jest.fn().mockResolvedValue({ id: 'cus_test123' }),
    },
    checkout: {
      sessions: {
        create: jest.fn().mockResolvedValue({ url: 'https://checkout.stripe.com/test', id: 'cs_test' }),
      },
    },
    billingPortal: {
      sessions: {
        create: jest.fn().mockResolvedValue({ url: 'https://billing.stripe.com/test' }),
      },
    },
    subscriptions: {
      list: jest.fn().mockResolvedValue({ data: [] }),
    },
    webhooks: {
      constructEvent: jest.fn(),
    },
  }));
});

jest.mock('axios');
process.env.ODDS_API_KEY = 'test';
process.env.STRIPE_SECRET_KEY = 'sk_test_xxx';
process.env.STRIPE_WEBHOOK_SECRET = 'whsec_test';

const app = require('../../src/app');

const MOCK_USER = {
  id: 'user-1', email: 'test@test.com', tier: 'free',
  scan_count: 0, stripe_customer_id: null, founder_status: false,
};

function setupAuthMocks(user = MOCK_USER) {
  mockSupabaseAuth.getUser.mockResolvedValue({
    data: { user: { id: user.id, email: user.email } }, error: null,
  });
  mockSupabaseFrom.mockImplementation((table) => {
    if (table === 'users') {
      return {
        select: () => ({
          eq: () => ({
            single: () => Promise.resolve({ data: user, error: null }),
          }),
        }),
        update: () => ({
          eq: () => Promise.resolve({ error: null }),
        }),
      };
    }
    return { select: () => ({ eq: () => Promise.resolve({ data: [] }) }) };
  });
}

beforeEach(() => {
  jest.clearAllMocks();
  mockRedis.get.mockResolvedValue(null);
  mockRedis.set.mockResolvedValue('OK');
  mockRedis.hset.mockResolvedValue(1);
  mockRedis.hgetall.mockResolvedValue({});
  mockRedis.expire.mockResolvedValue(1);
});

describe('POST /api/stripe/checkout', () => {
  test('creates checkout session and returns URL', async () => {
    setupAuthMocks();
    const res = await request(app)
      .post('/api/stripe/checkout')
      .set('Authorization', 'Bearer valid-token')
      .send({ tier: 'analyst' })
      .expect(200);

    expect(res.body.checkout_url).toBeDefined();
    expect(res.body.session_id).toBeDefined();
  });

  test('returns 400 for invalid tier', async () => {
    setupAuthMocks();
    const res = await request(app)
      .post('/api/stripe/checkout')
      .set('Authorization', 'Bearer valid-token')
      .send({ tier: 'gold' })
      .expect(400);

    expect(res.body.error).toContain('tier');
  });

  test('returns 401 without auth', async () => {
    await request(app)
      .post('/api/stripe/checkout')
      .send({ tier: 'analyst' })
      .expect(401);
  });
});

describe('POST /api/stripe/portal', () => {
  test('returns portal URL for existing customer', async () => {
    setupAuthMocks({ ...MOCK_USER, stripe_customer_id: 'cus_existing' });
    const res = await request(app)
      .post('/api/stripe/portal')
      .set('Authorization', 'Bearer valid-token')
      .expect(200);

    expect(res.body.portal_url).toBeDefined();
  });

  test('returns 400 when no subscription', async () => {
    setupAuthMocks();
    const res = await request(app)
      .post('/api/stripe/portal')
      .set('Authorization', 'Bearer valid-token')
      .expect(400);

    expect(res.body.error).toContain('No active subscription');
  });
});

describe('GET /api/stripe/status', () => {
  test('returns tier and subscription info', async () => {
    setupAuthMocks({ ...MOCK_USER, tier: 'analyst', founder_status: true });
    const res = await request(app)
      .get('/api/stripe/status')
      .set('Authorization', 'Bearer valid-token')
      .expect(200);

    expect(res.body.tier).toBe('analyst');
    expect(res.body.is_founder).toBe(true);
  });
});

describe('POST /api/stripe/webhook', () => {
  test('returns 400 without signature', async () => {
    await request(app)
      .post('/api/stripe/webhook')
      .send('{}')
      .set('Content-Type', 'application/json')
      .expect(400);
  });
});