// user-service.ts
export class UserService {
  constructor(
    private readonly userRepo: UserRepository,
    private readonly emailService: EmailService,
  ) {}

  async registerUser(email: string, name: string): Promise<User> {
    const existing = await this.userRepo.findByEmail(email);
    if (existing) throw new ConflictError('Email already registered');

    const user = await this.userRepo.create({ email, name });
    await this.emailService.sendWelcome(user);
    return user;
  }
}

// user-service.test.ts
import { UserService } from './user-service';
import { UserRepository } from './user-repository';
import { EmailService } from './email-service';
import { ConflictError } from './errors';

// Create typed mocks using jest.Mocked<T>
const mockUserRepo: jest.Mocked<UserRepository> = {
  findByEmail: jest.fn(),
  create: jest.fn(),
  findById: jest.fn(),
  update: jest.fn(),
  delete: jest.fn(),
};

const mockEmailService: jest.Mocked<EmailService> = {
  sendWelcome: jest.fn(),
  sendPasswordReset: jest.fn(),
  sendNotification: jest.fn(),
};

describe('UserService', () => {
  let service: UserService;

  beforeEach(() => {
    jest.clearAllMocks();
    service = new UserService(mockUserRepo, mockEmailService);
  });

  describe('registerUser', () => {
    const mockUser = { id: '123', email: 'test@example.com', name: 'Test User' };

    it('creates a new user and sends welcome email', async () => {
      mockUserRepo.findByEmail.mockResolvedValue(null);
      mockUserRepo.create.mockResolvedValue(mockUser);
      mockEmailService.sendWelcome.mockResolvedValue(undefined);

      const result = await service.registerUser('test@example.com', 'Test User');

      expect(mockUserRepo.findByEmail).toHaveBeenCalledWith('test@example.com');
      expect(mockUserRepo.create).toHaveBeenCalledWith({
        email: 'test@example.com',
        name: 'Test User',
      });
      expect(mockEmailService.sendWelcome).toHaveBeenCalledWith(mockUser);
      expect(result).toEqual(mockUser);
    });

    it('throws ConflictError when email already exists', async () => {
      mockUserRepo.findByEmail.mockResolvedValue(mockUser);

      await expect(
        service.registerUser('test@example.com', 'Test User')
      ).rejects.toThrow(ConflictError);

      expect(mockUserRepo.create).not.toHaveBeenCalled();
      expect(mockEmailService.sendWelcome).not.toHaveBeenCalled();
    });

    it('propagates email service failure', async () => {
      mockUserRepo.findByEmail.mockResolvedValue(null);
      mockUserRepo.create.mockResolvedValue(mockUser);
      mockEmailService.sendWelcome.mockRejectedValue(new Error('SMTP failure'));

      await expect(
        service.registerUser('test@example.com', 'Test User')
      ).rejects.toThrow('SMTP failure');
    });
  });
});

// retry.ts
export async function withRetry<T>(
  fn: () => Promise<T>,
  maxAttempts: number = 3,
  baseDelayMs: number = 1000,
): Promise<T> {
  let lastError: Error;

  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      return await fn();
    } catch (err) {
      lastError = err as Error;
      if (attempt < maxAttempts) {
        const delay = baseDelayMs * Math.pow(2, attempt - 1);
        await new Promise(resolve => setTimeout(resolve, delay));
      }
    }
  }

  throw lastError!;
}

// retry.test.ts
import { withRetry } from './retry';

describe('withRetry', () => {
  beforeEach(() => {
    jest.useFakeTimers();
  });

  afterEach(() => {
    jest.useRealTimers();
  });

  it('returns result on first success', async () => {
    const fn = jest.fn().mockResolvedValue('ok');
    await expect(withRetry(fn)).resolves.toBe('ok');
    expect(fn).toHaveBeenCalledTimes(1);
  });

  it('retries and succeeds on third attempt', async () => {
    const fn = jest.fn()
      .mockRejectedValueOnce(new Error('fail 1'))
      .mockRejectedValueOnce(new Error('fail 2'))
      .mockResolvedValueOnce('success');

    // Start the retry (don't await yet — it's waiting on a timer)
    const resultPromise = withRetry(fn, 3, 1000);

    // Advance past first backoff (1000ms)
    await jest.advanceTimersByTimeAsync(1000);
    // Advance past second backoff (2000ms)
    await jest.advanceTimersByTimeAsync(2000);

    await expect(resultPromise).resolves.toBe('success');
    expect(fn).toHaveBeenCalledTimes(3);
  });

  it('throws after exhausting all retries', async () => {
    const fn = jest.fn().mockRejectedValue(new Error('persistent failure'));

    const resultPromise = withRetry(fn, 3, 100);

    // Advance past both backoff delays
    await jest.advanceTimersByTimeAsync(100);
    await jest.advanceTimersByTimeAsync(200);

    await expect(resultPromise).rejects.toThrow('persistent failure');
    expect(fn).toHaveBeenCalledTimes(3);
  });
});

// handlers.ts — MSW request handlers
import { http, HttpResponse } from 'msw';

export const handlers = [
  http.get('/api/users/:id', ({ params }) => {
    if (params.id === '404') {
      return HttpResponse.json({ error: 'Not found' }, { status: 404 });
    }
    return HttpResponse.json({
      id: params.id,
      name: 'Test User',
      email: 'test@example.com',
    });
  }),

  http.post('/api/users', async ({ request }) => {
    const body = await request.json() as Record<string, unknown>;
    if (!body.email) {
      return HttpResponse.json({ error: 'Email required' }, { status: 400 });
    }
    return HttpResponse.json({ id: 'new-123', ...body }, { status: 201 });
  }),
];

// setupTests.ts
import { setupServer } from 'msw/node';
import { handlers } from './handlers';

export const server = setupServer(...handlers);

beforeAll(() => server.listen({ onUnhandledRequest: 'error' }));
afterEach(() => server.resetHandlers());
afterAll(() => server.close());

// user-profile.test.tsx
import { render, screen, waitFor } from '@testing-library/react';
import { server } from './setupTests';
import { http, HttpResponse } from 'msw';
import UserProfile from './UserProfile';

it('displays user data', async () => {
  render(<UserProfile userId="123" />);
  await waitFor(() => expect(screen.getByText('Test User')).toBeInTheDocument());
});

it('shows error on 404', async () => {
  render(<UserProfile userId="404" />);
  await waitFor(() => expect(screen.getByText(/not found/i)).toBeInTheDocument());
});

it('handles server error', async () => {
  // Override handler for this test only
  server.use(
    http.get('/api/users/:id', () => HttpResponse.json({}, { status: 500 }))
  );

  render(<UserProfile userId="123" />);
  await waitFor(() => expect(screen.getByText(/something went wrong/i)).toBeInTheDocument());
});