#!/bin/bash
# Test Loop - Simula esecuzione container con parallel discovery e MQTT push
# Questo script simula il comportamento completo del container in produzione

set -e

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Detect environment
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"
    INVERTER_CONFIG="/etc/inverter/inverter.conf"
    MQTT_PUSH_SCRIPT="/opt/inverter-mqtt/mqtt-push-parallel.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"
    INVERTER_CONFIG="/home/pi/Progetti/config/inverter.conf"
    MQTT_PUSH_SCRIPT="/home/pi/Progetti/sources/inverter-mqtt/mqtt-push-parallel.sh"
    CONTAINER_MODE=false
fi

SUDO_CMD=""
if [ "$EUID" -ne 0 ]; then
    SUDO_CMD="sudo"
fi

# Configuration
LOOP_INTERVAL=${LOOP_INTERVAL:-30}  # Seconds between iterations
MAX_ITERATIONS=${MAX_ITERATIONS:-0}  # 0 = infinite

echo -e "${BLUE}╔════════════════════════════════════════════════════════════════╗${NC}"
echo -e "${BLUE}║     VOLTRONIC PARALLEL INVERTER - TEST LOOP                   ║${NC}"
echo -e "${BLUE}║     Simulates container execution with full discovery          ║${NC}"
echo -e "${BLUE}╚════════════════════════════════════════════════════════════════╝${NC}"
echo ""
echo -e "${YELLOW}Mode:${NC} $([ "$CONTAINER_MODE" = true ] && echo "Container" || echo "Development")"
echo -e "${YELLOW}Binary:${NC} $INVERTER_BIN"
echo -e "${YELLOW}MQTT Config:${NC} $MQTT_CONFIG"
echo -e "${YELLOW}Loop Interval:${NC} ${LOOP_INTERVAL}s"
echo -e "${YELLOW}Max Iterations:${NC} $([ $MAX_ITERATIONS -eq 0 ] && echo "∞ (infinite)" || echo "$MAX_ITERATIONS")"
echo ""

# Check device configuration
if [ -f "$INVERTER_CONFIG" ]; then
    USB_DEVICE=$(grep "^device=" "$INVERTER_CONFIG" | cut -d= -f2)
    echo -e "${YELLOW}USB Device:${NC} $USB_DEVICE"
    # Show USB info if available
    if [ -e "$USB_DEVICE" ]; then
        USB_SERIAL=$(udevadm info -q property -n "$USB_DEVICE" 2>/dev/null | grep "ID_SERIAL_SHORT=" | cut -d= -f2)
        [ ! -z "$USB_SERIAL" ] && echo -e "${YELLOW}USB Serial:${NC} $USB_SERIAL"
    fi
fi

# Check if MQTT server is configured
if [ -f "$MQTT_CONFIG" ]; then
    MQTT_SERVER=$(cat "$MQTT_CONFIG" | jq -r '.server' 2>/dev/null || echo "not configured")
    MQTT_PORT=$(cat "$MQTT_CONFIG" | jq -r '.port' 2>/dev/null || echo "1883")
    MQTT_TOPIC=$(cat "$MQTT_CONFIG" | jq -r '.topic' 2>/dev/null || echo "homeassistant")
    MQTT_DEVICE=$(cat "$MQTT_CONFIG" | jq -r '.devicename' 2>/dev/null || echo "voltronic")
    echo -e "${YELLOW}MQTT Server:${NC} $MQTT_SERVER:$MQTT_PORT"
    echo -e "${YELLOW}MQTT Base Topic:${NC} $MQTT_TOPIC/sensor/$MQTT_DEVICE"
else
    echo -e "${RED}✗ MQTT config not found: $MQTT_CONFIG${NC}"
    exit 1
fi

echo ""
read -p "Press ENTER to start test loop (Ctrl+C to stop)..."
echo ""

# Phase 1: Initial Discovery (run once at startup)
echo -e "${BLUE}╔════════════════════════════════════════════════════════════════╗${NC}"
echo -e "${BLUE}║ PHASE 1: INITIAL DISCOVERY                                    ║${NC}"
echo -e "${BLUE}╚════════════════════════════════════════════════════════════════╝${NC}"
echo ""

echo -e "${YELLOW}[1.1] Buffer Sizes Auto-Discovery${NC}"
DISCOVERY_OUTPUT=$($SUDO_CMD "$INVERTER_BIN" -a 2>&1)
DISCOVERY_SUCCESS=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_SUCCESS=" | cut -d= -f2)

if [ "$DISCOVERY_SUCCESS" = "true" ]; then
    echo -e "${GREEN}✓ Buffer sizes discovered successfully${NC}"
    QMOD=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_QMOD=" | cut -d= -f2)
    QPIGS=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_QPIGS=" | cut -d= -f2)
    QPIRI=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_QPIRI=" | cut -d= -f2)
    QPIWS=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_QPIWS=" | cut -d= -f2)
    
    echo "  • QMOD:  $QMOD bytes"
    echo "  • QPIGS: $QPIGS bytes"
    echo "  • QPIRI: $QPIRI bytes"
    echo "  • QPIWS: $QPIWS bytes"
else
    echo -e "${RED}✗ Buffer discovery failed, using defaults${NC}"
fi
echo ""

echo -e "${YELLOW}[1.2] Parallel Inverters Discovery${NC}"
PARALLEL_OUTPUT=$($SUDO_CMD "$INVERTER_BIN" -p 2>&1)
PARALLEL_COUNT=$(echo "$PARALLEL_OUTPUT" | grep "PARALLEL_COUNT=" | cut -d= -f2)

if [ -z "$PARALLEL_COUNT" ]; then
    PARALLEL_COUNT=0
fi

VALID_SERIALS=()
VALID_QPGS=()
MAX_QPGS_IDX=-1

if [ $PARALLEL_COUNT -gt 0 ]; then
    QPGS_COUNT=$PARALLEL_COUNT
    if [ "$QPGS_COUNT" -lt 2 ]; then
        QPGS_COUNT=2
    fi

    QPGS_OUTPUT=$($SUDO_CMD "$INVERTER_BIN" -P "$QPGS_COUNT" 2>/dev/null)

    for idx in $(seq 0 $((QPGS_COUNT - 1))); do
        QPGS_DATA=$(echo "$QPGS_OUTPUT" | grep "^QPGS${idx}_REPLY=" | cut -d= -f2- | xargs)
        if [ -z "$QPGS_DATA" ]; then
            continue
        fi
        SERIAL=$(echo "$QPGS_DATA" | awk '{print $2}')
        if [ -z "$SERIAL" ] || [ "$SERIAL" = "0.0" ]; then
            continue
        fi
        if echo "$SERIAL" | grep -qE '^0+$'; then
            continue
        fi
        if ! echo "$SERIAL" | grep -qE '^[0-9]{10,}$'; then
            continue
        fi
        duplicate=false
        for existing in "${VALID_SERIALS[@]}"; do
            if [ "$existing" = "$SERIAL" ]; then
                duplicate=true
                break
            fi
        done
        if [ "$duplicate" = true ]; then
            continue
        fi
        VALID_SERIALS+=("$SERIAL")
        VALID_QPGS+=("$idx")
        if [ "$idx" -gt "$MAX_QPGS_IDX" ]; then
            MAX_QPGS_IDX=$idx
        fi
    done

    VALID_COUNT=${#VALID_SERIALS[@]}
    echo -e "${GREEN}✓ Found $VALID_COUNT valid parallel inverter(s)${NC}"
    for idx in "${!VALID_SERIALS[@]}"; do
        inv_id=$((idx + 1))
        echo "  • Inverter #$inv_id: Serial ${VALID_SERIALS[$idx]} (QPGS${VALID_QPGS[$idx]})"
    done
else
    echo -e "${YELLOW}⚠ No parallel inverters found, using single mode${NC}"
fi
echo ""

# Phase 2: Main Loop
echo -e "${BLUE}╔════════════════════════════════════════════════════════════════╗${NC}"
echo -e "${BLUE}║ PHASE 2: MAIN POLLING LOOP                                    ║${NC}"
echo -e "${BLUE}╚════════════════════════════════════════════════════════════════╝${NC}"
echo ""

iteration=0
while true; do
    iteration=$((iteration + 1))
    timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    echo -e "${BLUE}═══════════════════════════════════════════════════════════════${NC}"
    echo -e "${BLUE}Iteration #$iteration - $timestamp${NC}"
    echo -e "${BLUE}═══════════════════════════════════════════════════════════════${NC}"
    
    # Test standard commands (local inverter)
    echo -e "${YELLOW}[2.1] Testing standard commands (local inverter)${NC}"
    for cmd in QPIGS QPIRI QMOD QPIWS; do
        result=$($SUDO_CMD "$INVERTER_BIN" -r $cmd 2>&1 | grep "Reply:" | cut -d: -f2- | xargs)
        if [ ! -z "$result" ] && [ "$result" != "NAK" ]; then
            echo -e "  ${GREEN}✓${NC} $cmd: OK (${#result} chars)"
        else
            echo -e "  ${RED}✗${NC} $cmd: FAIL ($result)"
        fi
    done
    echo ""
    
    # Get parallel data
    if [ ${#VALID_SERIALS[@]} -gt 0 ]; then
        echo -e "${YELLOW}[2.2] Reading parallel inverters data${NC}"
        QPGS_COUNT=$((MAX_QPGS_IDX + 1))
        if [ "$QPGS_COUNT" -lt 1 ]; then
            QPGS_COUNT=2
        fi
        QPGS_OUTPUT=$($SUDO_CMD "$INVERTER_BIN" -P "$QPGS_COUNT" 2>/dev/null)

        for idx in "${!VALID_SERIALS[@]}"; do
            inv_id=$((idx + 1))
            SERIAL="${VALID_SERIALS[$idx]}"
            QPGS_IDX="${VALID_QPGS[$idx]}"
            QPGS_DATA=$(echo "$QPGS_OUTPUT" | grep "^QPGS${QPGS_IDX}_REPLY=" | cut -d= -f2- | xargs)
            
            if [ ! -z "$QPGS_DATA" ]; then
                IFS=' ' read -ra DATA <<< "$QPGS_DATA"
                MODE="${DATA[2]}"
                GRID_V="${DATA[4]}"
                BATT_V="${DATA[11]}"
                LOAD_W="${DATA[9]}"

                echo -e "  ${GREEN}✓${NC} Inverter #$inv_id ($SERIAL): Mode=$MODE, Grid=${GRID_V}V, Battery=${BATT_V}V, Load=${LOAD_W}W"
            else
                echo -e "  ${RED}✗${NC} Inverter #$inv_id ($SERIAL): No data"
            fi
        done
        echo ""
    fi
    
    # MQTT Push simulation
    echo -e "${YELLOW}[2.3] MQTT Push${NC}"
    if [ -x "$MQTT_PUSH_SCRIPT" ]; then
        echo "  Running: $MQTT_PUSH_SCRIPT"
        echo "  Publishing to: $MQTT_SERVER:$MQTT_PORT"
        MQTT_OUTPUT=$(bash "$MQTT_PUSH_SCRIPT" 2>&1 | tail -5)
        echo "$MQTT_OUTPUT" | sed 's/^/  /'
        
        # Show sample topics published
        if [ ${#VALID_SERIALS[@]} -gt 0 ]; then
            echo -e "  ${GREEN}Sample topics published:${NC}"
            for idx in "${!VALID_SERIALS[@]}"; do
                inv_id=$((idx + 1))
                echo "    • $MQTT_TOPIC/sensor/${MQTT_DEVICE}_inv${inv_id}_serial"
                echo "    • $MQTT_TOPIC/sensor/${MQTT_DEVICE}_inv${inv_id}_Battery_voltage"
                echo "    • $MQTT_TOPIC/sensor/${MQTT_DEVICE}_inv${inv_id}_Load_watt"
                [ $inv_id -eq 1 ] && echo "    • ... (and more)"
            done
        fi
        
        echo -e "${GREEN}✓ MQTT push completed${NC}"
    else
        echo -e "${YELLOW}⚠ MQTT script not executable: $MQTT_PUSH_SCRIPT${NC}"
        echo "  Simulating MQTT publish..."
        if [ $PARALLEL_COUNT -gt 0 ]; then
            echo "  • Published data for $PARALLEL_COUNT inverters"
        else
            echo "  • Published data for 1 inverter (single mode)"
        fi
    fi
    echo ""
    
    # Check iteration limit
    if [ $MAX_ITERATIONS -gt 0 ] && [ $iteration -ge $MAX_ITERATIONS ]; then
        echo -e "${GREEN}✓ Reached maximum iterations ($MAX_ITERATIONS)${NC}"
        break
    fi
    
    # Wait for next iteration
    echo -e "${BLUE}Waiting ${LOOP_INTERVAL}s until next iteration...${NC}"
    echo ""
    sleep $LOOP_INTERVAL
done

echo ""
echo -e "${GREEN}╔════════════════════════════════════════════════════════════════╗${NC}"
echo -e "${GREEN}║ TEST LOOP COMPLETED                                            ║${NC}"
echo -e "${GREEN}║ Total iterations: $iteration                                    ║${NC}"
echo -e "${GREEN}╚════════════════════════════════════════════════════════════════╝${NC}"