simulator.ts

import bleno from '@abandonware/bleno';
import fs from 'fs';
import { parse } from 'csv-parse';
import path from 'path';

// --- CONFIGURATION ---
const SERVICE_UUID = 'A07498CA-AD5B-474E-940D-16F1FBE7E8CD';
const CHARACTERISTIC_UUID = '51FF12BB-3ED8-46E5-B4F9-D64E2FEC021B';
const CSV_FILE = 'sensor_data.csv';
const UPDATE_INTERVAL = 2000; // Update every 2 seconds

// --- DATA STRUCTURE ---
// Based on your specific CSV headers
interface LogisticsData {
  Timestamp: string;
  Asset_ID: string;
  Temperature: string;
  Humidity: string;
  Inventory_Level: string;
  Shipment_Status: string;
}

let dataRows: LogisticsData[] = [];
let currentIndex = 0;

// --- LOAD CSV ---
console.log(`[Init] Loading ${CSV_FILE}...`);
const csvPath = path.resolve(__dirname, CSV_FILE);

if (fs.existsSync(csvPath)) {
    fs.createReadStream(csvPath)
        .pipe(parse({ 
            columns: true, 
            trim: true, 
            skip_empty_lines: true,
            bom: true 
        }))
        .on('data', (row) => {
            // Push row directly; names match the CSV headers
            dataRows.push(row);
        })
        .on('end', () => {
            console.log(`[Init] Successfully loaded ${dataRows.length} rows.`);
            if(dataRows.length > 0) {
                console.log("Sample Row:", dataRows[0]); // Debug print
            }
        });
} else {
    console.error(`[Error] File ${CSV_FILE} not found!`);
}

// --- DEFINE BLE CHARACTERISTIC ---
class LogisticsCharacteristic extends bleno.Characteristic {
    updateValueCallback: ((data: Buffer) => void) | null;
    timer: NodeJS.Timeout | null;

    constructor() {
        super({
            uuid: CHARACTERISTIC_UUID,
            properties: ['read', 'notify'],
            value: null
        });
        this.updateValueCallback = null;
        this.timer = null;
    }

    // Return the current value as a formatted string
    getCurrentValue(): Buffer {
        if (dataRows.length === 0) return Buffer.from("No Data");
        
        const row = dataRows[currentIndex];
        
        // Format: "AssetID,Temp,Hum,Status"
        // Example: "Truck_7,27.0,67.8,Delayed"
        const payload = `${row.Asset_ID},${row.Temperature},${row.Humidity},${row.Shipment_Status}`;
        
        return Buffer.from(payload);
    }

    onReadRequest(offset: number, callback: (result: number, data?: Buffer) => void) {
        const data = this.getCurrentValue();
        console.log(`[Read] Sending: ${data.toString()}`);
        callback(this.RESULT_SUCCESS, data);
    }

    onSubscribe(maxValueSize: number, updateValueCallback: (data: Buffer) => void) {
        console.log('[BLE] Client Subscribed (Notifications ON)');
        this.updateValueCallback = updateValueCallback;

        this.timer = setInterval(() => {
            if (dataRows.length === 0) return;

            // Move to next row
            currentIndex = (currentIndex + 1) % dataRows.length;
            
            const data = this.getCurrentValue();
            
            if (this.updateValueCallback) {
                console.log(`[Notify] Broadcasting: ${data.toString()}`);
                this.updateValueCallback(data);
            }
        }, UPDATE_INTERVAL);
    }

    onUnsubscribe() {
        console.log('[BLE] Client Unsubscribed');
        this.updateValueCallback = null;
        if (this.timer) clearInterval(this.timer);
    }
}

// --- START BLE SERVICE ---
const logisticsChar = new LogisticsCharacteristic();

bleno.on('stateChange', (state) => {
    console.log(`[BLE] Adapter State: ${state}`);
    if (state === 'poweredOn') {
        bleno.startAdvertising('LogisticsSim', [SERVICE_UUID]);
    } else {
        bleno.stopAdvertising();
    }
});

bleno.on('advertisingStart', (error) => {
    if (!error) {
        console.log('[BLE] Service Active. Waiting for connections...');
        bleno.setServices([
            new bleno.PrimaryService({
                uuid: SERVICE_UUID,
                characteristics: [logisticsChar]
            })
        ]);
    } else {
        console.error(`[BLE] Advertising Error: ${error}`);
    }
});