import { describe, test, expect, beforeEach } from 'bun:test';
import { Hono } from 'hono';
import { ResourceRegistry } from '../src/services/registry.ts';
import { createNovelRouter } from '../src/routes/novel.ts';
import type { ChapterView } from '../src/types.ts';
import type { AppConfig } from '../src/config/types.ts';

// Cache is not exercised by route tests — pass a stub that satisfies the type
const stubCache = {} as import('../src/services/cache.ts').Cache;

const stubAppConfig: AppConfig = {
  server: { port: 8080 },
  selenium: { remoteUrl: 'http://selenium:4444/wd/hub', browser: 'firefox' },
  cache: { basePath: '/tmp' },
  addons: { directory: './addons' },
};

function makeView(id: number, min: number, max: number): ChapterView {
  return { id, min, max, chapters: [] };
}

let registry: ResourceRegistry;
let app: Hono;

beforeEach(() => {
  registry = new ResourceRegistry();
  const router = createNovelRouter(registry, stubCache, stubAppConfig);
  app = new Hono();
  app.route('/qa/requests/novel', router);
});

describe('GET /qa/requests/novel/available', () => {
  test('returns empty object when nothing registered', async () => {
    const res = await app.request('/qa/requests/novel/available');
    expect(res.status).toBe(200);
    const body = await res.json();
    expect(body).toEqual({});
  });

  test('returns registered resources (without fetch fn)', async () => {
    registry.register({
      hash: 'abc123',
      slug: 'my-novel',
      startsAt: 0,
      endsAt: 100,
      fetch: async () => makeView(0, 0, 0),
    });
    const res = await app.request('/qa/requests/novel/available');
    const body = await res.json() as Record<string, unknown>;
    expect(Object.keys(body)).toHaveLength(1);
    expect((body['0'] as Record<string, unknown>)['slug']).toBe('my-novel');
    expect((body['0'] as Record<string, unknown>)['fetch']).toBeUndefined();
  });
});

describe('GET /qa/requests/novel/:novel', () => {
  beforeEach(() => {
    registry.register({
      hash: 'deadbeef',
      slug: 'test-novel',
      startsAt: 0,
      endsAt: 9,
      fetch: async (from, to) => makeView(0, from, to),
    });
  });

  test('returns 400 when r param is missing', async () => {
    const res = await app.request('/qa/requests/novel/0');
    expect(res.status).toBe(400);
    const body = await res.json() as { error: string };
    expect(body.error).toContain('Missing');
  });

  test('returns 400 for malformed r param', async () => {
    const res = await app.request('/qa/requests/novel/0?r=notanumber');
    expect(res.status).toBe(400);
  });

  test('returns 400 when min > max', async () => {
    const res = await app.request('/qa/requests/novel/0?r=10,5');
    expect(res.status).toBe(400);
  });

  test('returns 422 for unknown novel id', async () => {
    const res = await app.request('/qa/requests/novel/999?r=0,5');
    expect(res.status).toBe(422);
    const body = await res.json() as { error: string };
    expect(body.error).toContain('Unknown');
  });

  test('returns 400 for non-integer novel id', async () => {
    const res = await app.request('/qa/requests/novel/abc?r=0,5');
    expect(res.status).toBe(400);
  });

  test('returns 200 html by default', async () => {
    const res = await app.request('/qa/requests/novel/0?r=0,0');
    // fetch returns empty chapters so HTML template would be rendered (template read from disk)
    // We just verify it doesn't 5xx from the route layer itself
    expect([200, 500]).toContain(res.status);
  });

  test('returns 200 json when f=json', async () => {
    const res = await app.request('/qa/requests/novel/0?r=0,0&f=json');
    expect([200, 500]).toContain(res.status);
    if (res.status === 200) {
      expect(res.headers.get('content-type')).toContain('application/json');
    }
  });

  test('returns 500 when fetch throws', async () => {
    registry.register({
      hash: 'badfetch',
      slug: 'broken-novel',
      startsAt: 0,
      endsAt: 0,
      fetch: async () => { throw new Error('something went wrong internally'); },
    });
    const res = await app.request('/qa/requests/novel/1?r=0,0');
    expect(res.status).toBe(500);
    const body = await res.json() as { error: string; detail: string };
    expect(body.error).toBeDefined();
    expect(body.detail).toBe('something went wrong internally');
  });
});

describe('POST /qa/requests/novel/new', () => {
  test('returns 400 for non-JSON body', async () => {
    const res = await app.request('/qa/requests/novel/new', {
      method: 'POST',
      body: 'not json',
      headers: { 'Content-Type': 'text/plain' },
    });
    expect(res.status).toBe(400);
  });

  test('returns 400 when type is missing', async () => {
    const res = await app.request('/qa/requests/novel/new', {
      method: 'POST',
      body: JSON.stringify({ slug: 'test', urls: ['http://x.com/book.epub'] }),
      headers: { 'Content-Type': 'application/json' },
    });
    expect(res.status).toBe(400);
  });

  test('returns 400 for unsupported type', async () => {
    const res = await app.request('/qa/requests/novel/new', {
      method: 'POST',
      body: JSON.stringify({ type: 'novel', slug: 'test', urls: ['http://x.com'] }),
      headers: { 'Content-Type': 'application/json' },
    });
    expect(res.status).toBe(400);
    const body = await res.json() as { error: string };
    expect(body.error).toContain('Unsupported');
  });

  test('registers an epub and returns numeric id', async () => {
    const res = await app.request('/qa/requests/novel/new', {
      method: 'POST',
      body: JSON.stringify({ type: 'epub', slug: 'my-book', urls: ['http://x.com/book.epub'] }),
      headers: { 'Content-Type': 'application/json' },
    });
    expect(res.status).toBe(200);
    const text = await res.text();
    expect(parseInt(text, 10)).toBeGreaterThanOrEqual(0);
  });

  test('returns 409 on duplicate registration', async () => {
    const body = JSON.stringify({ type: 'epub', slug: 'dup', urls: ['http://x.com/dup.epub'] });
    const headers = { 'Content-Type': 'application/json' };
    await app.request('/qa/requests/novel/new', { method: 'POST', body, headers });
    const res = await app.request('/qa/requests/novel/new', { method: 'POST', body, headers });
    expect(res.status).toBe(409);
  });
});