import React, {useRef, useState } from "react"
import Taro from "@tarojs/taro";
import { Command } from "@/common/bluetooth/command";
import { uint8ArrayToFloat32, uint8ArrayToHex, waitFor } from "@/common/bluetooth/utils";


interface params {
    init: () => void
    state: Object,
    startScan: () => void,
    measureAndGetLab: () => any,
    getAdapterState: () => void,
    connect: (any) => void,
    disconnect: () => void
}
const Context = React.createContext<params|unknown>(null)

interface stateStype {
    listeners: any,
    discovering: boolean,
    available: boolean,
    connected: any,
    connecting: any,
    serviceRule: any,
    serviceId: any,
    characteristicRule: any,
    characteristicId: any,

    /** 正在执行的命令 */
    command: any,
    responseResolve: any,
    responseReject: any,
    responseTimer: any,

    /** 是否显示蓝牙调试信息 */
    debug: any,
    //搜索到的设备
    devices: any,
    //取色仪主动返回的数据
    deviceLab: any
}

let stateObj: stateStype = {
    /** 事件监听器 */ 
    listeners: new Set(),
    /** 正在扫描设备 */
    discovering: false,
    /** 蓝牙是否可用 */
    available: true,
    /** 当前连接的设备 */
    connected: null,
    /** 正在连接的设备 */
    connecting: null,

    serviceRule: /^0000FFE0/,
    serviceId: null,
    characteristicRule: /^0000FFE1/,
    characteristicId: null,

    /** 正在执行的命令 */
    command: null,
    responseResolve: null,
    responseReject: null,
    responseTimer: null,

    /** 是否显示蓝牙调试信息 */
    debug: true,
    //搜索到的设备
    devices: [],
    //取色仪主动返回的数据
    deviceLab: null
}

export default (props) => {
    let refStatus = useRef(stateObj)
    let [state, setState] = useState(refStatus.current)

    const changeStatus =  (obj:Object): void => {
        refStatus.current = {...refStatus.current, ...obj}
        setState({...refStatus.current})
    }

    const init = async () => {
        try{
            await openAdapter();
        }catch(e) {
            changeStatus({available:false})
        }
        
        // 绑定事件通知
        Taro.onBluetoothAdapterStateChange(res => {
            emit({ type: 'stateUpdate', detail: res });
        });
        Taro.onBLEConnectionStateChange(res => {
            emit({ type: res.connected ? 'connected' : 'disconnect', detail: res });
        });
        Taro.onBLECharacteristicValueChange(({ value }) => notifySubscriber(value));
        subscribe(async ev => {
            if (ev.type === 'stateUpdate') {
                // 蓝牙状态发生的变化
                changeStatus({discovering:ev.detail.discovering, available:ev.detail.available})
            } else if (ev.type === 'disconnect' && refStatus.current.connected && refStatus.current.connected.deviceId === ev.detail.deviceId) {
                // 断开连接
                changeStatus({
                    connected:null,  
                    serviceId:null,
                    characteristicId:null, 
                    deviceLab:null, 
                    devices:[]
                })
                Taro.showToast({ icon: 'none', title: '蓝牙连接已断开' });
            } else if (ev.type === 'connected' && refStatus.current.connecting) {
                // 连接成功
                changeStatus({connected: refStatus.current.connecting, connecting: null})
                Taro.showToast({ title: '蓝牙已连接' });
            } else if (ev.type === 'measure') {
                //监听取色仪主动推送lab
                await measureAndGetLab()
            }
            
        });
    }

    /** 打开蓝牙适配器 */
    const openAdapter = () => {
        return new Promise((resolve, reject) => {
            Taro.openBluetoothAdapter({
                success: resolve,
                fail: reject
            });
        });
    }

    /**
     * 推送事件
     * @param {{type: string; data: any}} event 
     */
     const emit = (event) => {
        refStatus.current.listeners.forEach(cb => {
            cb && cb(event);
        });
    }

    const subscribe = (cb) => {
        if (cb) {
            changeStatus({
                listeners: refStatus.current.listeners.add(cb)
            })
        }
    }

    /** 
     * 获取蓝牙适配器状态 
     * @returns {Promise<{discovering: boolean; available: boolean}>}
     */
     const getAdapterState = () => {
        return new Promise((resolve, reject) => {
            Taro.getBluetoothAdapterState({
                success: resolve,
                fail: reject
            })
        })
    }

    /**
     * 启动设备扫描
     * @param {(res: { devices: { name: string, deviceId: string, RSSI: number }[] }) => void} cb 
     * @param {number} duration 
     */
     const startScan = (duration = 30000) => {
        console.log('开始寻找')
        changeStatus({devices:[]})
        Taro.onBluetoothDeviceFound(getDevices);
        return new Promise((resolve, reject) => {
            Taro.startBluetoothDevicesDiscovery({
                allowDuplicatesKey: true,
                success: resolve,
                fail: reject
            });

            if (duration > 0) {
                setTimeout(() => {
                    Taro.offBluetoothDeviceFound(getDevices);
                    Taro.stopBluetoothDevicesDiscovery();
                    console.log("停止搜索")
                }, duration);
            }
        });
    }

     //获取搜索到的设备
     const getDevices = (res) => {
        res.devices.forEach(device => {
            // 排除掉已搜索到的设备和名称不合法的设备, 将新发现的设备添加到列表中
            if (/^CM/.test(device.name) && !refStatus.current.devices.find(i => i.deviceId === device.deviceId)) {
                changeStatus({devices: [ ...refStatus.current.devices, device ]})
            }
        });
    }

    /**
     * 连接设备
     * @param {{ name: string, deviceId: string, RSSI: number }} device 
     */
     const connect = async (device) => {
        try {
            changeStatus({connecting: device})
            console.log('connecting::', device)
            await createConnection(device.deviceId);
            await discoverService(device.deviceId);
            await discoverCharacteristic(device.deviceId);
            await notifyCharacteristicValueChange(device.deviceId);
        } catch (e) {
            changeStatus({connecting: null})
            Taro.showToast({ icon: 'none', title: '蓝牙连接失败' });
            throw e;
        }
    }

    /** 断开当前连接的设备 */
    const  disconnect = async () => {
        if (!refStatus.current.connected && !refStatus.current.connecting) return;
        if (refStatus.current.connected) {
            await closeConnection(refStatus.current.connected.deviceId);
            resetCommand();
            changeStatus({
                connected: null,
                serviceId: null,
                characteristicId: null,
                devices: [],
                deviceLab: null
            })
        }

        if (refStatus.current.connecting) {
            await closeConnection(refStatus.current.connecting.deviceId);
            changeStatus({connecting:null})
        }
    }

    /** 创建 BLE 连接 */
    function createConnection(deviceId) {
        return new Promise((resolve, reject) => {
            Taro.createBLEConnection({
                deviceId,
                timeout: 2000,
                success: resolve,
                fail: reject
            });
        });
    }

    /** 关闭 BLE 连接 */
    function closeConnection(deviceId) {
        return new Promise((resolve, reject) => {
            Taro.closeBLEConnection({
                deviceId,
                success: resolve,
                fail: reject
            });
        });
    }

    /** 搜索服务 */
    function discoverService(deviceId) {
        return new Promise((resolve, reject) => {
            Taro.getBLEDeviceServices({
                deviceId,
                success: ({ services }) => {
                    const service = services.find(i => refStatus.current.serviceRule.test(i.uuid));
                    if (!service) {
                        reject(new Error('服务不可用'));
                    } else {
                        changeStatus({serviceId: service.uuid})
                        resolve(service);
                    }
                },
                fail: reject
            });
        });
    }

    /** 搜索特征 */
    function discoverCharacteristic(deviceId) {
        return new Promise((resolve, reject) => {
            Taro.getBLEDeviceCharacteristics({
                deviceId,
                serviceId: refStatus.current.serviceId,
                success: ({ characteristics }) => {
                    const characteristic = characteristics.find(i => refStatus.current.characteristicRule.test(i.uuid));
                    if (!characteristic) {
                        reject(new Error('特征不可用'));
                    } else {
                        changeStatus({characteristicId: characteristic.uuid})
                        resolve(characteristic);
                    }
                },
                fail: reject
            })
        });
    }

     /** 启动特征通知 */
     function notifyCharacteristicValueChange(deviceId, stateParm = true) {
        return new Promise((resolve, reject) => {
            Taro.notifyBLECharacteristicValueChange({
                deviceId,
                serviceId: refStatus.current.serviceId,
                characteristicId: refStatus.current.characteristicId,
                state:stateParm,
                success: resolve,
                fail: reject
            });
        });
    }

    /**
     * 通知订阅器
     * @param {ArrayBuffer} buffer 
     */
     function notifySubscriber(buffer) {
        if (refStatus.current.command) {
            if (refStatus.current.debug) {
                console.log(`[BLE RESP] ${uint8ArrayToHex(new Uint8Array(buffer))}`);
            }
            refStatus.current.command.fillResponse(buffer);
            if (refStatus.current.command.isComplete) {
                if (refStatus.current.command.isValid && refStatus.current.responseResolve) {
                    refStatus.current.responseResolve(refStatus.current.command.response);
                } else if (!refStatus.current.command.isValid) {
                    refStatus.current.responseReject(new Error('无效数据'));
                }
                resetCommand();
            }
        } else {
            const uint8Array = new Uint8Array(buffer);
            if (uint8Array[0] === 0xbb && uint8Array[1] === 1 && uint8Array[3] === 0) {
                const ev = { type: 'measure', detail: { mode: uint8Array[2] } };
                emit(ev);
            }
        }
    }

    /**
     * 发送命令
     * @param {Command}} command 
     * @returns {Promise<Uint8Array>}
     */
     function exec(command) {
        return new Promise(async (resolve, reject) => {
            if (refStatus.current.command) {
                reject(new Error('正在执行其他命令'));
            } else {
                try {
                    refStatus.current.command = command;
                    const data = command.data;
                    for (let i = 0; i < data.length; i++) {
                        await sendData(data[i]);
                    } 

                    if (command.responseSize <= 0) {
                        resolve(true);
                        resetCommand();
                    } else {
                        refStatus.current.responseReject = reject;
                        refStatus.current.responseResolve = resolve;
                        refStatus.current.responseTimer = setTimeout(() => {
                            reject(new Error('命令响应超时'));
                            resetCommand();
                        }, command.timeout);
                    }
                } catch (e) {
                    reject(e);
                }
            }
            
        });
    }

     /**
     * 发送命令
     * @param {ArrayBuffer} buffer 
     */
      function sendData(buffer) {
        if (refStatus.current.debug) {
            console.log(`[BLE SEND] ${uint8ArrayToHex(new Uint8Array(buffer))}`);
        }
        return new Promise((resolve, reject) => {
            console.log('current:::',refStatus.current)
            Taro.writeBLECharacteristicValue({
                deviceId: refStatus.current.connected.deviceId,
                serviceId: refStatus.current.serviceId,
                characteristicId: refStatus.current.characteristicId,
                value: buffer,
                success: resolve,
                fail: reject
            })
        });
    }

    function resetCommand() {
        if (refStatus.current.responseTimer) {
            clearTimeout(refStatus.current.responseTimer);
        }
        changeStatus({
            command: null,
            responseResolve: null,
            responseReject: null,
            responseTimer: null
        })
    }

    /**
     * 测量
     * @param {number} mode 
     * @returns {Promise}
     */
     async function measure (mode = 0) {
        console.log('current1:::',Command.WakeUp)
        await exec(Command.WakeUp);
        console.log('current2:::',Command.WakeUp)
        await waitFor(50);
        console.log('current3:::',Command.WakeUp)
        return await exec(Command.measure(mode));
    }

    /**
     * 获取测量的 lab 值
     * @param {number} mode 
     * @returns {Promise<{ L: number, a: number, b: number }>}
     */
    async function getLab(mode = 0) {
        await exec(Command.WakeUp);
        await waitFor(50);
        const data: any = await exec(Command.getLab(mode));
        return {
            L: uint8ArrayToFloat32(data.slice(5, 9)),
            a: uint8ArrayToFloat32(data.slice(9, 13)),
            b: uint8ArrayToFloat32(data.slice(13, 17)),
        };
    }

    /**
     * 测量并获取 lab 值
     * @param {number} mode 
     * @returns {Promise<{L: number, a: number, b: number}>}
     */
     async function measureAndGetLab(mode = 0) {
        await measure(mode);
        await waitFor(50);
        const lab = await getLab(mode);
        console.log('lab2::',lab)
        changeStatus({deviceLab:lab})
        return lab
    }

    return <Context.Provider children={props.children} value={{
        init, 
        state,
        startScan,
        measureAndGetLab,
        getAdapterState,
        connect,
        disconnect
    }} />
}


export const useBluetooth = () => {
    const res = React.useContext<any>(Context)
    if(res) {
        return {...res}
    } else {
        return {}
    }
    
}