import type {
  IPlayer,
  WithCurrentItem,
  BasePlayerConfig,
  BaseEventMap,
  BasePlaylistItem,
  AuthConfig,
  CastConfig,
  DrmConfig,
  ActionOptions,
  LoadOptions,
  BeforeEvent,
} from '@nomercy-entertainment/nomercy-player-core';

interface IPlayer<E extends BaseEventMap = BaseEventMap> extends DispatchTarget {
  // Identity
  readonly playerId: string;
  readonly id: string; // alias for playerId
  readonly container: HTMLElement;

  // Event system
  on<K extends keyof E>(event: K, fn: (data: E[K]) => void): void;
  off<K extends keyof E>(event: K, fn: (data: E[K]) => void): void;
  once<K extends keyof E>(event: K, fn: (data: E[K]) => void): void;
  emit<K extends keyof E>(event: K, data?: E[K]): void;
  hasListeners<K extends keyof E>(event: K): boolean;

  // Runtime URL
  baseUrl(): string | undefined;
  baseUrl(url: string): void;

  // Audio context
  audioContext(): AudioContext | undefined;

  // URL resolution
  resolveUrl(url: string, category?: UrlCategory): Promise<ResolvedUrl>;
  urlResolver(): IUrlResolver | undefined;
  urlResolver(resolver: IUrlResolver | undefined): void;

  // Phase + dispatch
  phase(): PlayerPhase;
  dispatching(): ReadonlyArray<string>;

  // Experimental override surface
  readonly experimental: PlayerExperimental;

  // i18n
  t(key: string, vars?: Record<string, string>): string;
  language(): string;
  language(lang: string): Promise<void>;
  addTranslations(bundle: Translations): void;
  translation(lang: string, key: string): string | undefined;
  translation(lang: string, key: string, value: string): void;
  removeTranslations(prefix: string, lang?: string): void;

  // Cue parsers
  registerCueParser(parser: ICueParser, prepend?: boolean): void;
  unregisterCueParser(id: string): void;
  resolveCueParser(url: string): ICueParser | undefined;

  // Auth
  auth(): Readonly<AuthConfig> | undefined;
  auth(config: AuthConfig): void;
  auth(partial: Partial<AuthConfig>): void;

  // Metrics
  metrics(): PlaybackMetrics;

  // Tracks (playback)
  subtitle(): CurrentSubtitleSelection | null;
  subtitle(idx: number | null): void;
  audioTrack(): CurrentAudioTrackSelection | null;
  audioTrack(idx: number): void;
  quality(): CurrentQualitySelection | 'auto';
  quality(idx: number | 'auto'): void;
  chapters(): ReadonlyArray<Chapter>;
  chapter(): Chapter | null;
}

declare readonly __eventMap__: E;

interface WithCurrentItem<T extends BasePlaylistItem = BasePlaylistItem> {
  item(): T | undefined;
}

import { Plugin } from '@nomercy-entertainment/nomercy-player-core';
import type {
  IPlayer,
  WithCurrentItem,
  BaseEventMap,
  BasePlaylistItem,
} from '@nomercy-entertainment/nomercy-player-core';

class MyPlugin<
  P extends IPlayer<BaseEventMap> & WithCurrentItem<BasePlaylistItem>,
  I extends BasePlaylistItem = BasePlaylistItem,
> extends Plugin<P, BaseEventMap, I> {
  onEnded(): void {
    const item = this.player.item();        // BasePlaylistItem — typed via I
    const snapshot = this.player.metrics();    // PlaybackMetrics — no constraint needed
  }
}

interface BasePlayerConfig {
  // Auth
  auth?: AuthConfig;

  // Logging
  logger?: ILogger;
  logLevel?: LogLevel;

  // Storage
  storage?: IStorage;

  // Platform adapter
  platform?: IPlatform;

  // Realtime / WebSocket factory
  websocketFactory?: RealtimeFactory;

  // Translator adapter (server-side i18n)
  translator?: ITranslator;

  // URL resolver
  urlResolver?: IUrlResolver;

  // Base URL for relative media URLs
  baseUrl?: string;

  // Before-event timeout (ms). Default 10 000.
  beforeEventTimeoutMs?: number;

  // Plugin init timeout (ms). Default 30 000.
  pluginInitTimeoutMs?: number;

  // Cast
  cast?: CastConfig;

  // Playlist / initial load
  playlist?: BasePlaylistItem[] | string;

  // Custom cue parsers
  cueParsers?: ICueParser[];

  // Mutation guards
  mutationGuards?: false | 'all' | ReadonlyArray<string>;

  // Preload / transition strategies
  preloadStrategy?: IPreloadStrategy;
  transitionStrategy?: ITransitionStrategy;

  // i18n
  language?: string;
  translations?: Translations;
  loadTranslations?: TranslationLoader;
  onMissingTranslation?: (key: string, lang: string) => string;

  // Initial volume (0–100 scale)
  defaultVolume?: number;
}

interface AuthConfig {
  bearerToken?: string | (() => string) | (() => Promise<string>);
  headers?: Record<string, string | (() => string) | (() => Promise<string>)>;
  credentials?: 'omit' | 'same-origin' | 'include';
  transformUrl?: (url: string) => string | Promise<string>;
  signRequest?: (request: Request) => Request | Promise<Request>;
  refreshOnUnauthenticated?: () => Promise<void>;
  retryAfterRefresh?: number; // default 1
}

auth: {
  bearerToken: () => myStore.token,
  refreshOnUnauthenticated: async () => {
    await myStore.refresh();
  },
}

interface CastConfig {
  autoLoad?: boolean; // default false; auto-injects Cast SDK on first transferTo
  receiverApplicationId?: string; // default: standard Google media receiver
  // plus autoJoinPolicy, resumeSavedSession, scriptUrl, loadTimeoutMs
  // — see the Cast page for the full interface and defaults
}

interface DrmConfig {
  keySystem: string; // e.g. 'com.widevine.alpha', 'com.apple.fps'
  licenseUrl: string;
  certificate?: ArrayBuffer | string;
  customSignRequest?: (request: Request) => Request | Promise<Request>;
}

interface BeforeEvent<TData> {
  data: TData;
  preventDefault(): void;
  isDefaultPrevented(): boolean;
  stopImmediatePropagation(): void;
  isPropagationStopped(): boolean;
  delay(promise: Promise<unknown>): void;
  isDelayed(): boolean;
}

interface BasePlaylistItem {
  id: number | string;
  title?: string;
  image?: string;
}

interface ActionOptions {
  source?: ActionSource; // 'user' | 'remote' | 'plugin' | string; default 'user'
  silent?: boolean; // skip lifecycle events and before* guards
  autoplay?: boolean; // call play() immediately after load resolves
}

interface LoadOptions extends ActionOptions {
  slot?: 'current' | 'next'; // default 'current'
  startAt?: number; // start position (seconds)
  fadeIn?: number; // fade-in duration (seconds); 0 = immediate
}