package com.volcengine.reactnative.veplayer.events;

import android.os.Looper;
import android.util.SparseArray;
import androidx.annotation.NonNull;

import com.ss.ttvideoengine.Resolution;
import com.ss.ttvideoengine.TTVideoEngine;
import com.ss.ttvideoengine.VideoEngineCallback;
import com.ss.ttvideoengine.VideoEngineInfoListener;
import com.ss.ttvideoengine.VideoEngineInfos;
import com.ss.ttvideoengine.VideoInfoListener;
import com.ss.ttvideoengine.model.VideoModel;
import com.ss.ttvideoengine.utils.Error;
import java.util.concurrent.ConcurrentHashMap;

public class PlayerMultiObserver implements VideoEngineCallback, VideoEngineInfoListener, VideoInfoListener {
    // 播放器实例（一对一绑定）
    private TTVideoEngine player;
    // 观察者存储（使用线程安全的ConcurrentHashMap）
    private final ConcurrentHashMap<String, VideoEngineCallback> callbackObservers = new ConcurrentHashMap<>();
    private final ConcurrentHashMap<String, VideoEngineInfoListener> infoObservers = new ConcurrentHashMap<>();
    private final ConcurrentHashMap<String, VideoInfoListener> videoInfoObservers = new ConcurrentHashMap<>();

    // 构造函数：通过播放器实例初始化，并绑定默认回调
    public void setupPlayer(@NonNull TTVideoEngine player) {
        this.player = player;
        // 在创建时设置播放器的默认回调为当前MultiObserver
        player.setVideoEngineCallback(this);
        player.setVideoEngineInfoListener(this);
        player.setVideoInfoListener(this);
    }

    // ========== 观察者管理方法 ==========
    public void addObserverForCallback(@NonNull String observerId, @NonNull VideoEngineCallback observer) {
        callbackObservers.put(observerId, observer);
    }

    public void addObserverForInfo(@NonNull String observerId, @NonNull VideoEngineInfoListener observer) {
        infoObservers.put(observerId, observer);
    }

    public void addObserverForVideoInfo(@NonNull String observerId, @NonNull VideoInfoListener observer) {
        videoInfoObservers.put(observerId, observer);
    }

    public void removeObserver(@NonNull String observerId) {
        callbackObservers.remove(observerId);
        infoObservers.remove(observerId);
        videoInfoObservers.remove(observerId);
    }

    public void clearObservers() {
        callbackObservers.clear();
        infoObservers.clear();
        videoInfoObservers.clear();
    }

    // ========== VideoEngineCallback 接口实现（转发回调） ==========
    /**
     * 播放状态回调
     * @param engine        engine
     * @param playbackState {@link TTVideoEngine#PLAYBACK_STATE_PLAYING}(播放),
     *         {@link
     *                      TTVideoEngine#PLAYBACK_STATE_PAUSED} (暂停)
     */
    @Override
    public void onPlaybackStateChanged(TTVideoEngine engine, int playbackState) {
      for (VideoEngineCallback observer : callbackObservers.values()) {
        postToMainThread(() -> observer.onPlaybackStateChanged(engine, playbackState));
      }
    }

    /**
     * 缓冲状态回调
     * @param engine    engine
     * @param loadState {@link TTVideoEngine#LOAD_STATE_PLAYABLE}(缓冲结束),
     *         {@link
     *                  TTVideoEngine#LOAD_STATE_STALLED} (缓冲开始)
     */
    @Override
    public void onLoadStateChanged(TTVideoEngine engine, int loadState) {
      for (VideoEngineCallback observer : callbackObservers.values()) {
        postToMainThread(() -> observer.onLoadStateChanged(engine, loadState));
      }
    }

    /**
     * 视频尺寸回调
     * @param engine engine
     * @param width  视频宽度
     * @param height 视频高度
     */
    @Override
    public void onVideoSizeChanged(TTVideoEngine engine, int width, int height) {
      for (VideoEngineCallback observer : callbackObservers.values()) {
        postToMainThread(() -> observer.onVideoSizeChanged(engine, width, height));
      }
    }

    /**
     * 视频码率变化回调
     * @param resolution 视频清晰度
     * @param bitrate    视频码率 (kbps)
     */
    @Override
    public void onVideoStreamBitrateChanged(Resolution resolution, int bitrate) {
      for (VideoEngineCallback observer : callbackObservers.values()) {
        postToMainThread(() -> observer.onVideoStreamBitrateChanged(resolution, bitrate));
      }
    }


  /**
   * 视频缓冲进度更新回调
   * @param engine  engine
   * @param percent 缓冲进度 (0~100)
   */
  @Override
  public void onBufferingUpdate(TTVideoEngine engine, int percent) {
    for (VideoEngineCallback observer : callbackObservers.values()) {
      postToMainThread(() -> observer.onBufferingUpdate(engine, percent));
    }
  }

  /**
   * prepare 开始回调
   * @param engine engine
   */
  @Override
  public void onPrepare(TTVideoEngine engine) {
    for (VideoEngineCallback observer : callbackObservers.values()) {
      postToMainThread(() -> observer.onPrepare(engine));
    }
  }

  /**
   * prepare 完成回调
   * @param engine engine
   */
  @Override
  public void onPrepared(TTVideoEngine engine) {
    for (VideoEngineCallback observer : callbackObservers.values()) {
      postToMainThread(() -> observer.onPrepared(engine));
    }
  }

  /**
   * 首帧回调
   * @param engine engine
   */
  @Override
  public void onRenderStart(TTVideoEngine engine) {
    for (VideoEngineCallback observer : callbackObservers.values()) {
      postToMainThread(() -> observer.onRenderStart(engine));
    }
  }

  /**
   * 可渲染首帧的回调
   * @param engine engine
   */
  @Override
  public void onReadyForDisplay(TTVideoEngine engine) {
    for (VideoEngineCallback observer : callbackObservers.values()) {
      postToMainThread(() -> observer.onReadyForDisplay(engine));
    }
  }

  /**
   * 播放完成回调
   * @param engine engine
   */
  @Override
  public void onCompletion(TTVideoEngine engine) {
    for (VideoEngineCallback observer : callbackObservers.values()) {
      postToMainThread(() -> observer.onCompletion(engine));
    }
  }

  /**
   * 播放时间更新回调
   * @param engine engine
   */
  @Override
  public void onCurrentPlaybackTimeUpdate(TTVideoEngine engine, int currentPlaybackTime) {
    for (VideoEngineCallback observer : callbackObservers.values()) {
      postToMainThread(() -> observer.onCurrentPlaybackTimeUpdate(engine, currentPlaybackTime));
    }
  }

  /**
   * 播放错误回调
   * @param error 播放错误
   */
  @Override
  public void onError(Error error) {
    for (VideoEngineCallback observer : callbackObservers.values()) {
      postToMainThread(() -> observer.onError(error));
    }
  }

  // ========== VideoEngineInfoListener 接口实现（转发回调） ==========
  @Override
  public void onVideoEngineInfos(VideoEngineInfos videoEngineInfos) {
      for (VideoEngineInfoListener observer : infoObservers.values()) {
          postToMainThread(() -> observer.onVideoEngineInfos(videoEngineInfos));
      }
  }

  // ========== VideoInfoListener 接口实现（转发回调） ==========
  @Override
  public boolean onFetchedVideoInfo(VideoModel model) {
    for (VideoInfoListener observer : videoInfoObservers.values()) {
      postToMainThread(() -> observer.onFetchedVideoInfo(model));
    }
    return false;
  }
  
  // 辅助方法：确保回调在主线程执行
  private void postToMainThread(Runnable runnable) {
      if (Looper.myLooper() == Looper.getMainLooper()) {
          runnable.run();
      } else {
          android.os.Handler mainHandler = new android.os.Handler(Looper.getMainLooper());
          mainHandler.post(runnable);
      }
  }

//  private <T> T postToMainThreadWithResult(androidx.concurrent.futures.ResolvableFuture<T> future) {
//      // 类似实现，根据实际需求处理同步/异步结果
//      return null;
//  }
    
}