import Hls from 'hls.js';
import Artplayer from 'artplayer';
import artplayerPluginDanmuku from 'artplayer-plugin-danmuku';

/**
 * 视频播放器基类
 */
export abstract class BaseVideoPlayer {
    protected _hasPlayed: boolean = false;
    private _isUpdatingPlayCount: boolean = false;

    /**
     * 处理 m3u8 视频播放
     */
    protected playM3u8(video: HTMLVideoElement, url: string, art: Artplayer): void {
        // 初始化阶段不预加载视频内容，降低未点击播放时的 CDN 流量消耗。
        video.preload = 'none';

        // 懒加载场景下，尚未触发播放时主动隐藏 loading，避免一直展示等待状态。
        const loadingHideTimer = window.setTimeout(() => {
            art.loading.show = false;
        }, 100);

        let sourceLoaded = false;
        let pendingUserPlay = false;
        let playRequestPending = false;

        const requestPlayback = (): void => {
            if (!pendingUserPlay || playRequestPending) {
                return;
            }

            playRequestPending = true;
            void video
                .play()
                .then(() => {
                    pendingUserPlay = false;
                })
                .catch(() => {
                    // 源还没准备好或被浏览器策略拦截时，等待后续就绪事件再重试。
                })
                .finally(() => {
                    playRequestPending = false;
                });
        };

        const retryPendingPlayback = (): void => {
            if (!pendingUserPlay) {
                return;
            }

            requestPlayback();
        };

        const clearPendingPlayback = (): void => {
            pendingUserPlay = false;
        };

        video.addEventListener('play', clearPendingPlayback);

        const loadSource = (): void => {
            if (sourceLoaded) {
                return;
            }

            sourceLoaded = true;

            if (Hls.isSupported()) {
                // 销毁旧的 hls 实例
                if (art.hls) {
                    (art.hls as Hls)?.destroy();
                }
                const hls = new Hls();
                hls.on(Hls.Events.MANIFEST_PARSED, retryPendingPlayback);
                hls.loadSource(url);
                hls.attachMedia(video);
                art.hls = hls;
                art.on('destroy', () => hls.destroy());
                return;
            }

            if (video.canPlayType('application/vnd.apple.mpegurl')) {
                // Safari 原生支持
                video.addEventListener('loadedmetadata', retryPendingPlayback, { once: true });
                video.addEventListener('canplay', retryPendingPlayback, { once: true });
                video.src = url;
                video.load();
                return;
            }

            art.notice.show = '不支持播放该视频';
        };

        const triggerLoadAndPlay = (): void => {
            pendingUserPlay = true;
            loadSource();
            requestPlayback();
            removeLazyLoadTriggers();
        };

        const onPointerDown = (): void => {
            triggerLoadAndPlay();
        };

        const onKeyDown = (event: KeyboardEvent): void => {
            if (event.key !== 'Enter' && event.key !== ' ') {
                return;
            }
            triggerLoadAndPlay();
        };

        const playerElement = art.template.$player;

        const removeLazyLoadTriggers = (): void => {
            playerElement.removeEventListener('pointerdown', onPointerDown, true);
            playerElement.removeEventListener('keydown', onKeyDown, true);
        };

        // 在首次用户交互时才真正挂载媒体源并开始播放。
        playerElement.addEventListener('pointerdown', onPointerDown, true);
        playerElement.addEventListener('keydown', onKeyDown, true);

        art.on('destroy', () => {
            window.clearTimeout(loadingHideTimer);
            video.removeEventListener('play', clearPendingPlayback);
            removeLazyLoadTriggers();
        });
    }

    /**
     * 创建弹幕插件配置
     * @param videoId 视频 ID
     * @param onDanmakuSent 弹幕发送成功后的回调（可选）
     */
    protected createDanmakuPlugin(
        videoId: string,
        onDanmakuSent?: () => void
    ): ReturnType<typeof artplayerPluginDanmuku> {
        return artplayerPluginDanmuku({
            danmuku: async () => {
                try {
                    const response = await fetch(`/history/danmaku/v2/${videoId}`);
                    return await response.json();
                } catch (e) {
                    console.error('Failed to load danmaku', e);
                    return [];
                }
            },
            async beforeEmit(danmaku) {
                if (!danmaku.text || danmaku.text.trim() === '') {
                    return false;
                }

                (danmaku as unknown as Record<string, string>)['id'] = videoId;
                try {
                    await fetch(`/send/danmaku/v2`, {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json;charset=utf-8',
                        },
                        body: JSON.stringify(danmaku),
                    });

                    // 执行回调（如更新弹幕计数）
                    onDanmakuSent?.();
                    return true;
                } catch (e) {
                    console.error('Failed to send danmaku', e);
                    return false;
                }
            },
        });
    }

    /**
     * 处理首次播放事件（更新播放计数）
     * @param videoId 视频 ID
     * @param onFirstPlay 首次播放计数更新成功后的回调（可选）
     * @returns 播放事件处理器
     */
    protected createFirstPlayHandler(
        videoId: string,
        onFirstPlay?: () => void
    ): () => Promise<void> {
        return async () => {
            if (this._hasPlayed || this._isUpdatingPlayCount) {
                return;
            }

            this._isUpdatingPlayCount = true;
            try {
                const response = await fetch(`/play/${videoId}`, { method: 'PATCH' });
                if (!response.ok) {
                    throw new Error(`Play count update failed with status ${response.status}`);
                }

                this._hasPlayed = true;
                onFirstPlay?.();
            } catch (e) {
                console.error('Failed to update play count', e);
            } finally {
                this._isUpdatingPlayCount = false;
            }
        };
    }

    /**
     * 获取通用的 Artplayer 配置选项（可被子类覆盖或扩展）
     */
    protected getCommonArtplayerOptions(): Partial<Artplayer['option']> {
        return {
            type: 'm3u8',
            customType: {
                m3u8: this.playM3u8.bind(this),
            },
            // 避免浏览器在未点击播放时提前下载
            moreVideoAttr: {
                preload: 'none',
            },
            // 是否在移动端添加长按视频快进功能
            fastForward: true,
            // 是否在移动端的网页全屏时，根据视频尺寸和视口尺寸，旋转播放器
            autoOrientation: true,
        };
    }
}