/**
 * Tests handler webhooks Baserow — generique R1 (plus de cascade rollup metier).
 */

import pino from 'pino';
import { describe, expect, it } from 'vitest';
import type { RedisCache } from '../../src/adapters/redis-cache.js';
import { handleBaserowEvent } from '../../src/webhooks/baserow-handler.js';
import type { BaserowWebhookPayload } from '../../src/webhooks/types.js';

class FakeRedis {
  public calls: string[] = [];
  invalidatePattern(pattern: string): Promise<number> {
    this.calls.push(pattern);
    return Promise.resolve(1);
  }
}

const silentLogger = () => pino({ level: 'silent' });

function makePayload(over: Partial<BaserowWebhookPayload> = {}): BaserowWebhookPayload {
  return {
    event_id: 'evt-1',
    event_type: 'rows.created',
    table_id: 42,
    items: [{ id: 100 }],
    ...over,
  } as BaserowWebhookPayload;
}

describe('handleBaserowEvent (R1 generique)', () => {
  it('rows.created sur tableId -> invalide list + views (pas row precis)', async () => {
    const redis = new FakeRedis();
    const res = await handleBaserowEvent(makePayload(), {
      redis: redis as unknown as RedisCache,
      logger: silentLogger(),
    });
    expect(res.status).toBe('processed');
    expect(res.tableId).toBe(42);
    expect(redis.calls).toContain('bridge:tables:42:list:*');
    expect(redis.calls).toContain('bridge:tables:42:views:*');
    expect(redis.calls).not.toContain('bridge:tables:42:row:100');
  });

  it('rows.updated -> invalide list + views + row precis', async () => {
    const redis = new FakeRedis();
    await handleBaserowEvent(
      makePayload({ event_type: 'rows.updated', items: [{ id: 100 }, { id: 101 }] }),
      { redis: redis as unknown as RedisCache, logger: silentLogger() },
    );
    expect(redis.calls).toContain('bridge:tables:42:row:100');
    expect(redis.calls).toContain('bridge:tables:42:row:101');
    expect(redis.calls).toContain('bridge:tables:42:list:*');
    expect(redis.calls).toContain('bridge:tables:42:views:*');
  });

  it('rows.deleted -> invalide list + views + row precis', async () => {
    const redis = new FakeRedis();
    await handleBaserowEvent(
      makePayload({ event_type: 'rows.deleted', table_id: 5, items: [{ id: 200 }] }),
      { redis: redis as unknown as RedisCache, logger: silentLogger() },
    );
    expect(redis.calls).toContain('bridge:tables:5:row:200');
  });

  it('aucune cascade cross-table : tout reste sous bridge:tables:<tableId>:*', async () => {
    const redis = new FakeRedis();
    await handleBaserowEvent(
      makePayload({ event_type: 'rows.updated', table_id: 7, items: [{ id: 1 }] }),
      { redis: redis as unknown as RedisCache, logger: silentLogger() },
    );
    expect(redis.calls.every((p) => p.startsWith('bridge:tables:7:'))).toBe(true);
  });

  it('table_id <= 0 -> ignored, aucune invalidation', async () => {
    const redis = new FakeRedis();
    const res = await handleBaserowEvent(makePayload({ table_id: 0 }), {
      redis: redis as unknown as RedisCache,
      logger: silentLogger(),
    });
    expect(res.status).toBe('ignored');
    expect(res.tableId).toBeNull();
    expect(redis.calls).toHaveLength(0);
  });

  it('rows.created sans items -> invalide list + views, pas de row precis', async () => {
    const redis = new FakeRedis();
    await handleBaserowEvent(makePayload({ event_type: 'rows.created', items: [] }), {
      redis: redis as unknown as RedisCache,
      logger: silentLogger(),
    });
    expect(redis.calls).toContain('bridge:tables:42:list:*');
    expect(redis.calls).toContain('bridge:tables:42:views:*');
    expect(redis.calls.some((p) => p.includes(':row:'))).toBe(false);
  });

  it('renvoie le total des keys invalidees', async () => {
    const redis = new FakeRedis();
    const res = await handleBaserowEvent(
      makePayload({ event_type: 'rows.updated', items: [{ id: 1 }, { id: 2 }] }),
      { redis: redis as unknown as RedisCache, logger: silentLogger() },
    );
    // 4 patterns : list, views, row:1, row:2 → 4 keys.
    expect(res.invalidatedKeys).toBe(4);
  });
});