#!/bin/bash
# MQTT Push for Parallel Inverters
# Discovers parallel inverters and publishes data for each one separately

# Detect environment (container vs development)
if [ -f "/etc/inverter/mqtt.json" ] && [ -x "/opt/inverter-cli/bin/inverter_poller" ]; then
    # Container mode
    MQTT_CONFIG="/etc/inverter/mqtt.json"
    INVERTER_BIN="/opt/inverter-cli/bin/inverter_poller"
    MQTT_FALLBACK="/opt/inverter-mqtt/mqtt-push.sh"
    CONTAINER_MODE=true
else
    # Development mode
    MQTT_CONFIG="/home/pi/Progetti/config/mqtt.json"
    INVERTER_BIN="/home/pi/Progetti/sources/inverter-cli/bin/inverter_poller"
    MQTT_FALLBACK="/home/pi/Progetti/sources/inverter-mqtt/mqtt-push.sh"
    CONTAINER_MODE=false
fi

echo "Mode: $([ "$CONTAINER_MODE" = true ] && echo "Container" || echo "Development")"
echo "Using binary: $INVERTER_BIN"

# Check if jq is installed
if ! command -v jq &> /dev/null; then
    echo "ERROR: jq is not installed. Install it with: sudo apt-get install jq"
    exit 1
fi

MQTT_SERVER=`cat $MQTT_CONFIG | jq '.server' -r`
MQTT_PORT=`cat $MQTT_CONFIG | jq '.port' -r`
MQTT_TOPIC=`cat $MQTT_CONFIG | jq '.topic' -r`
MQTT_DEVICENAME=`cat $MQTT_CONFIG | jq '.devicename' -r`
MQTT_USERNAME=`cat $MQTT_CONFIG | jq '.username' -r`
MQTT_PASSWORD=`cat $MQTT_CONFIG | jq '.password' -r`
MQTT_CLIENTID=`cat $MQTT_CONFIG | jq '.clientid' -r`
INFLUX_ENABLED=`cat $MQTT_CONFIG | jq '.influx.enabled' -r`

pushMQTTData () {
    # $1 = inverter_id, $2 = metric, $3 = value
    local inverter_id=$1
    local metric=$2
    local value=$3
    
    mosquitto_pub \
        -h $MQTT_SERVER \
        -p $MQTT_PORT \
        -u "$MQTT_USERNAME" \
        -P "$MQTT_PASSWORD" \
        -i $MQTT_CLIENTID \
        -r \
        -t "$MQTT_TOPIC/sensor/${MQTT_DEVICENAME}_inv${inverter_id}_${metric}" \
        -m "$value"
    
    if [[ $INFLUX_ENABLED == "true" ]] ; then
        pushInfluxData $inverter_id $metric $value
    fi
}

pushInfluxData () {
    INFLUX_HOST=`cat $MQTT_CONFIG | jq '.influx.host' -r`
    INFLUX_USERNAME=`cat $MQTT_CONFIG | jq '.influx.username' -r`
    INFLUX_PASSWORD=`cat $MQTT_CONFIG | jq '.influx.password' -r`
    INFLUX_DEVICE=`cat $MQTT_CONFIG | jq '.influx.device' -r`
    INFLUX_PREFIX=`cat $MQTT_CONFIG | jq '.influx.prefix' -r`
    INFLUX_DATABASE=`cat $MQTT_CONFIG | jq '.influx.database' -r`
    INFLUX_MEASUREMENT_NAME=`cat $MQTT_CONFIG | jq '.influx.namingMap.'$2'' -r`
    
    curl -i -XPOST "$INFLUX_HOST/write?db=$INFLUX_DATABASE&precision=s" -u "$INFLUX_USERNAME:$INFLUX_PASSWORD" --data-binary "$INFLUX_PREFIX,device=${INFLUX_DEVICE}_inv${1} $INFLUX_MEASUREMENT_NAME=$3" > /dev/null 2>&1
}

# Extract all 33 parameters from JSON (like original mqtt-push.sh)
extractAndPublishAllData () {
    local inv_id=$1
    local json_data=$2
    
    # Extract all 33 parameters exactly like original script
    Inverter_mode=`echo "$json_data" | jq '.Inverter_mode' -r`
    [ ! -z "$Inverter_mode" ] && [ "$Inverter_mode" != "null" ] && pushMQTTData "$inv_id" "Inverter_mode" "$Inverter_mode"
    
    AC_grid_voltage=`echo "$json_data" | jq '.AC_grid_voltage' -r`
    [ ! -z "$AC_grid_voltage" ] && [ "$AC_grid_voltage" != "null" ] && pushMQTTData "$inv_id" "AC_grid_voltage" "$AC_grid_voltage"
    
    AC_grid_frequency=`echo "$json_data" | jq '.AC_grid_frequency' -r`
    [ ! -z "$AC_grid_frequency" ] && [ "$AC_grid_frequency" != "null" ] && pushMQTTData "$inv_id" "AC_grid_frequency" "$AC_grid_frequency"
    
    AC_out_voltage=`echo "$json_data" | jq '.AC_out_voltage' -r`
    [ ! -z "$AC_out_voltage" ] && [ "$AC_out_voltage" != "null" ] && pushMQTTData "$inv_id" "AC_out_voltage" "$AC_out_voltage"
    
    AC_out_frequency=`echo "$json_data" | jq '.AC_out_frequency' -r`
    [ ! -z "$AC_out_frequency" ] && [ "$AC_out_frequency" != "null" ] && pushMQTTData "$inv_id" "AC_out_frequency" "$AC_out_frequency"
    
    PV_in_voltage=`echo "$json_data" | jq '.PV_in_voltage' -r`
    [ ! -z "$PV_in_voltage" ] && [ "$PV_in_voltage" != "null" ] && pushMQTTData "$inv_id" "PV_in_voltage" "$PV_in_voltage"
    
    PV_in_current=`echo "$json_data" | jq '.PV_in_current' -r`
    [ ! -z "$PV_in_current" ] && [ "$PV_in_current" != "null" ] && pushMQTTData "$inv_id" "PV_in_current" "$PV_in_current"
    
    PV_in_watts=`echo "$json_data" | jq '.PV_in_watts' -r`
    [ ! -z "$PV_in_watts" ] && [ "$PV_in_watts" != "null" ] && pushMQTTData "$inv_id" "PV_in_watts" "$PV_in_watts"
    
    PV_in_watthour=`echo "$json_data" | jq '.PV_in_watthour' -r`
    [ ! -z "$PV_in_watthour" ] && [ "$PV_in_watthour" != "null" ] && pushMQTTData "$inv_id" "PV_in_watthour" "$PV_in_watthour"
    
    SCC_voltage=`echo "$json_data" | jq '.SCC_voltage' -r`
    [ ! -z "$SCC_voltage" ] && [ "$SCC_voltage" != "null" ] && pushMQTTData "$inv_id" "SCC_voltage" "$SCC_voltage"
    
    Load_pct=`echo "$json_data" | jq '.Load_pct' -r`
    [ ! -z "$Load_pct" ] && [ "$Load_pct" != "null" ] && pushMQTTData "$inv_id" "Load_pct" "$Load_pct"
    
    Load_watt=`echo "$json_data" | jq '.Load_watt' -r`
    [ ! -z "$Load_watt" ] && [ "$Load_watt" != "null" ] && pushMQTTData "$inv_id" "Load_watt" "$Load_watt"
    
    Load_watthour=`echo "$json_data" | jq '.Load_watthour' -r`
    [ ! -z "$Load_watthour" ] && [ "$Load_watthour" != "null" ] && pushMQTTData "$inv_id" "Load_watthour" "$Load_watthour"
    
    Load_va=`echo "$json_data" | jq '.Load_va' -r`
    [ ! -z "$Load_va" ] && [ "$Load_va" != "null" ] && pushMQTTData "$inv_id" "Load_va" "$Load_va"
    
    Bus_voltage=`echo "$json_data" | jq '.Bus_voltage' -r`
    [ ! -z "$Bus_voltage" ] && [ "$Bus_voltage" != "null" ] && pushMQTTData "$inv_id" "Bus_voltage" "$Bus_voltage"
    
    Heatsink_temperature=`echo "$json_data" | jq '.Heatsink_temperature' -r`
    [ ! -z "$Heatsink_temperature" ] && [ "$Heatsink_temperature" != "null" ] && pushMQTTData "$inv_id" "Heatsink_temperature" "$Heatsink_temperature"
    
    Battery_capacity=`echo "$json_data" | jq '.Battery_capacity' -r`
    [ ! -z "$Battery_capacity" ] && [ "$Battery_capacity" != "null" ] && pushMQTTData "$inv_id" "Battery_capacity" "$Battery_capacity"
    
    Battery_voltage=`echo "$json_data" | jq '.Battery_voltage' -r`
    [ ! -z "$Battery_voltage" ] && [ "$Battery_voltage" != "null" ] && pushMQTTData "$inv_id" "Battery_voltage" "$Battery_voltage"
    
    Battery_charge_current=`echo "$json_data" | jq '.Battery_charge_current' -r`
    [ ! -z "$Battery_charge_current" ] && [ "$Battery_charge_current" != "null" ] && pushMQTTData "$inv_id" "Battery_charge_current" "$Battery_charge_current"
    
    Battery_discharge_current=`echo "$json_data" | jq '.Battery_discharge_current' -r`
    [ ! -z "$Battery_discharge_current" ] && [ "$Battery_discharge_current" != "null" ] && pushMQTTData "$inv_id" "Battery_discharge_current" "$Battery_discharge_current"
    
    Load_status_on=`echo "$json_data" | jq '.Load_status_on' -r`
    [ ! -z "$Load_status_on" ] && [ "$Load_status_on" != "null" ] && pushMQTTData "$inv_id" "Load_status_on" "$Load_status_on"
    
    SCC_charge_on=`echo "$json_data" | jq '.SCC_charge_on' -r`
    [ ! -z "$SCC_charge_on" ] && [ "$SCC_charge_on" != "null" ] && pushMQTTData "$inv_id" "SCC_charge_on" "$SCC_charge_on"
    
    AC_charge_on=`echo "$json_data" | jq '.AC_charge_on' -r`
    [ ! -z "$AC_charge_on" ] && [ "$AC_charge_on" != "null" ] && pushMQTTData "$inv_id" "AC_charge_on" "$AC_charge_on"
    
    Battery_recharge_voltage=`echo "$json_data" | jq '.Battery_recharge_voltage' -r`
    [ ! -z "$Battery_recharge_voltage" ] && [ "$Battery_recharge_voltage" != "null" ] && pushMQTTData "$inv_id" "Battery_recharge_voltage" "$Battery_recharge_voltage"
    
    Battery_under_voltage=`echo "$json_data" | jq '.Battery_under_voltage' -r`
    [ ! -z "$Battery_under_voltage" ] && [ "$Battery_under_voltage" != "null" ] && pushMQTTData "$inv_id" "Battery_under_voltage" "$Battery_under_voltage"
    
    Battery_bulk_voltage=`echo "$json_data" | jq '.Battery_bulk_voltage' -r`
    [ ! -z "$Battery_bulk_voltage" ] && [ "$Battery_bulk_voltage" != "null" ] && pushMQTTData "$inv_id" "Battery_bulk_voltage" "$Battery_bulk_voltage"
    
    Battery_float_voltage=`echo "$json_data" | jq '.Battery_float_voltage' -r`
    [ ! -z "$Battery_float_voltage" ] && [ "$Battery_float_voltage" != "null" ] && pushMQTTData "$inv_id" "Battery_float_voltage" "$Battery_float_voltage"
    
    Max_grid_charge_current=`echo "$json_data" | jq '.Max_grid_charge_current' -r`
    [ ! -z "$Max_grid_charge_current" ] && [ "$Max_grid_charge_current" != "null" ] && pushMQTTData "$inv_id" "Max_grid_charge_current" "$Max_grid_charge_current"
    
    Max_charge_current=`echo "$json_data" | jq '.Max_charge_current' -r`
    [ ! -z "$Max_charge_current" ] && [ "$Max_charge_current" != "null" ] && pushMQTTData "$inv_id" "Max_charge_current" "$Max_charge_current"
    
    Out_source_priority=`echo "$json_data" | jq '.Out_source_priority' -r`
    [ ! -z "$Out_source_priority" ] && [ "$Out_source_priority" != "null" ] && pushMQTTData "$inv_id" "Out_source_priority" "$Out_source_priority"
    
    Charger_source_priority=`echo "$json_data" | jq '.Charger_source_priority' -r`
    [ ! -z "$Charger_source_priority" ] && [ "$Charger_source_priority" != "null" ] && pushMQTTData "$inv_id" "Charger_source_priority" "$Charger_source_priority"
    
    Battery_redischarge_voltage=`echo "$json_data" | jq '.Battery_redischarge_voltage' -r`
    [ ! -z "$Battery_redischarge_voltage" ] && [ "$Battery_redischarge_voltage" != "null" ] && pushMQTTData "$inv_id" "Battery_redischarge_voltage" "$Battery_redischarge_voltage"
    
    Warnings=`echo "$json_data" | jq '.Warnings' -r`
    [ ! -z "$Warnings" ] && [ "$Warnings" != "null" ] && pushMQTTData "$inv_id" "Warnings" "$Warnings"
}

# Discover parallel inverters with retry logic
SUDO_CMD=""
if [ "$EUID" -ne 0 ] && [ -c "/dev/ttyUSB0" ]; then
    SUDO_CMD="sudo"
fi

# Try parallel discovery with retry
MAX_RETRIES=1  # Reduced to 1 since we'll fallback to direct QPGS anyway
RETRY_DELAY=2
PARALLEL_COUNT=0

for attempt in $(seq 1 $MAX_RETRIES); do
    echo "Parallel discovery attempt $attempt/$MAX_RETRIES..."
    PARALLEL_DISCOVERY=`$SUDO_CMD "$INVERTER_BIN" -p 2>&1`
    PARALLEL_COUNT=`echo "$PARALLEL_DISCOVERY" | grep "PARALLEL_COUNT=" | cut -d= -f2`
    
    if [ ! -z "$PARALLEL_COUNT" ] && [ "$PARALLEL_COUNT" -gt 0 ]; then
        echo "✓ Found $PARALLEL_COUNT inverters"
        break
    else
        echo "⚠ Discovery failed (count=$PARALLEL_COUNT)"
        if [ $attempt -lt $MAX_RETRIES ]; then
            echo "  Waiting ${RETRY_DELAY}s before retry..."
            sleep $RETRY_DELAY
        fi
    fi
done

# If still no count or discovery failed, try direct QPGS commands
if [ -z "$PARALLEL_COUNT" ] || [ "$PARALLEL_COUNT" -eq 0 ]; then
    echo "⚠ Discovery reports 0 inverters, trying direct QPGS0/QPGS1 commands..."
    
    # Test QPGS0 to see if parallel mode is active
    TEST_QPGS0=`$SUDO_CMD "$INVERTER_BIN" -r "QPGS0" 2>&1 | grep "Reply:"`
    TEST_QPGS1=`$SUDO_CMD "$INVERTER_BIN" -r "QPGS1" 2>&1 | grep "Reply:"`
    
    if [ ! -z "$TEST_QPGS0" ] && [[ "$TEST_QPGS0" != *"NAK"* ]]; then
        echo "✓ QPGS0 responds, assuming 2 inverters in cascade"
        PARALLEL_COUNT=2
        
        # Build fake discovery output
        PARALLEL_DISCOVERY="INVERTER_1_SERIAL=unknown
INVERTER_1_QPGS=0
INVERTER_2_SERIAL=unknown
INVERTER_2_QPGS=1"
    elif [ ! -z "$TEST_QPGS1" ] && [[ "$TEST_QPGS1" != *"NAK"* ]]; then
        echo "✓ QPGS1 responds, assuming 2 inverters in cascade"
        PARALLEL_COUNT=2
        
        # Build fake discovery output
        PARALLEL_DISCOVERY="INVERTER_1_SERIAL=unknown
INVERTER_1_QPGS=0
INVERTER_2_SERIAL=unknown
INVERTER_2_QPGS=1"
    else
        echo "✗ QPGS commands also failed"
        PARALLEL_COUNT=0
    fi
fi

echo "Processing $PARALLEL_COUNT parallel inverters"

# Publish discovery info
pushMQTTData "system" "parallel_count" "$PARALLEL_COUNT"

# Get QPIRI data once (shared configuration for all inverters in cascade)
echo ""
echo "Getting shared configuration (QPIRI)..."
QPIRI_RAW=`$SUDO_CMD "$INVERTER_BIN" -r "QPIRI" 2>&1 | grep "Reply:" | cut -d: -f2- | xargs`

QPIRI_SUCCESS=false
if [ ! -z "$QPIRI_RAW" ] && [ "$QPIRI_RAW" != "NAK" ]; then
    echo "✓ QPIRI retrieved successfully"
    QPIRI_SUCCESS=true
    # Parse QPIRI: Grid rating, Grid rating, AC output rating, AC output frequency, 
    # AC output current, AC output apparent power, AC output active power,
    # Battery rating, Battery recharge, Battery under, Battery bulk, Battery float,
    # Battery type, Max charge current, Max AC charge current, Input voltage range,
    # Output source priority, Charger source priority, Parallel max num, Machine type,
    # Topology, Output mode, Battery redischarge, PV OK, PV power balance
    IFS=' ' read -ra QPIRI <<< "$QPIRI_RAW"
    
    # Extract configuration values (same for all inverters)
    BATT_RECHARGE="${QPIRI[8]}"
    BATT_UNDER="${QPIRI[9]}"
    BATT_BULK="${QPIRI[10]}"
    BATT_FLOAT="${QPIRI[11]}"
    MAX_CHARGE_CURRENT="${QPIRI[13]}"
    MAX_GRID_CHARGE="${QPIRI[14]}"
    OUT_SOURCE_PRIORITY="${QPIRI[15]}"
    CHARGER_SOURCE_PRIORITY="${QPIRI[16]}"
    BATT_REDISCHARGE="${QPIRI[22]}"
else
    echo "⚠ QPIRI failed, configuration parameters unavailable"
fi

# Extract runtime data for each inverter using QPGS
PARALLEL_SUCCESS=false

for i in $(seq 1 $PARALLEL_COUNT); do
    QPGS_IDX=$((i - 1))  # 0-based index
    SERIAL=`echo "$PARALLEL_DISCOVERY" | grep "INVERTER_${i}_SERIAL=" | cut -d= -f2`
    
    echo ""
    echo "Processing Inverter #$i (Serial: $SERIAL, QPGS$QPGS_IDX)"
    
    # Get QPGS data: 1 Serial Mode Status GridV GridF OutV OutF VA W PCT BattV ChgA Cap PVV PVA ...
    QPGS_RAW=`$SUDO_CMD "$INVERTER_BIN" -r "QPGS$QPGS_IDX" 2>&1 | grep "Reply:" | cut -d: -f2- | xargs`
    
    if [ ! -z "$QPGS_RAW" ] && [ "$QPGS_RAW" != "NAK" ]; then
        echo "  ✓ QPGS$QPGS_IDX successful"
        PARALLEL_SUCCESS=true
        
        # Parse QPGS response
        IFS=' ' read -ra DATA <<< "$QPGS_RAW"
        
        # Field mapping (verified from test output):
        # 0=Exists, 1=Serial, 2=Mode, 3=Status, 4=GridV, 5=GridF, 6=OutV, 7=OutF
        # 8=VA, 9=W, 10=PCT, 11=BattV, 12=ChgA, 13=Cap, 14=PVV, 15=PVA
        # 16=?, 17=?, 18=?, 19-26=additional fields
        
        # Publish serial
        pushMQTTData "$i" "serial" "$SERIAL"
        
        # Runtime data from QPGS (19 parameters)
        [ "${DATA[2]}" ] && pushMQTTData "$i" "Inverter_mode" "${DATA[2]}"
        [ "${DATA[4]}" ] && pushMQTTData "$i" "AC_grid_voltage" "${DATA[4]}"
        [ "${DATA[5]}" ] && pushMQTTData "$i" "AC_grid_frequency" "${DATA[5]}"
        [ "${DATA[6]}" ] && pushMQTTData "$i" "AC_out_voltage" "${DATA[6]}"
        [ "${DATA[7]}" ] && pushMQTTData "$i" "AC_out_frequency" "${DATA[7]}"
        [ "${DATA[8]}" ] && pushMQTTData "$i" "Load_va" "${DATA[8]}"
        [ "${DATA[9]}" ] && pushMQTTData "$i" "Load_watt" "${DATA[9]}"
        [ "${DATA[10]}" ] && pushMQTTData "$i" "Load_pct" "${DATA[10]}"
        [ "${DATA[11]}" ] && pushMQTTData "$i" "Battery_voltage" "${DATA[11]}"
        [ "${DATA[12]}" ] && pushMQTTData "$i" "Battery_charge_current" "${DATA[12]}"
        [ "${DATA[13]}" ] && pushMQTTData "$i" "Battery_capacity" "${DATA[13]}"
        [ "${DATA[14]}" ] && pushMQTTData "$i" "PV_in_voltage" "${DATA[14]}"
        [ "${DATA[15]}" ] && pushMQTTData "$i" "PV_in_current" "${DATA[15]}"
        
        # Calculate PV watts (V * A)
        if [ ! -z "${DATA[14]}" ] && [ ! -z "${DATA[15]}" ]; then
            PV_WATTS=`echo "${DATA[14]} ${DATA[15]}" | awk '{printf "%.1f", $1 * $2}'`
            pushMQTTData "$i" "PV_in_watts" "$PV_WATTS"
        fi
        
        # Status flags (parse from field 18 bitmap if available)
        [ "${DATA[18]}" ] && {
            BITMAP="${DATA[18]}"
            # Binary flags: bit0=Load_on, bit1=SCC_on, bit2=AC_charge_on
            LOAD_ON=$((($BITMAP & 1) ? 1 : 0))
            SCC_ON=$((($BITMAP & 2) ? 1 : 0))
            AC_CHG_ON=$((($BITMAP & 4) ? 1 : 0))
            
            pushMQTTData "$i" "Load_status_on" "$LOAD_ON"
            pushMQTTData "$i" "SCC_charge_on" "$SCC_ON"
            pushMQTTData "$i" "AC_charge_on" "$AC_CHG_ON"
        }
        
        echo "  ✓ Published 17 runtime parameters for inverter #$i"
        echo "    (QPGS data + calculated PV_watts + status flags)"
        echo "  ⚠ Missing 5 params: PV_watthour, Load_watthour, Bus_voltage, Heatsink_temp, Warnings"
        
    else
        echo "  ✗ QPGS$QPGS_IDX failed (NAK or empty)"
    fi
done

# Publish shared configuration parameters for ALL inverters (replicate QPIRI data)
if [ "$QPIRI_SUCCESS" = true ]; then
    echo ""
    echo "Publishing shared configuration to all inverters..."
    
    for i in $(seq 1 $PARALLEL_COUNT); do
        echo "  Replicating QPIRI config to inverter #$i..."
        
        [ ! -z "$BATT_RECHARGE" ] && pushMQTTData "$i" "Battery_recharge_voltage" "$BATT_RECHARGE"
        [ ! -z "$BATT_UNDER" ] && pushMQTTData "$i" "Battery_under_voltage" "$BATT_UNDER"
        [ ! -z "$BATT_BULK" ] && pushMQTTData "$i" "Battery_bulk_voltage" "$BATT_BULK"
        [ ! -z "$BATT_FLOAT" ] && pushMQTTData "$i" "Battery_float_voltage" "$BATT_FLOAT"
        [ ! -z "$MAX_CHARGE_CURRENT" ] && pushMQTTData "$i" "Max_charge_current" "$MAX_CHARGE_CURRENT"
        [ ! -z "$MAX_GRID_CHARGE" ] && pushMQTTData "$i" "Max_grid_charge_current" "$MAX_GRID_CHARGE"
        [ ! -z "$OUT_SOURCE_PRIORITY" ] && pushMQTTData "$i" "Out_source_priority" "$OUT_SOURCE_PRIORITY"
        [ ! -z "$CHARGER_SOURCE_PRIORITY" ] && pushMQTTData "$i" "Charger_source_priority" "$CHARGER_SOURCE_PRIORITY"
        [ ! -z "$BATT_REDISCHARGE" ] && pushMQTTData "$i" "Battery_redischarge_voltage" "$BATT_REDISCHARGE"
        
        echo "    ✓ Published 9 shared config parameters to inv$i"
    done
fi

# Fallback: use standard mode with full JSON output
if [ "$PARALLEL_SUCCESS" = false ]; then
    echo ""
    echo "⚠ Parallel mode failed completely (QPGS not responding)"
    echo "  Possible reasons:"
    echo "  - Inverters not configured in parallel mode in firmware"
    echo "  - RS232 connection issue"
    echo "  - Inverters in standby or fault mode"
    echo ""
    echo "  Falling back to standard single-inverter mode (QPIGS)..."
    echo "  Will publish data as 'inv1' (master inverter or aggregated data)"
    
    # Use standard inverter_poller -1 (QPIGS+QPIRI+QMOD+QPIWS) WITHOUT debug flag
    INVERTER_DATA=`timeout 10 $SUDO_CMD "$INVERTER_BIN" -1 2>/dev/null`
    
    if [ ! -z "$INVERTER_DATA" ]; then
        # Check if it's valid JSON
        echo "$INVERTER_DATA" | jq . > /dev/null 2>&1
        if [ $? -eq 0 ]; then
            echo "  ✓ Standard mode data retrieved successfully"
            extractAndPublishAllData "1" "$INVERTER_DATA"
            echo "  ✓ Published all 33 parameters for inverter #1"
            echo ""
            echo "  NOTE: If you have 2 inverters in cascade:"
            echo "  - Enable parallel mode in inverter firmware settings"
            echo "  - OR connect second inverter to separate USB port"
            echo "  - Check manual for 'Machine in Parallel' configuration"
        else
            echo "  ✗ Invalid JSON data from inverter_poller"
            echo "  Raw output: $INVERTER_DATA"
        fi
    else
        echo "  ✗ No data from inverter (timeout or device error)"
    fi
fi

echo "Parallel MQTT push completed"