import { TABLENAME } from "../config/dbEnum";
import { addData } from "../data/addData";
import { selectOneDataByParam } from "../data/findData";
import { controlAcByEnvironment } from "./running";

/**
 * 处理接收到的环境设备数据，并存入数据库
 *
 * 消息示例：
 * {
 *   "applicationID": 1,
 *   "cellularIP": "0.0.0.0",
 *   "co2": 1649,
 *   "devEUI": "24e124710e466786",
 *   "deviceName": "cgq3",
 *   "gatewayTime": "2026-06-17T09:53:55+08:00",
 *   "hcho": 0.01,
 *   "humidity": 66.5,
 *   "light_level": 0,
 *   "pir": 1,
 *   "pm10": 32,
 *   "pm2_5": 32,
 *   "pressure": 1009.7,
 *   "temperature": 22.5,
 *   "tvoc": 1.56
 * }
 */
export async function processDeviceData(message) {
    try {
        // 解析JSON消息
        const msgStr = message.toString();
        let data: any;
        try {
            data = JSON.parse(msgStr);
        } catch (e) {
            console.error('消息不是合法JSON，跳过:', msgStr);
            return;
        }
        console.log('收到数据:', data);

        // 提取关键字段
        const devEUI = data.devEUI ? data.devEUI.toUpperCase() : null;
        if (!devEUI) {
            console.warn('消息缺少devEUI字段，跳过');
            return;
        }
        const gatewayTime = data.gatewayTime ? new Date(data.gatewayTime) : new Date();
        
        // 解码data字段（Base64 -> 十六进制）
        // const rawHex = decodePayload(data.data);
        // if (!rawHex) {
        //     console.warn('data字段为空或无效');
        //     return;
        // }

        // ===== 设备校验（保留） =====
        const deviceRow = await selectOneDataByParam(
            TABLENAME.设备表, { device_id: devEUI}
        );
        if (!deviceRow && !deviceRow.data) {
            console.warn(`设备不存在，跳过入库: ${devEUI}`);
            return;
        }

        // ===== 新设备入库（注释掉，设备由定时任务从设备商接口同步） =====
        // let now = formatLocalTime(new Date());
        // if (!deviceRow) {
        //     // 设备不存在，插入新设备（区域等后续可手动关联）
        //     await addData(
        //         TABLENAME.设备表, {
        //             device_id: devEUI,
        //             region_key: 0,
        //             device_type: '环境监测',
        //             device_name: `Device_${devEUI.slice(-6)}`,
        //             control_params: message.toString(),
        //             created_at: now,
        //             updated_at: now,
        //         }
        //     );
        //     console.log(`新设备已创建: ${devEUI}`);
        // }

        // ===== 插入设备数据（优化） =====
        const now = new Date();
        await addData(
            TABLENAME.设备数据表,
            {device_id: devEUI, data: data, received_time: now, device_time: gatewayTime, created_at: now}
        );
        
        console.log(`数据入库成功: 设备 ${devEUI}`);
        
        // 根据regionKey查询区域表，若包含文创，则禁用空调控制
        if (deviceRow.data && deviceRow.data.region_key) {
            const regionRow = await selectOneDataByParam(
                TABLENAME.区域表, { id: deviceRow.data.region_key},
                ["name"]
            );
            // 调用空调控制（非文创区域才允许自动控温）
            if (regionRow?.data && !regionRow.data.name?.includes("文创") 
                    && !regionRow.data.name?.includes("原料厅")
                    && !regionRow.data.name?.includes("社会责任厅")
                    && !regionRow.data.name?.includes("新包装")
                ) {
                await controlAcByEnvironment(devEUI, data);
            }
        }

    } catch (error) {
        console.error('数据处理失败:', error);
    }
}

/** 客流触发的单条线路数据 */
interface CustomerTriggerItem {
    /** 线路编号 */
    triggerKey: number;
    /** 线路名称 */
    triggerName: string;
    /** 线路UUID */
    triggerUuid: string;
    /** 统计对象 { in: number, out: number } */
    total: any;
}

/**
 * 处理接收到的客流设备数据，并存入数据库
 *
 * 当前格式（line_trigger_data）：
 * {
 *   device_info: { ... },
 *   line_trigger_data: [ { line: 1, line_name: 'Line1', line_uuid: '...', total: { in: 2, out: 2 } } ],
 *   time_info: { ... }
 * }
 *
 * 旧格式（已弃用，注释保留备用）：
 * //  region_trigger_data: { region_count_data: [ { region: 1, region_name: 'Region1', region_uuid: '...', total: { current_total: 9 } } ] }
 */
export async function customerDeviceData(message) {
    try {
        // 解析JSON消息
        const msgStr = message.toString();
        let data: any;
        try {
            data = JSON.parse(msgStr);
        } catch (e) {
            console.error('消息不是合法JSON，跳过:', msgStr);
            return;
        }
        console.log('收到客流数据:', data);

        // 提取设备信息
        const deviceInfo = data.device_info;
        if (!deviceInfo) {
            console.warn('消息缺少device_info字段，跳过');
            return;
        }
        const deviceSn = deviceInfo.device_sn ? deviceInfo.device_sn.toUpperCase() : null; // 设备序列号，转大写作为设备标识
        if (!deviceSn) {
            console.warn('消息缺少device_info.device_sn字段，跳过');
            return;
        }
        const deviceMac = deviceInfo.device_mac;
        const deviceName = deviceInfo.device_name || `客流设备_${deviceSn.slice(-6)}`;

        // 提取设备时间
        const timeInfo = data.time_info;
        const deviceTime = timeInfo && timeInfo.time ? new Date(timeInfo.time) : new Date();

        // ===== 提取客流数据（当前使用新格式 line_trigger_data） =====
        let triggerItems: CustomerTriggerItem[] = [];

        if (data.line_trigger_data && Array.isArray(data.line_trigger_data)) {
            // 新格式：line_trigger_data，直接是数组，total: { in, out }
            for (const item of data.line_trigger_data) {
                triggerItems.push({
                    triggerKey: item.line,
                    triggerName: item.line_name || '',
                    triggerUuid: item.line_uuid || '',
                    total: item.total,
                });
            }
            console.log(`[客流] 使用新格式 line_trigger_data，共 ${triggerItems.length} 条线路`);
        }
        /*
        // ====== 旧格式（已弃用，保留备用） ======
        else if (data.region_trigger_data?.region_count_data?.length > 0) {
            // 旧格式：region_trigger_data.region_count_data，total: { current_total }
            for (const item of data.region_trigger_data.region_count_data) {
                triggerItems.push({
                    triggerKey: item.region,
                    triggerName: item.region_name || '',
                    triggerUuid: item.region_uuid || '',
                    total: item.total,
                });
            }
            console.log(`[客流] 使用旧格式 region_trigger_data，共 ${triggerItems.length} 条区域`);
        }
        */

        if (triggerItems.length === 0) {
            console.warn('消息缺少客流线路数据，跳过');
            return;
        }

        const now = new Date();

        // ===== 设备校验/新增 =====
        const deviceRow = await selectOneDataByParam(
            TABLENAME.设备表, { device_id: deviceSn }
        );
        if (!deviceRow) {
            // 设备不存在，为每条线路创建一条设备记录
            for (const item of triggerItems) {
                await addData(
                    TABLENAME.设备表,
                    {
                        device_id: deviceSn,
                        region_key: item.triggerKey,
                        device_type: '客流传感器',
                        device_name: deviceName,
                        control_params: data,
                        created_at: now,
                        updated_at: now,
                    }
                );
                console.log(`客流设备已创建: ${deviceSn}, 线路 ${item.triggerKey}`);
            }
        }

        // 遍历每条线路的客流数据，逐条入库
        for (const item of triggerItems) {
            const inCount = item.total?.in ?? 0;
            const outCount = item.total?.out ?? 0;

            await addData(
                TABLENAME.设备数据表,
                {
                    device_id: deviceSn,
                    data: item.total,
                    received_time: now,
                    device_time: deviceTime,
                    created_at: now,
                }
            );

            console.log(`客流数据入库成功: 设备 ${deviceSn}, ${item.triggerName || item.triggerUuid}, 进 ${inCount} 出 ${outCount}`);
        }

        console.log(`客流数据处理完成: 设备 ${deviceSn}, 共入库 ${triggerItems.length} 条数据`);

    } catch (error) {
        console.error('客流数据处理失败:', error);
    }
}

// ==================== 数据解析与入库函数 ====================
/**
 * 将Base64编码的payload解码为十六进制字符串
 * 如果已知具体传感器协议，可以在这里进一步解析为具体数值
 */
function decodePayload(base64Data) {
    if (!base64Data) return null;
    // 方法1: 转为十六进制字符串（便于查看和存储）
    const buffer = Buffer.from(base64Data, 'base64');
    return buffer.toString('hex').toUpperCase();
    
    // 方法2: 如果知道协议格式，可以直接解析数值，例如：
    // return { temperature: buffer.readInt16BE(0) / 10.0, humidity: buffer.readUInt8(2) };
}