package com.xscm.moduleutil.base;

import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.text.TextUtils;

import com.alibaba.android.arouter.launcher.ARouter;
import com.blankj.utilcode.util.LogUtils;
import com.blankj.utilcode.util.ToastUtils;
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.logger.Logger;

import org.greenrobot.eventbus.EventBus;

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
     */
    public void enterRoom(Context context, String roomId) {
        enterRoom(context, roomId, null, null);
    }

    /**
     * 进入房间 - 使用密码
     * @param context 上下文
     * @param roomId 房间ID
     * @param password 房间密码
     */
    public void enterRoom(Context context, String roomId, String password) {
        enterRoom(context, roomId, password, null);
    }

    /**
     * 进入房间 - 使用缓存数据
     * @param context 上下文
     * @param roomId 房间ID
     * @param password 房间密码
     * @param cachedData 缓存的房间数据
     */
    public void enterRoom(Context context, String roomId, String password, RoomInfoResp cachedData) {
        if (TextUtils.isEmpty(roomId)) {
            ToastUtils.showShort("房间ID不能为空");
            return;
        }

        // 检查是否有有效的缓存数据
        RoomInfoResp roomInfo = cachedData != null ? cachedData : getCachedRoomData(roomId);

        if (roomInfo != null) {
            // 使用缓存数据直接进入房间
            navigateToRoom(context, roomId, password, roomInfo, false);
        } else {
            // 获取房间数据后进入房间
            fetchRoomDataAndEnter(context, roomId, password);
        }
    }

    /**
     * 获取房间数据并进入房间
     * @param context 上下文
     * @param roomId 房间ID
     * @param password 房间密码
     */
    public void fetchRoomDataAndEnter(Context context, String roomId, String password) {
        // 显示加载提示
        // 这里可以根据需要添加加载对话框

        // 检查是否有有效的缓存数据
//        RoomInfoResp roomInfo =  getCachedRoomData(roomId);
        // 检查是否是当前房间且用户在线
//        boolean isCurrentRoom = isCurrentRoom(roomId);
        if (CommonAppContext.getInstance().playId==null){
            fetchAndJoinRoom(context, roomId, password);
        }else {
            isUserOnline(context, roomId, password, null);
        }

//        try {
//            Thread.sleep(1000);
//        } catch (InterruptedException e) {
//            Thread.currentThread().interrupt();
//        }

        // 如果是当前房间且用户在线，直接跳转到房间页面，仅更新数据


//        // 获取房间数据
//        MessageListenerSingleton.getInstance().joinGroup(roomId);
//        // 等待一段时间确保退出完成
//        try {
//            Thread.sleep(500);
//        } catch (InterruptedException e) {
//            Thread.currentThread().interrupt();
//        }
//        RetrofitClient.getInstance().roomGetIn(roomId, password, new BaseObserver<RoomInfoResp>() {
//
//            @Override
//            public void onSubscribe(Disposable d) {
//            }
//
//            @Override
//            public void onNext(RoomInfoResp resp) {
//                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(context)
//                        .joinRoom(token, roomId, uid, enableMic,enableJs);
//                cacheRoomData(roomId, resp);
//                navigateToRoom(context, roomId, password, resp);
//            }
//        });

        // 临时实现 - 直接跳转（因为缺少具体的网络请求代码）
//        navigateToRoom(context, roomId, password, null);
    }

    private void upInfo(Context context, String roomId, String password,boolean isOnline, RoomInfoResp roomInfo,boolean isCurrentRoom){


        if (isOnline){
            navigateToRoom(context, roomId, password, roomInfo,isOnline);
        }else {
//            CommonAppContext.getInstance().isShow = false;
//            CommonAppContext.getInstance().isPlaying = false;
//            EventBus.getDefault().post(new RoomOutEvent());
//            try {
//                Thread.sleep(300);
//            } catch (InterruptedException e) {
//                Thread.currentThread().interrupt();
//            }
            fetchAndJoinRoom(context, roomId, password);
        }



//        if (isCurrentRoom&& isOnline) {
//            if (roomInfo != null) {
//                navigateToRoom(context, roomId, password, roomInfo);
//            } else {
//                // 即使在线，如果没有缓存数据，也需要获取数据
//                fetchAndJoinRoom(context, roomId, password);
//            }
//            return;
//        }


        // 如果有缓存数据且用户在线，使用缓存数据进入房间
//        if (roomInfo != null && isOnline) {
//            RetrofitClient.getInstance().postRoomInfo(roomId, new BaseObserver<RoomInfoResp>() {
//
//                @Override
//                public void onSubscribe(Disposable d) {
//
//                }
//
//                @Override
//                public void onNext(RoomInfoResp roomInfoResp) {
////                    cacheRoomData(roomId, roomInfo);
//                    navigateToRoom(context, roomId, password, roomInfoResp);
//                }
//            });

//            cacheRoomData(roomId, roomInfo);
//            navigateToRoom(context, roomId, password, roomInfo);
            return;
//        }

        // 其他情况，获取新的房间数据并加入房间
//        fetchAndJoinRoom(context, roomId, password);
    }

    /**
     * 获取新的房间数据并加入房间
     * @param context 上下文
     * @param roomId 房间ID
     * @param password 房间密码
     */
    private void fetchAndJoinRoom(Context context, String roomId, String password) {
        // 获取房间数据
        MessageListenerSingleton.getInstance().joinGroup(roomId);
        // 等待一段时间确保退出完成
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        navigateToRoom(context, roomId, password, null,false);

//        RetrofitClient.getInstance().roomGetIn(roomId, password, new BaseObserver<RoomInfoResp>() {
//
//            @Override
//            public void onSubscribe(Disposable d) {
//            }
//
//            @Override
//            public void onNext(RoomInfoResp resp) {
//                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(context)
//                        .joinRoom(token, roomId, uid, enableMic,enableJs);
//                cacheRoomData(roomId, resp);
//                navigateToRoom(context, roomId, password, resp);
//            }
//        });
    }

    /**
     * 检查是否是当前房间
     * @param roomId 房间ID
     * @return true表示是当前房间，false表示不是
     */
    private boolean isCurrentRoom(String roomId) {
        // 这里应该实现检查是否是当前房间的逻辑
        // 可以通过检查当前Activity或者通过全局变量等方式实现
        // 目前返回false，需要根据实际需求实现具体逻辑

        RoomInfoResp roomInfo = getCachedRoomData(roomId);
        if (roomInfo != null){
            if (roomInfo.getRoom_info().getRoom_id().equals(roomId)){
                return true;
            }else {
                return false;
            }
        }

        return false;
    }
    /**
     * 跳转到房间页面
     * @param context 上下文
     * @param roomId 房间ID
     * @param password 房间密码
     * @param roomInfo 房间信息
     */
    private void navigateToRoom(Context context, String roomId, String password, RoomInfoResp roomInfo,boolean isOnline) {
        try {
            // 构建跳转参数
            Bundle bundle = new Bundle();
            bundle.putString("roomId", roomId);
            bundle.putBoolean("isOnline", isOnline);

            if (!TextUtils.isEmpty(password)) {
                bundle.putString("password", password);
            }

            if (roomInfo != null) {
//                bundle.putSerializable("roomInfo", roomInfo);
            }

            // 使用ARouter跳转到房间页面
            ARouter.getInstance()
                    .build(ARouteConstants.ROOM_DETAILS)
                    .with(bundle)
                    .withFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_REORDER_TO_FRONT)
                    .navigation(context);

        } 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) {
        // 这里应该实现检查用户是否在线的逻辑
        // 可以通过检查Agora是否还在房间中，或者通过服务端接口查询用户状态等方式实现
        // 目前返回false，需要根据实际需求实现具体逻辑
//        boolean isCurrentRoom=isCurrentRoom(roomId);
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        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);
                    } else {
                        isOnline[0] = false;
                    }
                } catch (Exception e) {
                    // 捕获所有可能的异常，避免崩溃
                    e.printStackTrace();
                    isOnline[0] = false;
                    // 即使出现异常也继续执行
                    upInfo(context, roomId, password, isOnline[0], roomInfo, true);
                }
            }
        });
        return  isOnline[0];
    }
    /**
     * 清除指定房间的缓存数据
     * @param roomId 房间ID
     */
    public void clearRoomCache(String roomId) {
        if (!TextUtils.isEmpty(roomId)) {
            roomDataCache.remove(roomId);
            cacheTimestamps.remove(roomId);
        }
    }

    /**
     * 清除所有房间缓存数据
     */
    public void clearAllRoomCache() {
        roomDataCache.clear();
        cacheTimestamps.clear();
    }

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

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

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

    /**
     * 批量退出房间
     * @param roomIds 房间ID列表
     */
    public void exitRooms(String... roomIds) {
        if (roomIds != null) {
            for (String roomId : roomIds) {
                exitRoom(roomId);
            }
        }
    }

    /**
     * 获取房间缓存状态
     * @param roomId 房间ID
     * @return 缓存状态信息
     */
    public String getRoomCacheStatus(String roomId) {
        if (TextUtils.isEmpty(roomId)) {
            return "无效的房间ID";
        }

        Long timestamp = cacheTimestamps.get(roomId);
        if (timestamp == null) {
            return "未缓存";
        }

        long elapsed = System.currentTimeMillis() - timestamp;
        if (elapsed > CACHE_DURATION) {
            return "缓存已过期";
        }

        RoomInfoResp data = roomDataCache.get(roomId);
        if (data == null) {
            return "缓存数据为空";
        }

        return String.format("已缓存 (%d秒前)", elapsed / 1000);
    }
}