Интеграция плеера FUNILM

<!-- Адаптивный плеер FUNILM 16:9 -->
<div style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; border-radius: 8px; background: #000;">
  <iframe 
    src="https://funilm.top/embed/kp/301?token=ВАШ_ТОКЕН" 
    style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: 0;" 
    allow="autoplay; fullscreen; encrypted-media; picture-in-picture" 
    allowfullscreen>
  </iframe>
</div>

<!-- Вставьте блок "Произвольный HTML" в редакторе записи -->
<div class="funilm-player-responsive" style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; border-radius: 8px;">
  <iframe 
    src="https://funilm.top/embed/kp/<?php echo get_post_meta($post->ID, 'kinopoisk_id', true); ?>?token=ВАШ_ТОКЕН" 
    style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: 0;" 
    allow="autoplay; fullscreen; encrypted-media; picture-in-picture" 
    allowfullscreen>
  </iframe>
</div>

<!-- Добавьте в шаблон fullstory.tpl, используя доп. поле [xfvalue_kp_id] -->
[xfgiven_kp_id]
<div style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; border-radius: 8px;">
  <iframe 
    src="https://funilm.top/embed/kp/[xfvalue_kp_id]?token=ВАШ_ТОКЕН" 
    style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: 0;" 
    allow="autoplay; fullscreen; encrypted-media; picture-in-picture" 
    allowfullscreen>
  </iframe>
</div>
[/xfgiven_kp_id]

export function FunilmPlayer({ kpId, token }: { kpId: number; token: string }) {
  return (
    <div style={{ position: 'relative', paddingBottom: '56.25%', height: 0, overflow: 'hidden', borderRadius: 8 }}>
      <iframe
        src={`https://funilm.top/embed/kp/${kpId}?token=${token}`}
        style={{ position: 'absolute', top: 0, left: 0, width: '100%', height: '100%', border: 0 }}
        allow="autoplay; fullscreen; encrypted-media; picture-in-picture"
        allowFullScreen
      />
    </div>
  );
}

/**
 * FUNILM Player Client SDK (ES6+)
 * Паттерны: Observer / EventEmitter, Fluent Interface, DRY.
 */
class FunilmPlayer {
  /**
   * @param {string|HTMLIFrameElement} target Селектор или DOM-элемент iframe
   * @param {Object} [options={}]
   * @param {string} [options.origin='*'] Допустимый Origin сообщений
   */
  constructor(target, options = {}) {
    this.iframe = typeof target === 'string' ? document.querySelector(target) : target;
    if (!this.iframe) {
      throw new Error(`[FunilmPlayer] Iframe элемент '${target}' не найден.`);
    }
    this.options = { origin: '*', ...options };
    this._listeners = new Map();
    this._onMessage = this._handleMessage.bind(this);

    window.addEventListener('message', this._onMessage);
  }

  /**
   * Подписка на событие ('player:ready', 'player:play', 'player:timeupdate', etc.)
   */
  on(event, handler) {
    if (!this._listeners.has(event)) {
      this._listeners.set(event, new Set());
    }
    this._listeners.get(event).add(handler);
    return this; // Fluent chaining
  }

  /**
   * Одноразовая подписка
   */
  once(event, handler) {
    const wrapper = (data) => {
      this.off(event, wrapper);
      handler(data);
    };
    return this.on(event, wrapper);
  }

  /**
   * Отписка от события
   */
  off(event, handler) {
    if (this._listeners.has(event)) {
      this._listeners.get(event).delete(handler);
    }
    return this;
  }

  /**
   * Отправка команды в iframe плеера
   */
  send(action, payload = {}) {
    if (!this.iframe.contentWindow) {
      console.warn('[FunilmPlayer] contentWindow недоступен.');
      return this;
    }
    this.iframe.contentWindow.postMessage({ action, ...payload }, this.options.origin);
    return this;
  }

  // === Fluent API управления плеером ===
  play() { return this.send('play'); }
  pause() { return this.send('pause'); }
  togglePlay() { return this.send('togglePlay'); }
  seek(seconds) { return this.send('seek', { time: Math.max(0, Number(seconds) || 0) }); }
  setEpisode(season, episode) { return this.send('setEpisode', { season: Number(season), episode: Number(episode) }); }
  setVolume(value) { return this.send('setVolume', { value: Math.max(0, Math.min(1, Number(value))) }); }
  mute() { return this.send('mute'); }
  unmute() { return this.send('unmute'); }
  toggleFullscreen() { return this.send('toggleFullscreen'); }

  /**
   * Очистка памяти и удаление глобального слушателя событий
   */
  destroy() {
    window.removeEventListener('message', this._onMessage);
    this._listeners.clear();
  }

  /** @private */
  _handleMessage(e) {
    if (this.options.origin !== '*' && e.origin !== this.options.origin) return;
    if (e.data?.source !== 'funilm-player') return;
    if (e.source !== this.iframe.contentWindow) return;

    const { event, data } = e.data;
    const handlers = this._listeners.get(event);
    if (handlers) {
      handlers.forEach(fn => {
        try { fn(data); } catch (err) { console.error(`[FunilmPlayer] Error in '${event}':`, err); }
      });
    }

    const wildcard = this._listeners.get('*');
    if (wildcard) {
      wildcard.forEach(fn => {
        try { fn({ event, data }); } catch (err) { console.error('[FunilmPlayer] Wildcard error:', err); }
      });
    }
  }
}

// --- Пример использования ---
const player = new FunilmPlayer('#my-player-frame');

// Подписка на аналитику
player
  .on('player:ready', () => console.log('✓ Плеер готов к воспроизведению'))
  .on('player:play', ({ currentTime }) => console.log('Старт воспроизведения на', currentTime))
  .on('player:timeupdate', ({ currentTime, duration }) => {
    // Трекинг прогресса просмотра (Яндекс.Метрика / GA4)
  })
  .on('player:ended', () => {
    ym(XXXXXX, 'reachGoal', 'film_finished');
  });

// Управление кнопками интерфейса
document.getElementById('play-btn')?.addEventListener('click', () => player.play());
document.getElementById('pause-btn')?.addEventListener('click', () => player.pause());
document.getElementById('forward-btn')?.addEventListener('click', () => player.seek(180));

/**
 * FUNILM Player TypeScript SDK
 * Строгая типизация контрактов взаимодействия postMessage
 */

export interface PlayerTimeData {
  currentTime: number;
  duration: number;
}

export interface PlayerEpisodeData {
  season: number;
  episode: number;
}

export interface PlayerFullscreenData {
  fullscreen: boolean;
}

export interface PlayerEventMap {
  'player:ready': void;
  'player:play': PlayerTimeData;
  'player:pause': PlayerTimeData;
  'player:timeupdate': PlayerTimeData;
  'player:ended': { duration: number };
  'player:episode_change': PlayerEpisodeData;
  'player:fullscreen': PlayerFullscreenData;
  '*': { event: string; data: unknown };
}

export interface FunilmPlayerOptions {
  origin?: string;
}

export type EventCallback<T> = (data: T) => void;

export class FunilmPlayer {
  private readonly iframe: HTMLIFrameElement;
  private readonly origin: string;
  private readonly listeners = new Map<keyof PlayerEventMap, Set<EventCallback<any>>>();
  private readonly boundHandler: (e: MessageEvent) => void;

  constructor(target: string | HTMLIFrameElement, options: FunilmPlayerOptions = {}) {
    const el = typeof target === 'string' ? document.querySelector<HTMLIFrameElement>(target) : target;
    if (!el) throw new Error(`[FunilmPlayer] Iframe '${target}' not found`);
    this.iframe = el;
    this.origin = options.origin ?? '*';
    this.boundHandler = this.handleMessage.bind(this);
    window.addEventListener('message', this.boundHandler);
  }

  public on<K extends keyof PlayerEventMap>(event: K, handler: EventCallback<PlayerEventMap[K]>): this {
    if (!this.listeners.has(event)) this.listeners.set(event, new Set());
    this.listeners.get(event)!.add(handler);
    return this;
  }

  public off<K extends keyof PlayerEventMap>(event: K, handler: EventCallback<PlayerEventMap[K]>): this {
    this.listeners.get(event)?.delete(handler);
    return this;
  }

  public play(): this { return this.send('play'); }
  public pause(): this { return this.send('pause'); }
  public togglePlay(): this { return this.send('togglePlay'); }
  public seek(seconds: number): this { return this.send('seek', { time: seconds }); }
  public setEpisode(season: number, episode: number): this { return this.send('setEpisode', { season, episode }); }
  public setVolume(value: number): this { return this.send('setVolume', { value }); }
  public mute(): this { return this.send('mute'); }
  public unmute(): this { return this.send('unmute'); }
  public toggleFullscreen(): this { return this.send('toggleFullscreen'); }

  public destroy(): void {
    window.removeEventListener('message', this.boundHandler);
    this.listeners.clear();
  }

  private send(action: string, payload: Record = {}): this {
    this.iframe.contentWindow?.postMessage({ action, ...payload }, this.origin);
    return this;
  }

  private handleMessage(e: MessageEvent): void {
    if (this.origin !== '*' && e.origin !== this.origin) return;
    if (e.data?.source !== 'funilm-player' || e.source !== this.iframe.contentWindow) return;

    const { event, data } = e.data;
    this.listeners.get(event as keyof PlayerEventMap)?.forEach(fn => fn(data));
    this.listeners.get('*')?.forEach(fn => fn({ event, data }));
  }
}

from __future__ import annotations
from dataclasses import dataclass, field
from typing import Optional, Dict, Any
from urllib.parse import urlencode
import html


@dataclass(frozen=True)
class PlayerConfig:
    """Конфигурация воспроизведения и UI плеера."""
    autoplay: bool = False
    season: Optional[int] = None
    episode: Optional[int] = None
    skin: str = "default"
    custom_params: Dict[str, Any] = field(default_factory=dict)


class FunilmEmbedBuilder:
    """
    Фабрика плееров FUNILM.
    Принцип DRY: единая точка сборки URL и HTML-разметки.
    """
    def __init__(self, token: str, base_url: str = "https://funilm.top/embed"):
        if not token:
            raise ValueError("API-токен вебмастера обязателен.")
        self.token = token.strip()
        self.base_url = base_url.rstrip("/")

    def movie(self, kinopoisk_id: Optional[int] = None, tmdb_id: Optional[int] = None, **kwargs) -> FunilmPlayerEmbed:
        return FunilmPlayerEmbed(
            token=self.token,
            base_url=self.base_url,
            kinopoisk_id=kinopoisk_id,
            tmdb_id=tmdb_id,
            config=PlayerConfig(**kwargs)
        )

    def series(self, kinopoisk_id: Optional[int] = None, season: int = 1, episode: int = 1, **kwargs) -> FunilmPlayerEmbed:
        return FunilmPlayerEmbed(
            token=self.token,
            base_url=self.base_url,
            kinopoisk_id=kinopoisk_id,
            config=PlayerConfig(season=season, episode=episode, **kwargs)
        )


class FunilmPlayerEmbed:
    """Сущность конкретного плеера с методами генерации URL и HTML."""
    def __init__(self, token: str, base_url: str,
                 kinopoisk_id: Optional[int] = None, tmdb_id: Optional[int] = None,
                 config: Optional[PlayerConfig] = None):
        if not kinopoisk_id and not tmdb_id:
            raise ValueError("Необходимо указать kinopoisk_id или tmdb_id.")
        self.token = token
        self.base_url = base_url
        self.kinopoisk_id = kinopoisk_id
        self.tmdb_id = tmdb_id
        self.config = config or PlayerConfig()

    def get_url(self) -> str:
        """Собирает канонический URL плеера с query-параметрами."""
        path = f"/kp/{self.kinopoisk_id}" if self.kinopoisk_id else f"/tmdb/{self.tmdb_id}"
        query: Dict[str, Any] = {"token": self.token}

        if self.config.season is not None:
            query["s"] = self.config.season
        if self.config.episode is not None:
            query["e"] = self.config.episode
        if self.config.autoplay:
            query["autoplay"] = 1
        if self.config.skin != "default":
            query["skin"] = self.config.skin
        if self.config.custom_params:
            query.update(self.config.custom_params)

        return f"{self.base_url}{path}?{urlencode(query)}"

    def render_html(self, iframe_id: str = "funilm-player", wrapper_class: str = "") -> str:
        """Генерирует адаптивный 16:9 контейнер с безопасным экранированием."""
        url = html.escape(self.get_url())
        css_class = f"funilm-player-wrapper {wrapper_class}".strip()
        return (
            f'<div class="{css_class}" style="position:relative;padding-bottom:56.25%;height:0;overflow:hidden;border-radius:8px;background:#000;">\n'
            f'  <iframe id="{iframe_id}" src="{url}" '
            f'style="position:absolute;top:0;left:0;width:100%;height:100%;border:0;" '
            f'allow="autoplay; fullscreen; encrypted-media; picture-in-picture" allowfullscreen></iframe>\n'
            f'</div>'
        )

# === Пример использования в FastAPI / Django / Flask ===
# sdk = FunilmEmbedBuilder(token="ВАШ_ТОКЕН")
# player = sdk.movie(kinopoisk_id=301, autoplay=True)
# player_url = player.get_url()
# player_html = player.render_html(iframe_id="main-movie")

<?php
declare(strict_types=1);

namespace Funilm\Sdk;

/**
 * FUNILM Player PHP SDK (PHP 8.1+)
 * Архитектура: Fluent Builder, Value Object, Clean Architecture.
 * Полная совместимость с WordPress, DataLife Engine и Laravel / Symfony.
 */
final class FunilmPlayer
{
    private const BASE_URL = 'https://funilm.top/embed';

    private function __construct(
        private readonly string $token,
        private readonly ?int $kinopoiskId = null,
        private readonly ?int $tmdbId = null,
        private int $season = 1,
        private int $episode = 1,
        private bool $autoplay = false,
        private string $skin = 'default'
    ) {
        if ($this->kinopoiskId === null && $this->tmdbId === null) {
            throw new \InvalidArgumentException('Необходимо указать kinopoiskId либо tmdbId.');
        }
    }

    /** Фабрика для фильмов */
    public static function movie(string $token, int $kinopoiskId): self
    {
        return new self(token: $token, kinopoiskId: $kinopoiskId);
    }

    /** Фабрика для сериалов */
    public static function series(string $token, int $kinopoiskId, int $season = 1, int $episode = 1): self
    {
        return new self(token: $token, kinopoiskId: $kinopoiskId, season: $season, episode: $episode);
    }

    /** Установка серии для чейнинга */
    public function withEpisode(int $season, int $episode): self
    {
        $clone = clone $this;
        $clone->season = $season;
        $clone->episode = $episode;
        return $clone;
    }

    /** Включение автостарта */
    public function withAutoplay(bool $autoplay = true): self
    {
        $clone = clone $this;
        $clone->autoplay = $autoplay;
        return $clone;
    }

    /** Генерация канонического URL */
    public function getUrl(): string
    {
        $path = $this->kinopoiskId ? "/kp/{$this->kinopoiskId}" : "/tmdb/{$this->tmdbId}";
        $params = ['token' => $this->token];

        if ($this->season > 1 || $this->episode > 1) {
            $params['s'] = $this->season;
            $params['e'] = $this->episode;
        }
        if ($this->autoplay) {
            $params['autoplay'] = 1;
        }
        if ($this->skin !== 'default') {
            $params['skin'] = $this->skin;
        }

        return self::BASE_URL . $path . '?' . http_build_query($params);
    }

    /**
     * Рендеринг адаптивного HTML5 iframe 16:9
     */
    public function render(string $elementId = 'funilm-frame', string $extraClass = ''): string
    {
        $safeUrl = htmlspecialchars($this->getUrl(), ENT_QUOTES, 'UTF-8');
        $safeId = htmlspecialchars($elementId, ENT_QUOTES, 'UTF-8');
        $classes = trim('funilm-embed-box ' . $extraClass);

        return <<<HTML
        <div class="{$classes}" style="position:relative;padding-bottom:56.25%;height:0;overflow:hidden;border-radius:8px;background:#000;">
            <iframe id="{$safeId}" src="{$safeUrl}" style="position:absolute;top:0;left:0;width:100%;height:100%;border:0;" allow="autoplay; fullscreen; encrypted-media; picture-in-picture" allowfullscreen></iframe>
        </div>
        HTML;
    }
}

// === Пример использования в WordPress (single.php) или DLE ===
// $kpId = (int) get_post_meta(get_the_ID(), 'kinopoisk_id', true);
// echo \Funilm\Sdk\FunilmPlayer::movie('ВАШ_ТОКЕН', $kpId)
//     ->withAutoplay(false)
//     ->render('wp-player');