import { isRecord } from './guards';
import { parseTimelineEvent } from './types';
import type { TimelineEvent } from './types';

export type SearchScope = { kind: 'room'; room_id: string } | { kind: 'rooms'; room_ids: string[] } | { kind: 'all' };

export interface ScopeOption {
  label: string;
  scope: SearchScope;
}

export interface SearchHit {
  room_id: string;
  event_id: string;
  timestamp_ms: number;
  event: TimelineEvent;
  ranges: [number, number][];
}

export type SearchBackfill = 'Waiting' | 'Running' | 'Paused' | 'Complete' | 'Disabled' | { Failed: string };

export interface RoomSearchCoverage {
  room_id: string;
  oldest_indexed_ms: number | null;
  start_reached: boolean;
  backfill: SearchBackfill;
}

export interface SearchCoverage {
  rooms: RoomSearchCoverage[];
  persistent: boolean;
  undecrypted: number;
}

export interface SearchPage {
  hits: SearchHit[];
  next: string | null;
  coverage: SearchCoverage;
}

export interface SearchSession {
  search_id: string;
  page: SearchPage;
}

/** The wire form of a scope, as macltok's externally tagged enum. */
export function scopeWire(scope: SearchScope): unknown {
  if (scope.kind === 'room') return { Room: scope.room_id };
  if (scope.kind === 'rooms') return { Rooms: scope.room_ids };
  return 'All';
}

/** macltok's matches are utf-8 byte ranges, so they're mapped back to string offsets against the body. */
function parseRanges(raw: unknown, body: string): [number, number][] {
  if (!Array.isArray(raw)) return [];
  const bytes = new TextEncoder().encode(body);
  const decoder = new TextDecoder();
  const offset = (byte: number) => decoder.decode(bytes.subarray(0, byte)).length;
  return raw.flatMap((range) =>
    isRecord(range) && typeof range['start'] === 'number' && typeof range['end'] === 'number'
      ? [[offset(range['start']), offset(range['end'])] as [number, number]]
      : []
  );
}

function hitBody(event: TimelineEvent): string {
  const content = event.content;
  if (content.kind === 'Message') return content.message.body;
  return '';
}

function parseHit(raw: unknown): SearchHit | null {
  if (!isRecord(raw) || typeof raw['room_id'] !== 'string' || typeof raw['event_id'] !== 'string' || !isRecord(raw['event'])) return null;
  const event = parseTimelineEvent(raw['event']);
  return {
    room_id: raw['room_id'],
    event_id: raw['event_id'],
    timestamp_ms: typeof raw['timestamp_ms'] === 'number' ? raw['timestamp_ms'] : event.timestamp_ms,
    event,
    ranges: parseRanges(raw['matches'], hitBody(event))
  };
}

function parseBackfill(raw: unknown): SearchBackfill {
  if (raw === 'Waiting' || raw === 'Running' || raw === 'Paused' || raw === 'Complete' || raw === 'Disabled') return raw;
  if (isRecord(raw) && isRecord(raw['Failed']) && typeof raw['Failed']['message'] === 'string') return { Failed: raw['Failed']['message'] };
  return 'Waiting';
}

function parseRoomCoverage(raw: unknown): RoomSearchCoverage | null {
  if (!isRecord(raw) || typeof raw['room_id'] !== 'string') return null;
  return {
    room_id: raw['room_id'],
    oldest_indexed_ms: typeof raw['oldest_indexed_ms'] === 'number' ? raw['oldest_indexed_ms'] : null,
    start_reached: raw['start_reached'] === true,
    backfill: parseBackfill(raw['backfill'])
  };
}

function parseCoverage(raw: unknown): SearchCoverage {
  if (!isRecord(raw)) return { rooms: [], persistent: false, undecrypted: 0 };
  return {
    rooms: Array.isArray(raw['rooms']) ? raw['rooms'].flatMap((room) => parseRoomCoverage(room) ?? []) : [],
    persistent: raw['persistent'] === true,
    undecrypted: typeof raw['undecrypted'] === 'number' ? raw['undecrypted'] : 0
  };
}

export function parseSearchPage(raw: unknown): SearchPage | null {
  if (!isRecord(raw) || !Array.isArray(raw['hits'])) return null;
  return {
    hits: raw['hits'].flatMap((hit) => parseHit(hit) ?? []),
    next: typeof raw['next_cursor'] === 'string' ? raw['next_cursor'] : null,
    coverage: parseCoverage(raw['coverage'])
  };
}

export function parseSearchSession(raw: unknown): SearchSession | null {
  if (!isRecord(raw) || typeof raw['search_id'] !== 'string') return null;
  const page = parseSearchPage(raw['page']);
  return page ? { search_id: raw['search_id'], page } : null;
}

/** Hits grouped by room, keeping the order in which each room first appears. */
export function groupByRoom(hits: SearchHit[]): { room_id: string; hits: SearchHit[] }[] {
  const groups = new Map<string, SearchHit[]>();
  for (const hit of hits) {
    const list = groups.get(hit.room_id);
    if (list) list.push(hit);
    else groups.set(hit.room_id, [hit]);
  }
  return [...groups].map(([room_id, list]) => ({ room_id, hits: list }));
}