#!/bin/sh

#sleep $((RANDOM % 18 + 3))

SCRIPTVERSION=16

delay=$(( ( $(hexdump -n2 -e '/2 "%u"' /dev/urandom) % 18 ) + 3 ))
#echo "Sleeping for $delay seconds..."
sleep $delay

# Get hostname
HOSTNAME=$(cat /proc/sys/kernel/hostname)

FWVER=$(cat /etc/banner | grep rev | awk '{ print $1 }')

# ===========================================================
# GPS coordinates management (locks, timeout, 0/0 fallback)
#   - Writes /tmp/gps_coordinates with:
#       longitude: <lon 6 decimals>
#       latitude:  <lat 6 decimals>
#   - Uses /tmp/gps_coordinates.<epoch>.lock (expires 10m)
#   - Tracks retries in /tmp/gps_timeout (stop after 3)
#   - On any retrieval attempt (success/fail) -> exit cycle
# ===========================================================

COORD_FILE="/tmp/gps_coordinates"
TIMEOUT_FILE="/tmp/gps_timeout"
LOCK_MAX_AGE_MIN=10          # minutes
RETRIEVE_MAX_WAIT=480        # seconds (8 minutes)
LOCATION_LON="0.000000"
LOCATION_LAT="0.000000"

# Helper: parse existing coords file (if any)
read_coords_file() {
  if [ -f "$COORD_FILE" ]; then
    # Expect two lines: "longitude: X" and "latitude: Y"
    local lon lat
    lon=$(awk -F': *' '/^longitude:/ {print $2; exit}' "$COORD_FILE")
    lat=$(awk -F': *' '/^latitude:/  {print $2; exit}' "$COORD_FILE")
    # Validate numeric and ranges; format to 6 decimals
    if echo "$lon" | awk 'BEGIN{ok=0} /^[+-]?[0-9]*\.?[0-9]+$/ {ok=1} END{exit !ok}'; then
      if echo "$lat" | awk 'BEGIN{ok=0} /^[+-]?[0-9]*\.?[0-9]+$/ {ok=1} END{exit !ok}'; then
        if awk -v a="$lat" -v b="$lon" 'BEGIN{exit !(a>=-90 && a<=90 && b>=-180 && b<=180)}'; then
          LOCATION_LON=$(awk -v x="$lon" 'BEGIN{printf "%.6f", x+0}')
          LOCATION_LAT=$(awk -v x="$lat" 'BEGIN{printf "%.6f", x+0}')
          return 0
        fi
      fi
    fi
  fi
  return 1
}

# If coords exist and valid -> proceed; else attempt retrieval logic
if read_coords_file; then
  :
else
  # Check retry threshold
  GTO=0
  if [ -f "$TIMEOUT_FILE" ]; then
    GTO=$(cat "$TIMEOUT_FILE" 2>/dev/null | awk '/^[0-9]+$/ {print $0; exit}')
    [ -z "$GTO" ] && GTO=0
  fi

  if [ "$GTO" -ge 3 ]; then
    # Give up trying; ensure coords file exists with 0/0 and exit this cycle
    printf "longitude: %.6f\nlatitude: %.6f\n" 0 0 > "${COORD_FILE}.tmp"
    mv "${COORD_FILE}.tmp" "$COORD_FILE"
    exit 0
  fi

  # Clean up stale locks (>10 minutes)
  find /tmp -maxdepth 1 -type f -name 'gps_coordinates.*.lock' -mmin +"$LOCK_MAX_AGE_MIN" -exec rm -f {} \; 2>/dev/null

  # If any non-stale lock remains, skip this run
  for f in /tmp/gps_coordinates.*.lock; do
    [ -e "$f" ] || continue
    # Found an active (<=10m) lock; skip this cycle
    exit 0
  done

  # Create fresh lock and start retrieval
  NOWTS=$(date +%s)
  LOCK_FILE="/tmp/gps_coordinates.${NOWTS}.lock"
  : > "$LOCK_FILE" 2>/dev/null

  CAND="/tmp/gps_candidate.$$"
  (
    gpspipe -r | awk -F, '
      # -------- THE ONLY CHANGE IS HERE: use deglen+1 for minutes --------
      function dm2dd(dm, hemi, deglen, deg, min, dd) {
        if (dm=="" || hemi=="") return ""
        deglen = (hemi=="N" || hemi=="S") ? 2 : 3
        deg = substr(dm, 1, deglen) + 0
        min = substr(dm, deglen+1) + 0
        dd = deg + (min / 60.0)
        return (hemi=="S" || hemi=="W") ? -dd : dd
      }
      # Wait for first valid RMC (A)
      /^\$..RMC/ && $3=="A" {
        lat = dm2dd($4, $5)
        lon = dm2dd($6, $7)
        if (lat != "" && lon != "") {
          printf("%.6f %.6f\n", lon, lat)
          exit
        }
      }
    ' > "$CAND"
  ) &
  GPID=$!

  # Wait up to RETRIEVE_MAX_WAIT seconds for candidate to appear
  waited=0
  while [ "$waited" -lt "$RETRIEVE_MAX_WAIT" ]; do
    if [ -s "$CAND" ]; then
      break
    fi
    sleep 1
    waited=$((waited+1))
  done

  success=0
  if [ -s "$CAND" ]; then
    set -- $(head -n1 "$CAND" 2>/dev/null)
    cand_lon="$1"
    cand_lat="$2"
    if awk -v a="$cand_lat" -v b="$cand_lon" 'BEGIN{ok=(a!="" && b!=""); if (!ok) exit 1; exit !(a>=-90 && a<=90 && b>=-180 && b<=180)}'
    then
      printf "longitude: %.6f\nlatitude: %.6f\n" "$cand_lon" "$cand_lat" > "${COORD_FILE}.tmp"
      mv "${COORD_FILE}.tmp" "$COORD_FILE"
      echo 0 > "$TIMEOUT_FILE"
      success=1
    fi
  fi

  # Cleanup background gpspipe if still running
  kill "$GPID" 2>/dev/null
  sleep 1
  kill -9 "$GPID" 2>/dev/null

  # Remove lock and temp
  rm -f "$LOCK_FILE" "$CAND" 2>/dev/null

  # Exit this cycle after any retrieval attempt (success or fail)
  if [ "$success" -eq 1 ]; then
    exit 0
  else
    printf "longitude: %.6f\nlatitude: %.6f\n" 0 0 > "${COORD_FILE}.tmp"
    mv "${COORD_FILE}.tmp" "$COORD_FILE"
    GTO=$((GTO+1))
    echo "$GTO" > "$TIMEOUT_FILE"
    exit 0
  fi
fi

# At this point, LOCATION_LON/LOCATION_LAT are set (from file or default 0/0)

# Get OBSS utilization value from wifitool
ATH0_OBSS_UTIL=$(wifitool ath0 get_rrmutil | awk '/obss util/ { print $4 }')
ATH1_OBSS_UTIL=$(wifitool ath1 get_rrmutil | awk '/obss util/ { print $4 }')
ATH0_CH_UTIL=$(cfg80211tool ath0 get_chutil | awk -F ':' '{ print $2 }')
ATH1_CH_UTIL=$(cfg80211tool ath1 get_chutil | awk -F ':' '{ print $2 }')

# -----------------------------------------------------------
# Count connected (real) clients on ath0 and ath1
# -----------------------------------------------------------

get_usercount() {
    IFACE=$1
    hostapd_cli -i "$IFACE" all_sta 2>/dev/null | awk '
        /^[0-9a-f]{2}(:[0-9a-f]{2}){5}$/ {mac=$0; next}
        /flags=/ {
            auth = (index($0, "AUTH") > 0)
            assoc = (index($0, "ASSOC") > 0)
            authorized = (index($0, "AUTHORIZED") > 0)
        }
        /rx_packets=/ {rx_packets=$1; sub("rx_packets=", "", rx_packets)}
        /tx_packets=/ {tx_packets=$1; sub("tx_packets=", "", tx_packets)}
        /inactive_msec=/ {inactive=$1; sub("inactive_msec=", "", inactive)}
        /connected_time=/ {
            connected=$1; sub("connected_time=", "", connected)
            if (auth && assoc && authorized &&
                rx_packets+0 > 0 && tx_packets+0 > 0 &&
                inactive+0 < 5000 && connected+0 > 60) {
                count++
            }
        }
        END { print count+0 }
    '
}

ATH0_USERCOUNT=$(get_usercount ath0)
ATH1_USERCOUNT=$(get_usercount ath1)

# -----------------------------------------------------------
# Get IP/MAC for br-wan
# -----------------------------------------------------------

MACADDRESS=$(ip link show br-wan | awk '/link\/ether/ {print $2}')
IPADDR_MASK=$(ip -4 addr show br-wan | awk '/inet / {print $2}' | head -n 1)
IPADDRESS=${IPADDR_MASK%/*}
IPMASK=${IPADDR_MASK#*/}

# -----------------------------------------------------------
# Get LLDP neighbor switch
NEIGH_SW=$(grep ikeja /tmp/run/lldp_server.json | grep -E "\-sc|\-as" -m1 | sed -E 's/.*"system_name": "([^"]+)".*/\1/')

# -----------------------------------------------------------
# Get default GW
DEFGW=$(ip route show | grep default | awk '{ print $3 }')

# -----------------------------------------------------------

# Run once per iface and reuse the buffer
ATH0_RAW="$(apstats -v -i ath0 2>/dev/null)"
ATH1_RAW="$(apstats -v -i ath1 2>/dev/null)"

# ---- ath0 (read from ATH0_RAW) ----
ATH0_TXDP=$(printf '%s\n' "$ATH0_RAW" | grep -m 1 "Tx Data Packets " | awk '{ print $NF }')
ATH0_RXDP=$(printf '%s\n' "$ATH0_RAW" | grep -m 1 "Rx Data Packets" | awk '{ print $NF }')
ATH0_TXUDP=$(printf '%s\n' "$ATH0_RAW" | grep "Tx Unicast Data Packets" | awk '{ print $NF }')
ATH0_TXMBDP=$(printf '%s\n' "$ATH0_RAW" | grep "Tx Multi/Broadcast Data Packets" | awk '{ print $NF }')
ATH0_TXMDP=$(printf '%s\n' "$ATH0_RAW" | grep "Tx multicast Data Packets" | awk '{ print $NF }')
ATH0_TXBDP=$(printf '%s\n' "$ATH0_RAW" | grep "Tx Broadcast Data Packets" | awk '{ print $NF }')
ATH0_TXFLR=$(printf '%s\n' "$ATH0_RAW" | grep "Tx failures" | awk '{ print $NF }')
ATH0_PCKERR=$(printf '%s\n' "$ATH0_RAW" | grep "Packets Errored" | awk '{ print $NF }')
ATH0_RETR=$(printf '%s\n' "$ATH0_RAW" | grep "Retries" | awk '{ print $NF }')
ATH0_BCNSUC=$(printf '%s\n' "$ATH0_RAW" | grep "Beacon success" | awk '{ print $NF }')
ATH0_BCNFLR=$(printf '%s\n' "$ATH0_RAW" | grep "Beacon failed" | awk '{ print $NF }')

ATH0_TXRATE=$(echo "$ATH0_RAW" | awk -F'=' '/^Average Tx Rate/{gsub(/[^0-9]/,"",$2); print ($2==""?0:$2); exit}')
ATH0_RXRATE=$(echo "$ATH0_RAW" | awk -F'=' '/^Average Rx Rate/{gsub(/[^0-9]/,"",$2); print ($2==""?0:$2); exit}')

# ---- ath1 (read from ATH1_RAW) ----
ATH1_TXDP=$(printf '%s\n' "$ATH1_RAW" | grep -m 1 "Tx Data Packets " | awk '{ print $NF }')
ATH1_RXDP=$(printf '%s\n' "$ATH1_RAW" | grep -m 1 "Rx Data Packets" | awk '{ print $NF }')
ATH1_TXUDP=$(printf '%s\n' "$ATH1_RAW" | grep "Tx Unicast Data Packets" | awk '{ print $NF }')
ATH1_TXMBDP=$(printf '%s\n' "$ATH1_RAW" | grep "Tx Multi/Broadcast Data Packets" | awk '{ print $NF }')
ATH1_TXMDP=$(printf '%s\n' "$ATH1_RAW" | grep "Tx multicast Data Packets" | awk '{ print $NF }')
ATH1_TXBDP=$(printf '%s\n' "$ATH1_RAW" | grep "Tx Broadcast Data Packets" | awk '{ print $NF }')
ATH1_TXFLR=$(printf '%s\n' "$ATH1_RAW" | grep "Tx failures" | awk '{ print $NF }')
ATH1_PCKERR=$(printf '%s\n' "$ATH1_RAW" | grep "Packets Errored" | awk '{ print $NF }')
ATH1_RETR=$(printf '%s\n' "$ATH1_RAW" | grep "Retries" | awk '{ print $NF }')
ATH1_BCNSUC=$(printf '%s\n' "$ATH1_RAW" | grep "Beacon success" | awk '{ print $NF }')
ATH1_BCNFLR=$(printf '%s\n' "$ATH1_RAW" | grep "Beacon failed" | awk '{ print $NF }')

ATH1_TXRATE=$(echo "$ATH1_RAW" | awk -F'=' '/^Average Tx Rate/{gsub(/[^0-9]/,"",$2); print ($2==""?0:$2); exit}')
ATH1_RXRATE=$(echo "$ATH1_RAW" | awk -F'=' '/^Average Rx Rate/{gsub(/[^0-9]/,"",$2); print ($2==""?0:$2); exit}')

# -----------------------------------------------------------
# channels
# -----------------------------------------------------------

ATH0_CH_NMBR=$(iw dev ath0 info | grep MHz | awk '{ print $2 }')
ATH0_CH_WIDTH=$(iw dev ath0 info | grep MHz | awk '{ print $6 }')
ATH0_CH_CNTR=$(iw dev ath0 info | grep MHz | awk '{ print $(NF-1) }')

ATH1_CH_NMBR=$(iw dev ath1 info | grep MHz | awk '{ print $2 }')
ATH1_CH_WIDTH=$(iw dev ath1 info | grep MHz | awk '{ print $6 }')
ATH1_CH_CNTR=$(iw dev ath1 info | grep MHz | awk '{ print $(NF-1) }')

# --- ath1 RSSI buckets (gold/silver/bronze/trash) ---
ATH1_USGLD=0; ATH1_USSLV=0; ATH1_USBRN=0; ATH1_USTRS=0
_assigns="$(
  (
    exec 2>/dev/null
    hostapd_cli -i ath1 all_sta \
    | grep 'AUTHORIZED' -B1 -A12 \
    | grep -E '([[:xdigit:]]{2}:){5}[[:xdigit:]]{2}|^signal=' \
    | awk '
        BEGIN { g=0; s=0; b=0; t=0 }
        /^[0-9A-Fa-f]{2}(:[0-9A-Fa-f]{2}){5}$/ { next }
        /^signal=/ {
          sig=$0; sub(/^signal=[[:space:]]*/,"",sig); sig+=0
          if      (sig>=-65 && sig<=-20) g++
          else if (sig>=-75 && sig<=-66) s++
          else if (sig>=-85 && sig<=-76) b++
          else if (sig>=-200 && sig<=-86) t++
        }
        END {
          printf "ATH1_USGLD=%d\nATH1_USSLV=%d\nATH1_USBRN=%d\nATH1_USTRS=%d\n", g+0, s+0, b+0, t+0
        }
    '
  ) || true
)"
if printf '%s\n' "$_assigns" | awk -F= '
  NR==1 && $1=="ATH1_USGLD" && $2 ~ /^[0-9]+$/ {ok1=1}
  NR==2 && $1=="ATH1_USSLV" && $2 ~ /^[0-9]+$/ {ok2=1}
  NR==3 && $1=="ATH1_USBRN" && $2 ~ /^[0-9]+$/ {ok3=1}
  NR==4 && $1=="ATH1_USTRS" && $2 ~ /^[0-9]+$/ {ok4=1}
  END{ exit !(ok1&&ok2&&ok3&&ok4) }
'; then
  eval "$_assigns"
fi
case "$ATH1_USGLD" in (''|*[!0-9]*) ATH1_USGLD=0;; esac
case "$ATH1_USSLV" in (''|*[!0-9]*) ATH1_USSLV=0;; esac
case "$ATH1_USBRN" in (''|*[!0-9]*) ATH1_USBRN=0;; esac
case "$ATH1_USTRS" in (''|*[!0-9]*) ATH1_USTRS=0;; esac

# --- ath0 RSSI buckets (gold/silver/bronze/trash) ---
ATH0_USGLD=0; ATH0_USSLV=0; ATH0_USBRN=0; ATH0_USTRS=0
_assigns="$(
  (
    exec 2>/dev/null
    hostapd_cli -i ath0 all_sta \
    | grep 'AUTHORIZED' -B1 -A12 \
    | grep -E '([[:xdigit:]]{2}:){5}[[:xdigit:]]{2}|^signal=' \
    | awk '
        BEGIN { g=0; s=0; b=0; t=0 }
        /^[0-9A-Fa-f]{2}(:[0-9A-Fa-f]{2}){5}$/ { next }
        /^signal=/ {
          sig=$0; sub(/^signal=[[:space:]]*/,"",sig); sig+=0
          if      (sig>=-65 && sig<=-20) g++
          else if (sig>=-75 && sig<=-66) s++
          else if (sig>=-85 && sig<=-76) b++
          else if (sig>=-200 && sig<=-86) t++
        }
        END {
          printf "ATH0_USGLD=%d\nATH0_USSLV=%d\nATH0_USBRN=%d\nATH0_USTRS=%d\n", g+0, s+0, b+0, t+0
        }
    '
  ) || true
)"
if printf '%s\n' "$_assigns" | awk -F= '
  NR==1 && $1=="ATH0_USGLD" && $2 ~ /^[0-9]+$/ {ok1=1}
  NR==2 && $1=="ATH0_USSLV" && $2 ~ /^[0-9]+$/ {ok2=1}
  NR==3 && $1=="ATH0_USBRN" && $2 ~ /^[0-9]+$/ {ok3=1}
  NR==4 && $1=="ATH0_USTRS" && $2 ~ /^[0-9]+$/ {ok4=1}
  END{ exit !(ok1&&ok2&&ok3&&ok4) }
'; then
  eval "$_assigns"
fi
case "$ATH0_USGLD" in (''|*[!0-9]*) ATH0_USGLD=0;; esac
case "$ATH0_USSLV" in (''|*[!0-9]*) ATH0_USSLV=0;; esac
case "$ATH0_USBRN" in (''|*[!0-9]*) ATH0_USBRN=0;; esac
case "$ATH0_USTRS" in (''|*[!0-9]*) ATH0_USTRS=0;; esac

# -----------------------------------------------------------
# FCS totals/errored
# -----------------------------------------------------------

WIFISTATS_ATH0_FCSOK=$(wifistats wifi0 2 | grep fcs_ok | awk '{ print $3 }')
WIFISTATS_ATH0_FCSERR=$(wifistats wifi0 2 | grep fcs_err | awk '{ print $3 }')

WIFISTATS_ATH1_FCSOK=$(wifistats wifi1 2 | grep fcs_ok | awk '{ print $3 }')
WIFISTATS_ATH1_FCSERR=$(wifistats wifi1 2 | grep fcs_err | awk '{ print $3 }')

# 10-hex-char uuid for correlation (shared between the two parts)
UUID=$(hexdump -n5 -e '5/1 "%02x"' /dev/urandom)

# ------------------------
# Part 1: ath0 + shared (+ GPS)
# ------------------------
MSG1="hostname=${HOSTNAME} \
uuid=${UUID} part=1 \
scrver=${SCRIPTVERSION} \
ath0_ch_nmbr=${ATH0_CH_NMBR} \
ath0_ch_width=${ATH0_CH_WIDTH} \
ath0_ch_cntr=${ATH0_CH_CNTR} \
ath0_obss_util=${ATH0_OBSS_UTIL} \
ath0_chutil=${ATH0_CH_UTIL} \
ath0_txdp=${ATH0_TXDP} \
ath0_rxdp=${ATH0_RXDP} \
ath0_txudp=${ATH0_TXUDP} \
ath0_txmbdp=${ATH0_TXMBDP} \
ath0_txmdp=${ATH0_TXMDP} \
ath0_txbdp=${ATH0_TXBDP} \
ath0_txflr=${ATH0_TXFLR} \
ath0_txrate=${ATH0_TXRATE} \
ath0_rxrate=${ATH0_RXRATE} \
ath0_pckerr=${ATH0_PCKERR} \
ath0_retr=${ATH0_RETR} \
ath0_bcnsuc=${ATH0_BCNSUC} \
ath0_bcnflr=${ATH0_BCNFLR} \
ath0_usercount=${ATH0_USERCOUNT} \
ath0_usgld=${ATH0_USGLD} \
ath0_usslv=${ATH0_USSLV} \
ath0_usbrn=${ATH0_USBRN} \
ath0_ustrs=${ATH0_USTRS} \
ath0_fcsok=${WIFISTATS_ATH0_FCSOK} \
ath0_fcserr=${WIFISTATS_ATH0_FCSERR} \
fw_ver=${FWVER} ipaddress=${IPADDRESS} ipmask=${IPMASK} defgw=${DEFGW} macaddress=${MACADDRESS} neigh_switch=${NEIGH_SW} \
location.lat=${LOCATION_LAT} location.lon=${LOCATION_LON}"

# ------------------------
# Part 2: ath1 only
# ------------------------
MSG2="hostname=${HOSTNAME} \
uuid=${UUID} part=2 \
scrver=${SCRIPTVERSION} \
ath1_ch_nmbr=${ATH1_CH_NMBR} \
ath1_ch_width=${ATH1_CH_WIDTH} \
ath1_ch_cntr=${ATH1_CH_CNTR} \
ath1_obss_util=${ATH1_OBSS_UTIL} \
ath1_chutil=${ATH1_CH_UTIL} \
ath1_txdp=${ATH1_TXDP} \
ath1_rxdp=${ATH1_RXDP} \
ath1_txudp=${ATH1_TXUDP} \
ath1_txmbdp=${ATH1_TXMBDP} \
ath1_txmdp=${ATH1_TXMDP} \
ath1_txbdp=${ATH1_TXBDP} \
ath1_txflr=${ATH1_TXFLR} \
ath1_txrate=${ATH1_TXRATE} \
ath1_rxrate=${ATH1_RXRATE} \
ath1_pckerr=${ATH1_PCKERR} \
ath1_retr=${ATH1_RETR} \
ath1_bcnsuc=${ATH1_BCNSUC} \
ath1_bcnflr=${ATH1_BCNFLR} \
ath1_usercount=${ATH1_USERCOUNT} \
ath1_usgld=${ATH1_USGLD} \
ath1_usslv=${ATH1_USSLV} \
ath1_usbrn=${ATH1_USBRN} \
ath1_ustrs=${ATH1_USTRS} \
ath1_fcsok=${WIFISTATS_ATH1_FCSOK} \
ath1_fcserr=${WIFISTATS_ATH1_FCSERR} \
location.lat=${LOCATION_LAT} location.lon=${LOCATION_LON}"

# Send messages via syslog (two separate lines, same tag)
logger -t "debug|${HOSTNAME}" "$MSG1"
logger -t "debug|${HOSTNAME}" "$MSG2"