Mesh Network Detection

public SatelliteContext detectMesh(ParameterTree tree,
                                   WifiContext wifiContext,
                                   List<HostInfo> hosts,
                                   DeviceInfo deviceInfo) {
    // Step 1: Locate WiFi object root
    ObjectNode wifiNode = tree.getObject("Device.WiFi");

    // Step 2: Try DataElements path (preferred for modern devices)
    ObjectNode dataElements = wifiNode
        .getChildObject("DataElements")
        .getChildObject("Network")
        .getChildObject("Device");

    if (!dataElements.isEmpty()) {
        // Step 3: Process DataElements mesh
        DataElementsInfo info = DataElementsMapper.toDataElementsInfo(dataElements);

        if (info.getDevices().size() >= 2) {
            // MESH DETECTED via DataElements
            SatelliteContext context = SatelliteProcessor.processDataElements(info);
            context.setSatelliteType(SatelliteType.DATA_ELEMENTS);
            return context;
        } else {
            // Mesh capable but not active (< 2 devices)
            return createNoMeshContext("DataElements capable, but < 2 devices");
        }
    }

    // Step 4: Fallback to MultiAP path (legacy devices)
    ObjectNode multiAP = wifiNode
        .getChildObject("MultiAP")
        .getChildObject("APDevice");

    if (!multiAP.isEmpty()) {
        // Step 5: Process MultiAP mesh
        MultiAPInfo info = APMapper.toMultiAPInfo(multiAP, deviceInfo);

        if (info.getDevices().size() >= 2) {
            // MESH DETECTED via MultiAP
            SatelliteContext context = SatelliteProcessor.processMultiAP(info, wifiContext);
            context.setSatelliteType(SatelliteType.MULTI_AP);
            return context;
        } else {
            // Mesh capable but not active (< 2 devices)
            return createNoMeshContext("MultiAP capable, but < 2 devices");
        }
    }

    // Step 6: No mesh support detected
    return createNoMeshContext("No DataElements or MultiAP objects");
}

def detect_vendor_custom_mesh(device):
    """Attempt detection using vendor-specific custom objects"""

    # Check for vendor-specific mesh indicators
    vendor_paths = {
        'ASUS': 'Device.X_ASUS_AiMesh.NodeList',
        'TP-Link': 'Device.X_TP_OneMesh.DeviceList',
        'Netgear': 'Device.X_NETGEAR_Orbi.SatelliteTable',
        'Ubiquiti': 'Device.X_UBNT_Mesh.Nodes'
    }

    for vendor, path in vendor_paths.items():
        value = query_parameter(device, path)
        if value is not None:
            return {
                'detected': True,
                'vendor': vendor,
                'custom_path': path,
                'requires_mapping': True
            }

    return {'detected': False, 'reason': 'No standard or custom objects found'}

class MeshDetector:
    """Complete mesh network detection implementation"""

    def __init__(self, device_parameters):
        self.params = device_parameters
        self.device_tree = self.build_parameter_tree()

    def detect_mesh(self):
        """Main detection entry point"""
        # Try DataElements path first (modern standard)
        data_elements_result = self.try_data_elements()
        if data_elements_result['detected']:
            return data_elements_result

        # Fallback to MultiAP path (legacy standard)
        multi_ap_result = self.try_multi_ap()
        if multi_ap_result['detected']:
            return multi_ap_result

        # No standard mesh detected
        return {
            'detected': False,
            'mesh_type': None,
            'device_count': 0,
            'reason': 'No DataElements or MultiAP objects found'
        }

    def try_data_elements(self):
        """Attempt detection via DataElements path"""
        base_path = "Device.WiFi.DataElements.Network.Device"
        devices = self.get_object_instances(base_path)

        if len(devices) == 0:
            return {'detected': False, 'reason': 'DataElements object empty'}

        if len(devices) == 1:
            return {
                'detected': False,
                'mesh_capable': True,
                'reason': 'Single device - mesh capable but not active',
                'device_count': 1
            }

        # Parse device information
        mesh_devices = []
        for idx, device in enumerate(devices):
            device_path = f"{base_path}.{idx}"
            device_info = {
                'id': self.get_param(f"{device_path}.ID"),
                'backhaul_type': self.get_param(f"{device_path}.BackhaulMediaType"),
                'backhaul_mac': self.get_param(f"{device_path}.BackhaulMACAddress"),
                'hostname': self.get_param(f"{device_path}.MultiAPDevice.HostName"),
                'model': self.get_param(f"{device_path}.ManufacturerModel")
            }

            # Determine role
            if not device_info['backhaul_type'] or \
               device_info['backhaul_type'] in ['None', 'Controller', '']:
                device_info['role'] = 'CONTROLLER'
            else:
                device_info['role'] = 'SATELLITE'

            mesh_devices.append(device_info)

        return {
            'detected': True,
            'mesh_type': 'DataElements',
            'standard': 'WiFi EasyMesh',
            'device_count': len(mesh_devices),
            'devices': mesh_devices,
            'controller_count': sum(1 for d in mesh_devices if d['role'] == 'CONTROLLER'),
            'satellite_count': sum(1 for d in mesh_devices if d['role'] == 'SATELLITE')
        }

    def try_multi_ap(self):
        """Attempt detection via MultiAP path"""
        base_path = "Device.WiFi.MultiAP.APDevice"
        devices = self.get_object_instances(base_path)

        if len(devices) == 0:
            return {'detected': False, 'reason': 'MultiAP object empty'}

        if len(devices) == 1:
            return {
                'detected': False,
                'mesh_capable': True,
                'reason': 'Single device - mesh capable but not active',
                'device_count': 1
            }

        # Parse device information
        mesh_devices = []
        for idx, device in enumerate(devices):
            device_path = f"{base_path}.{idx}"
            device_info = {
                'mac': self.get_param(f"{device_path}.MACAddress"),
                'backhaul_type': self.get_param(f"{device_path}.BackhaulLinkType"),
                'backhaul_mac': self.get_param(f"{device_path}.BackhaulMACAddress"),
                'backhaul_rssi': self.get_param(f"{device_path}.BackhaulSignalStrength")
            }

            # Determine role
            if device_info['backhaul_type'] == 'None' or not device_info['backhaul_type']:
                device_info['role'] = 'CONTROLLER'
            else:
                device_info['role'] = 'SATELLITE'

            mesh_devices.append(device_info)

        return {
            'detected': True,
            'mesh_type': 'MultiAP',
            'standard': 'WiFi MultiAP',
            'device_count': len(mesh_devices),
            'devices': mesh_devices,
            'controller_count': sum(1 for d in mesh_devices if d['role'] == 'CONTROLLER'),
            'satellite_count': sum(1 for d in mesh_devices if d['role'] == 'SATELLITE')
        }

    def get_object_instances(self, base_path):
        """Get all instances of an object"""
        instances = []
        idx = 0
        while True:
            test_path = f"{base_path}.{idx}"
            if test_path in self.device_tree:
                instances.append(test_path)
                idx += 1
            else:
                break
        return instances

    def get_param(self, path):
        """Get parameter value from device tree"""
        return self.device_tree.get(path)

    def build_parameter_tree(self):
        """Build hierarchical parameter tree from flat parameters"""
        # Implementation depends on parameter format (CSV, JSON, etc.)
        # See ParameterTreeBuilder.java for reference
        pass


# Usage example
if __name__ == "__main__":
    # Device parameters from MQTT or HTTP
    device_params = {
        "Device.WiFi.DataElements.Network.Device.0.ID": "AA:BB:CC:DD:EE:01",
        "Device.WiFi.DataElements.Network.Device.0.BackhaulMediaType": "None",
        "Device.WiFi.DataElements.Network.Device.1.ID": "AA:BB:CC:DD:EE:02",
        "Device.WiFi.DataElements.Network.Device.1.BackhaulMediaType": "Wi-Fi",
        "Device.WiFi.DataElements.Network.Device.1.BackhaulMACAddress": "AA:BB:CC:DD:EE:01"
    }

    detector = MeshDetector(device_params)
    result = detector.detect_mesh()

    if result['detected']:
        print(f"✓ Mesh Network Detected!")
        print(f"  Type: {result['mesh_type']} ({result['standard']})")
        print(f"  Devices: {result['device_count']} total")
        print(f"    - Controllers: {result['controller_count']}")
        print(f"    - Satellites: {result['satellite_count']}")
    else:
        print(f"✗ No Mesh Detected")
        print(f"  Reason: {result['reason']}")
        if result.get('mesh_capable'):
            print(f"  Note: Device is mesh-capable but not configured")