fotospiel-app/resources/js/guest/services/eventApi.ts

import { getDeviceId } from '../lib/device';

export interface EventData {
  id: number;
  slug: string;
  name: string;
  default_locale: string;
  created_at: string;
  updated_at: string;
  join_token?: string | null;
  type?: {
    slug: string;
    name: string;
    icon: string;
  };
}

export interface PackageData {
  id: number;
  name: string;
  max_photos: number;
}

export interface EventPackage {
  id: number;
  used_photos: number;
  expires_at: string;
  package: PackageData;
}

export interface EventStats {
  onlineGuests: number;
  tasksSolved: number;
  latestPhotoAt: string | null;
}

export type FetchEventErrorCode =
  | 'invalid_token'
  | 'token_expired'
  | 'token_revoked'
  | 'token_rate_limited'
  | 'event_not_public'
  | 'network_error'
  | 'server_error'
  | 'unknown';

interface FetchEventErrorOptions {
  code: FetchEventErrorCode;
  message: string;
  status?: number;
}

export class FetchEventError extends Error {
  readonly code: FetchEventErrorCode;
  readonly status?: number;

  constructor({ code, message, status }: FetchEventErrorOptions) {
    super(message);
    this.name = 'FetchEventError';
    this.code = code;
    this.status = status;
  }
}

const API_ERROR_CODES: FetchEventErrorCode[] = [
  'invalid_token',
  'token_expired',
  'token_revoked',
  'token_rate_limited',
  'event_not_public',
];

function resolveErrorCode(rawCode: unknown, status: number): FetchEventErrorCode {
  if (typeof rawCode === 'string') {
    const normalized = rawCode.toLowerCase() as FetchEventErrorCode;
    if ((API_ERROR_CODES as string[]).includes(normalized)) {
      return normalized;
    }
  }

  if (status === 429) return 'token_rate_limited';
  if (status === 404) return 'event_not_public';
  if (status === 410) return 'token_expired';
  if (status === 401) return 'invalid_token';
  if (status === 403) return 'token_revoked';
  if (status >= 500) return 'server_error';

  return 'unknown';
}

function defaultMessageForCode(code: FetchEventErrorCode): string {
  switch (code) {
    case 'invalid_token':
      return 'Der eingegebene Zugriffscode ist ungültig.';
    case 'token_revoked':
      return 'Dieser Zugriffscode wurde deaktiviert. Bitte fordere einen neuen Code an.';
    case 'token_expired':
      return 'Dieser Zugriffscode ist abgelaufen.';
    case 'token_rate_limited':
      return 'Zu viele Versuche in kurzer Zeit. Bitte warte einen Moment und versuche es erneut.';
    case 'event_not_public':
      return 'Dieses Event ist nicht öffentlich verfügbar.';
    case 'network_error':
      return 'Keine Verbindung zum Server. Prüfe deine Internetverbindung und versuche es erneut.';
    case 'server_error':
      return 'Der Server ist gerade nicht erreichbar. Bitte versuche es später erneut.';
    case 'unknown':
    default:
      return 'Event konnte nicht geladen werden.';
  }
}

export async function fetchEvent(eventKey: string): Promise<EventData> {
  try {
    const res = await fetch(`/api/v1/events/${encodeURIComponent(eventKey)}`);
    if (!res.ok) {
      let apiMessage: string | null = null;
      let rawCode: unknown;

      try {
        const data = await res.json();
        rawCode = data?.error?.code ?? data?.code;
        const message = data?.error?.message ?? data?.message;
        if (typeof message === 'string' && message.trim() !== '') {
          apiMessage = message.trim();
        }
      } catch {
        // ignore parse errors and fall back to defaults
      }

      const code = resolveErrorCode(rawCode, res.status);
      const message = apiMessage ?? defaultMessageForCode(code);

      throw new FetchEventError({
        code,
        message,
        status: res.status,
      });
    }

    return await res.json();
  } catch (error) {
    if (error instanceof FetchEventError) {
      throw error;
    }

    if (error instanceof TypeError) {
      throw new FetchEventError({
        code: 'network_error',
        message: defaultMessageForCode('network_error'),
        status: 0,
      });
    }

    if (error instanceof Error) {
      throw new FetchEventError({
        code: 'unknown',
        message: error.message || defaultMessageForCode('unknown'),
        status: 0,
      });
    }

    throw new FetchEventError({
      code: 'unknown',
      message: defaultMessageForCode('unknown'),
      status: 0,
    });
  }
}

export async function fetchStats(eventKey: string): Promise<EventStats> {
  const res = await fetch(`/api/v1/events/${encodeURIComponent(eventKey)}/stats`, {
    headers: {
      'X-Device-Id': getDeviceId(),
    },
  });
  if (!res.ok) throw new Error('Stats fetch failed');
  const json = await res.json();
  return {
    onlineGuests: json.online_guests ?? json.onlineGuests ?? 0,
    tasksSolved: json.tasks_solved ?? json.tasksSolved ?? 0,
    latestPhotoAt: json.latest_photo_at ?? json.latestPhotoAt ?? null,
  };
}

export async function getEventPackage(eventToken: string): Promise<EventPackage | null> {
  const res = await fetch(`/api/v1/events/${encodeURIComponent(eventToken)}/package`);
  if (!res.ok) {
    if (res.status === 404) return null;
    throw new Error('Failed to load event package');
  }
  return await res.json();
}