WiFi Client Health Score Calculation

RSSI [dBm] = RCPI / 2 - 110

RCPI = 65
RSSI = 65 / 2 - 110
RSSI = 32.5 - 110
RSSI = -77.5 dBm
Rounded: -78 dBm (mathematical rounding)

RSSI:           (-55 + 100) / 80 = 0.563
SNR:            32 / 80 = 0.4
Operating Std:  0.8 (802.11ac)
Error Score:    1 - (30 / 1500) = 0.98
Retrans Score:  1 - (20 / 1500) = 0.987
DL Rate Score:  400 / 867 = 0.461
UL Rate Score:  300 / 867 = 0.346
Steering Score: 1 - (2 / 20) = 0.9

Score = (0.563 × 0.20) + (0.4 × 0.20) + (0.8 × 0.15) + (0.98 × 0.15)
      + (0.987 × 0.10) + (0.461 × 0.10) + (0.346 × 0.05) + (0.9 × 0.05)

Score = 0.1126 + 0.08 + 0.12 + 0.147 + 0.0987 + 0.0461 + 0.0173 + 0.045

Score = 0.6667 → 0.7 (rounded)

Health Score = 0.7 × 100 = 70

New Weight = (Baseline Weight / Sum of Available Weights) × 100

class ClientHealthCalculator:
    WEIGHTS = {
        'rssi': 0.20,
        'snr': 0.20,
        'operating_standard': 0.15,
        'error_score': 0.15,
        'retransmission_score': 0.10,
        'dl_rate_score': 0.10,
        'ul_rate_score': 0.05,
        'steering_score': 0.05
    }

    STANDARD_SCORES = {
        '802.11be': 1.0,
        '802.11ax': 1.0,
        '802.11ac': 0.8,
        '802.11n': 0.5,
        '802.11g': 0.3,
        '802.11a': 0.3,
        'legacy': 0.3
    }

    def calculate_health_score(self, client_metrics):
        available_metrics = {}
        available_weights = {}

        # Normalize RSSI
        if client_metrics.rssi is not None:
            normalized_rssi = self._clamp((client_metrics.rssi + 100) / 80)
            available_metrics['rssi'] = normalized_rssi
            available_weights['rssi'] = self.WEIGHTS['rssi']

        # Normalize SNR
        if client_metrics.snr is not None:
            normalized_snr = self._clamp(client_metrics.snr / 80)
            available_metrics['snr'] = normalized_snr
            available_weights['snr'] = self.WEIGHTS['snr']

        # Operating Standard
        if client_metrics.operating_standard:
            std_score = self.STANDARD_SCORES.get(
                client_metrics.operating_standard, 0.3)
            available_metrics['operating_standard'] = std_score
            available_weights['operating_standard'] = self.WEIGHTS['operating_standard']

        # Error Score
        if client_metrics.total_packets > 0:
            error_score = self._clamp(
                1 - (client_metrics.total_errors / client_metrics.total_packets))
            available_metrics['error_score'] = error_score
            available_weights['error_score'] = self.WEIGHTS['error_score']

        # Retransmission Score
        if client_metrics.packets_received > 0:
            retrans_score = self._clamp(
                1 - (client_metrics.retransmissions / client_metrics.packets_received))
            available_metrics['retransmission_score'] = retrans_score
            available_weights['retransmission_score'] = self.WEIGHTS['retransmission_score']

        # Data Rate Scores (AccessPoint path only)
        if client_metrics.max_dl_rate and client_metrics.max_dl_rate > 0:
            dl_score = self._clamp(
                client_metrics.last_dl_rate / client_metrics.max_dl_rate)
            available_metrics['dl_rate_score'] = dl_score
            available_weights['dl_rate_score'] = self.WEIGHTS['dl_rate_score']

        if client_metrics.max_ul_rate and client_metrics.max_ul_rate > 0:
            ul_score = self._clamp(
                client_metrics.last_ul_rate / client_metrics.max_ul_rate)
            available_metrics['ul_rate_score'] = ul_score
            available_weights['ul_rate_score'] = self.WEIGHTS['ul_rate_score']

        # Steering Score
        if client_metrics.steering_events is not None:
            steering_score = self._clamp(
                1 - (client_metrics.steering_events / 20))
            available_metrics['steering_score'] = steering_score
            available_weights['steering_score'] = self.WEIGHTS['steering_score']

        # Check for RSSI-only fallback
        if len(available_metrics) == 1 and 'rssi' in available_metrics:
            return self._rssi_only_score(client_metrics.rssi)

        if not available_metrics:
            return None

        # Redistribute weights
        total_weight = sum(available_weights.values())
        normalized_weights = {
            k: v / total_weight for k, v in available_weights.items()
        }

        # Calculate aggregated score
        aggregated_score = sum(
            available_metrics[k] * normalized_weights[k]
            for k in available_metrics
        )

        # Round to 1 decimal place
        return round(aggregated_score * 100, 0)

    def _rssi_only_score(self, rssi):
        return max(0, min(100, 100 + rssi))

    def _clamp(self, value, min_val=0, max_val=1):
        return max(min_val, min(max_val, value))

    def get_status(self, health_score, rssi_only=False):
        if rssi_only:
            if health_score >= 40:
                return 'Good', 'green'
            elif health_score >= 21:
                return 'Average', 'yellow'
            else:
                return 'Low', 'red'
        else:
            if health_score >= 70:
                return 'Good', 'green'
            elif health_score >= 40:
                return 'Average', 'yellow'
            else:
                return 'Low', 'red'