package com.safeluck.floatwindow;

import android.app.Service;
import android.content.ComponentName;
import android.content.Context;
import android.content.ServiceConnection;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteCallbackList;
import android.os.RemoteException;

import com.safeluck.floatwindow.manager.AndroidCameraRecordManager;
import com.safeluck.floatwindow.manager.UsbCameraPushManager;
import com.safeluck.floatwindow.manager.UsbCameraRecordManager;

import timber.log.Timber;

/**
 * 悬浮窗服务，用于处理推流和录像
 * 根据MediaArgu参数选择使用不同的管理器：
 * - USB摄像头推流：UsbCameraPushManager
 * - USB摄像头录像：UsbCameraRecordManager
 * - Android相机录像：AndroidCameraRecordManager
 */
public class FloatingService extends Service {
    private static final String TAG = "FloatingService";
    
    private Context context;
    
    // 管理器实例
    private UsbCameraPushManager usbCameraPushManager;
    private UsbCameraRecordManager usbCameraRecordManager;
    private AndroidCameraRecordManager androidCameraRecordManager;
    
    // 当前使用的管理器类型
    private ManagerType currentManagerType = ManagerType.NONE;

    // P2 跨进程服务（用于 usbCameraId == 2）
    private IMediaAidlInterface p2Service;
    private boolean p2Bound = false;
    private MediaArgu pendingP2StartMedia;

    private final IMyCallback p2Callback = new IMyCallback.Stub() {
        @Override
        public void onResult(ResponseVO re) throws RemoteException {
            // 将 P2 进程回调转发给客户端
            notifyCallback(re);
        }
    };

    private final ServiceConnection p2Connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            p2Service = IMediaAidlInterface.Stub.asInterface(service);
            p2Bound = true;
            Timber.d("P2UsbCameraVideoService connected");
            try {
                p2Service.registerCallback(p2Callback);
            } catch (RemoteException e) {
                Timber.e(e, "Failed to register p2Callback");
            }

            // 如果有 pending startMedia，连接后立刻执行
            if (pendingP2StartMedia != null) {
                try {
                    p2Service.startMedia(pendingP2StartMedia);
                    pendingP2StartMedia = null;
                } catch (RemoteException e) {
                    Timber.e(e, "Failed to startMedia on P2 service");
                }
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Timber.w("P2UsbCameraVideoService disconnected");
            p2Bound = false;
            p2Service = null;
        }
    };
    
    /**
     * 管理器类型枚举
     */
    private enum ManagerType {
        NONE,
        USB_PUSH,
        USB_RECORD,
        ANDROID_RECORD
    }
    
    // AIDL Binder
    private final IMediaAidlInterface.Stub mBinder = new IMediaAidlInterface.Stub() {
        @Override
        public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, 
                double aDouble, String aString) throws RemoteException {
            Timber.d("basicTypes called: anInt=%d, aLong=%d, aBoolean=%s, aFloat=%f, aDouble=%f, aString=%s", 
                    anInt, aLong, aBoolean, aFloat, aDouble, aString);
        }
        
        @Override
        public void startMedia(MediaArgu media) throws RemoteException {
            Timber.d("startMedia called via AIDL");
            FloatingService.this.startMedia(media);
        }
        
        @Override
        public void stopMedia(MediaArgu media) throws RemoteException {
            Timber.d("stopMedia called via AIDL");
            FloatingService.this.stopMedia(media);
        }
        
        @Override
        public void registerCallback(IMyCallback cb) throws RemoteException {
            if (cb != null) {
                mCallbacks.register(cb);
                Timber.d("Callback registered");
            }
        }
        
        @Override
        public void unregisterCallback(IMyCallback cb) throws RemoteException {
            if (cb != null) {
                mCallbacks.unregister(cb);
                Timber.d("Callback unregistered");
            }
        }
    };
    
    // 回调列表，使用 RemoteCallbackList 管理跨进程回调
    private final RemoteCallbackList<IMyCallback> mCallbacks = new RemoteCallbackList<>();
    
    @Override
    public void onCreate() {
        super.onCreate();
        context = this;
        
        // 初始化管理器
        usbCameraPushManager = new UsbCameraPushManager(context);
        usbCameraPushManager.setCallback(new UsbCameraPushManager.PushCallback() {
            @Override
            public void onResult(ResponseVO response) {
                notifyCallback(response);
            }
        });
        
        usbCameraRecordManager = new UsbCameraRecordManager(context);
        usbCameraRecordManager.setCallback(new UsbCameraRecordManager.RecordCallback() {
            @Override
            public void onResult(ResponseVO response) {
                notifyCallback(response);
            }
        });
        
        androidCameraRecordManager = new AndroidCameraRecordManager(context);
        androidCameraRecordManager.setCallback(new AndroidCameraRecordManager.RecordCallback() {
            @Override
            public void onResult(ResponseVO response) {
                notifyCallback(response);
            }
        });
        
        Timber.d("FloatingService onCreate");
    }

    private void ensureP2Bound() {
        if (p2Bound) return;
        Intent intent = new Intent(this, P2UsbCameraVideoService.class);
        try {
            bindService(intent, p2Connection, Context.BIND_AUTO_CREATE);
        } catch (Exception e) {
            Timber.e(e, "bindService P2UsbCameraVideoService failed");
        }
    }
    
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return START_STICKY;
    }
    
    /**
     * 启动媒体（通过 AIDL 调用）
     */
    private void startMedia(MediaArgu media) {
        if (media == null) {
            Timber.w("startMedia: media is null");
            notifyCallback(1, -1, "MediaArgu is null");
            return;
        }

        // usbCameraId == 2：走 P2 跨进程服务，支持两路 USB 同时工作（本 Service 不再跟踪其状态）
        if (media.isUsedOutCamera() && media.getUsbCameraId() == 2) {
            ensureP2Bound();
            if (p2Service != null) {
                try {
                    p2Service.startMedia(media);
                } catch (RemoteException e) {
                    Timber.e(e, "startMedia forward to P2 failed");
                    notifyCallback(1, -3, "启动P2服务失败: " + e.getMessage());
                }
            } else {
                // 等待连接完成后执行
                pendingP2StartMedia = media;
            }
            return;
        }
        
        // 先停止当前正在运行的管理器
        stopCurrentManager();
        
        // 根据参数选择管理器
        if (media.isPush()) {
            // 推流
            if (media.isUsedOutCamera()) {
                // USB摄像头推流
                Timber.i("启动USB摄像头推流");
                currentManagerType = ManagerType.USB_PUSH;
                usbCameraPushManager.startPush(media);
            } else {
                Timber.w("推流仅支持USB摄像头");
                notifyCallback(1, -4, "推流仅支持USB摄像头");
            }
        } else {
            // 录像
            if (media.isUsedOutCamera()) {
                // USB摄像头录像
                Timber.i("启动USB摄像头录像");
                currentManagerType = ManagerType.USB_RECORD;
                usbCameraRecordManager.startRecord(media);
            } else {
                // Android相机录像
                Timber.i("启动Android相机录像");
                currentManagerType = ManagerType.ANDROID_RECORD;
                androidCameraRecordManager.startRecord(media);
            }
        }
    }
    
    /**
     * 停止当前本地管理器（仅管理本进程中的 USB(P1)/Android 录像或推流）
     */
    private void stopCurrentManager() {
        switch (currentManagerType) {
            case USB_PUSH:
                if (usbCameraPushManager != null) {
                    usbCameraPushManager.stopPush();
                }
                break;
            case USB_RECORD:
                if (usbCameraRecordManager != null) {
                    usbCameraRecordManager.stopRecord();
                }
                break;
            case ANDROID_RECORD:
                if (androidCameraRecordManager != null) {
                    androidCameraRecordManager.stopRecord();
                }
                break;
            case NONE:
                break;
        }
        currentManagerType = ManagerType.NONE;
    }
    
    /**
     * 停止媒体（通过 AIDL 调用，带 MediaArgu，用于区分 P1/P2）
     */
    private void stopMedia(MediaArgu media) {
        Timber.d("stopMedia called, media=%s", media);
        if (media != null && media.isUsedOutCamera() && media.getUsbCameraId() == 2) {
            // P2 USB 摄像头由 P2UsbCameraVideoService 管理
            ensureP2Bound();
            if (p2Service != null) {
                try {
                    p2Service.stopMedia(media);
                } catch (RemoteException e) {
                    Timber.e(e, "stopMedia forward to P2 failed");
                }
            } else {
                pendingP2StartMedia = null;
            }
        } else {
            // 其他情况（包括 P1 USB 与 Android 相机）由本 Service 自己管理
            stopCurrentManager();
        }
    }
    
    @Override
    public IBinder onBind(Intent intent) {
        Timber.d("onBind called");
        return mBinder;
    }
    
    @Override
    public void onDestroy() {
        super.onDestroy();
        stopCurrentManager();
        mCallbacks.kill();
        if (p2Bound) {
            try {
                if (p2Service != null) {
                    p2Service.unregisterCallback(p2Callback);
                }
            } catch (RemoteException e) {
                Timber.e(e, "Failed to unregister p2Callback");
            }
            try {
                unbindService(p2Connection);
            } catch (Exception e) {
                Timber.w(e, "unbindService P2 failed");
            }
            p2Bound = false;
            p2Service = null;
        }
        Timber.d("FloatingService onDestroy");
    }
    
    /**
     * 通知回调：统一使用 ResponseVO
     * @param response ResponseVO 对象，包含 type、errCode、message
     */
    private void notifyCallback(ResponseVO response) {
        if (response == null) {
            return;
        }
        int count = mCallbacks.beginBroadcast();
        for (int i = 0; i < count; i++) {
            try {
                mCallbacks.getBroadcastItem(i).onResult(response);
            } catch (RemoteException e) {
                Timber.e(e, "Error notifying callback");
            }
        }
        mCallbacks.finishBroadcast();
    }
    
    /**
     * 创建并发送回调
     * @param type 类型：0-录像 1-推流 2-文件名类型等
     * @param errCode 错误码：0-成功，其他为错误码
     * @param message 消息内容
     */
    private void notifyCallback(int type, int errCode, String message) {
        ResponseVO response = new ResponseVO();
        response.setType(type);
        response.setErrCode(errCode);
        response.setMessage(message);
        notifyCallback(response);
    }
}