package com.xscm.modulemain.manager;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;

import com.alibaba.android.arouter.launcher.ARouter;
import com.blankj.utilcode.util.ActivityUtils;
import com.blankj.utilcode.util.LogUtils;
import com.blankj.utilcode.util.ToastUtils;
import com.xscm.modulemain.activity.room.activity.RoomActivity;
import com.xscm.moduleutil.base.CommonAppContext;
import com.xscm.moduleutil.bean.room.RoomInfoResp;
import com.xscm.moduleutil.bean.room.RoomOnline;
import com.xscm.moduleutil.bean.room.RoomOnlineBean;
import com.xscm.moduleutil.event.RoomOutEvent;
import com.xscm.moduleutil.http.BaseObserver;
import com.xscm.moduleutil.http.RetrofitClient;
import com.xscm.moduleutil.listener.MessageListenerSingleton;
import com.xscm.moduleutil.rtc.AgoraManager;
import com.xscm.moduleutil.utils.ARouteConstants;
import com.xscm.moduleutil.utils.SpUtil;
import com.xscm.moduleutil.utils.TimeUtils;
import com.xscm.moduleutil.utils.logger.Logger;

import org.greenrobot.eventbus.EventBus;
import org.jetbrains.annotations.NotNull;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import io.reactivex.disposables.Disposable;

/**
 * 房间管理器
 * 统一处理房间数据获取、进入房间和退出房间的逻辑
 */
public class RoomManager {
    private static final String TAG = "RoomManager";

    private static RoomManager instance;

    // 房间数据缓存
    private Map<String, RoomInfoResp> roomDataCache = new ConcurrentHashMap<>();
    private Map<String, Long> cacheTimestamps = new ConcurrentHashMap<>();

    // 缓存有效期（5分钟）
    private static final long CACHE_DURATION = 5 * 60 * 1000;

    private RoomManager() {
    }

    public static synchronized RoomManager getInstance() {
        if (instance == null) {
            instance = new RoomManager();
        }
        return instance;
    }

    /**
     * 获取房间数据并进入房间
     *
     * @param context  上下文
     * @param roomId   房间ID
     * @param password 房间密码
     */
    public void fetchRoomDataAndEnter(Context context, String roomId, String password, String taskId) {
        // 显示加载提示
        // 这里可以根据需要添加加载对话框
        if (CommonAppContext.getInstance().isRoomJoininj) {
            return;
        }
        CommonAppContext.getInstance().isRoomJoininj = true;
        // 检查是否有有效的缓存数据
        RoomInfoResp roomInfo = getCachedRoomData(roomId);
        //加入房间
        MessageListenerSingleton.getInstance().joinGroup(roomId);
        if (CommonAppContext.getInstance().playId == null) {
            fetchAndJoinRoom(context, roomId, password, taskId);
        } else {
            if (!CommonAppContext.getInstance().playId.equals(roomId)) {
                MessageListenerSingleton.getInstance().joinGroup(roomId);
                exitRoom(CommonAppContext.getInstance().playId);
                CommonAppContext.getInstance().isShow = false;
                CommonAppContext.getInstance().isPlaying = false;
                CommonAppContext.getInstance().isRoomJoininj = false;
                EventBus.getDefault().post(new RoomOutEvent());
            } else if (CommonAppContext.getInstance().lable_id.equals("6")) {
                upInfo(context, roomId, password, true, roomInfo, true, taskId);
                return;
            }
            isUserOnline(context, roomId, password, roomInfo, taskId);
        }
    }

    private void upInfo(Context context, String roomId, String password, boolean isOnline, RoomInfoResp roomInfo, boolean isCurrentRoom, String taskId) {
        if (isOnline) {
            RetrofitClient.getInstance().postRoomInfo(roomId, new BaseObserver<RoomInfoResp>() {

                @Override
                public void onSubscribe(@NotNull Disposable disposable) {

                }

                @Override
                public void onNext(@NotNull RoomInfoResp roomInfoResp) {
                    navigateToRoom(context, roomId, password, roomInfoResp, false, taskId);
                }
            });
        } else {
            fetchAndJoinRoom(context, roomId, password, taskId);
        }
    }

    /**
     * 获取新的房间数据并加入房间
     *
     * @param context  上下文
     * @param roomId   房间ID
     * @param password 房间密码
     */
    private void fetchAndJoinRoom(Context context, String roomId, String password, String taskId) {
        // 获取房间数据
        RetrofitClient.getInstance().roomGetIn(roomId, password, new BaseObserver<RoomInfoResp>() {

            @Override
            public void onSubscribe(Disposable d) {
            }

            @Override
            public void onNext(RoomInfoResp resp) {
                if (resp != null) {
                    String appId = CommonAppContext.getInstance().getCurrentEnvironment().getSwSdkAppId();
                    String token = resp.getUser_info().getAgora_token(); // 如果启用了鉴权才需要
                    String roomId = resp.getRoom_info().getRoom_id(); // 房间 ID
                    String rtm_token = resp.getUser_info().getAgora_rtm_token();
                    SpUtil.setRtmToken(rtm_token);
                    int uid = SpUtil.getUserId(); // 0 表示由 Agora 自动生成 UID
                    boolean enableMic = false; // 是否开启麦克风
                    boolean enableJs = false; // 是否开启角色
                    if (resp.getUser_info().getPit_number() != 0) {
                        enableJs = true;
                    }
                    LogUtils.e("token", token);
                    LogUtils.e("roomId:", roomId);
                    // 初始化 Agora 并加入房间
                    AgoraManager.getInstance()
                            .joinRoom(token, roomId, uid, enableMic, enableJs);
                    cacheRoomData(roomId, resp);
                    navigateToRoom(context, roomId, password, resp, false, taskId);
                }
            }

            @Override
            public void onError(Throwable e) {
                super.onError(e);
            }
        });
    }


    /**
     * 跳转到房间页面
     *
     * @param context  上下文
     * @param roomId   房间ID
     * @param password 房间密码
     * @param roomInfo 房间信息
     */
    private void navigateToRoom(Context context, String roomId, String password, RoomInfoResp roomInfo, boolean isOnline, String taskId) {
        try {
            // 构建跳转参数
            Intent intent = new Intent(ActivityUtils.getTopActivity(), RoomActivity.class);
            intent.putExtra("roomId", roomId);
            intent.putExtra("isOnline", isOnline);
            intent.putExtra("roomInfo", roomInfo);
            if (!TextUtils.isEmpty(password)) {
                intent.putExtra("password", password);
            }
            if (taskId != null) {
                intent.putExtra("taskId", taskId);
            }

            if (roomInfo == null && !isOnline) {
                LogUtils.dTag("RoomActivity", "navigateToRoom:房间信息获取存在问题");
                return;
            }
            intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
            ActivityUtils.getTopActivity().startActivity(intent);
        } catch (Exception e) {
            Logger.e(TAG, "跳转房间页面失败: " + e.getMessage());
        }
    }

    /**
     * 缓存房间数据
     *
     * @param roomId   房间ID
     * @param roomInfo 房间信息
     */
    public void cacheRoomData(String roomId, RoomInfoResp roomInfo) {

        if (TextUtils.isEmpty(roomId) || roomInfo == null) {
            return;
        }
        // 清除所有现有的缓存数据
        roomDataCache.clear();
        cacheTimestamps.clear();
        roomDataCache.put(roomId, roomInfo);
        cacheTimestamps.put(roomId, System.currentTimeMillis());
    }

    /**
     * 获取缓存的房间数据
     *
     * @param roomId 房间ID
     * @return 房间信息，如果缓存无效则返回null
     */
    public RoomInfoResp getCachedRoomData(String roomId) {
        if (TextUtils.isEmpty(roomId)) {
            return null;
        }

        Long timestamp = cacheTimestamps.get(roomId);
        if (timestamp == null) {
            return null;
        }

        // 检查缓存是否过期
        if (System.currentTimeMillis() - timestamp > CACHE_DURATION) {
            // 缓存过期，清除数据
            roomDataCache.remove(roomId);
            cacheTimestamps.remove(roomId);
            return null;
        }

        return roomDataCache.get(roomId);
    }

    /**
     * 检查用户是否在线
     *
     * @param roomId 房间ID
     * @return true表示用户在线，false表示不在线
     */
    private boolean isUserOnline(Context context, String roomId, String password, RoomInfoResp roomInfo, String taskId) {
        // 这里应该实现检查用户是否在线的逻辑
        // 可以通过检查Agora是否还在房间中，或者通过服务端接口查询用户状态等方式实现
        // 目前返回false，需要根据实际需求实现具体逻辑

        final boolean[] isOnline = {false};
        RetrofitClient.getInstance().getRoomOnline(roomId, "1", "50", new BaseObserver<RoomOnline>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(RoomOnline roomOnline) {
                try {
                    if (roomOnline != null) {
                        if (roomOnline.getOn_pit() != null) {
                            for (RoomOnlineBean roomOnlineBean : roomOnline.getOn_pit()) {
                                if (roomOnlineBean.getUser_id() == SpUtil.getUserId()) {
                                    isOnline[0] = true;
                                    break;
                                }
                            }
                        }
                        if (roomOnline.getOff_pit() != null) {
                            for (RoomOnlineBean roomOnlineBean : roomOnline.getOff_pit()) {
                                if (roomOnlineBean.getUser_id() == SpUtil.getUserId()) {
                                    isOnline[0] = true;
                                    break;
                                }
                            }
                        }
                        upInfo(context, roomId, password, isOnline[0], roomInfo, true, taskId);

                    } else {
                        isOnline[0] = false;
                    }
                } catch (Exception e) {
                    // 捕获所有可能的异常，避免崩溃
                    e.printStackTrace();
                    isOnline[0] = false;
                    // 即使出现异常也继续执行
                    upInfo(context, roomId, password, isOnline[0], roomInfo, true, taskId);
                }
            }
        });
        return false;
    }

    /**
     * 清除指定房间的缓存数据
     *
     * @param roomId 房间ID
     */
    public void clearRoomCache(String roomId) {
        if (!TextUtils.isEmpty(roomId)) {
            roomDataCache.remove(roomId);
            cacheTimestamps.remove(roomId);
        }
    }

    /**
     * 退出房间
     *
     * @param roomId 房间ID
     */
    public void exitRoom(String roomId) {
        // 清除该房间的缓存数据
        clearRoomCache(roomId);

        // 可以在这里添加其他退出房间的逻辑
        // 例如：通知服务器用户已退出、清理房间相关资源等

        RetrofitClient.getInstance().quitRoom(roomId, SpUtil.getUserId() + "", new BaseObserver<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {

            }
        });

        Logger.d(TAG, "退出房间: " + roomId);
    }
}