lf_webpage.py

#!/usr/bin/env python3
"""
NAME: lf_webpage.py

PURPOSE:
lf_webpage.py will verify that N clients are connected on a specified band and can download
some amount of file data from the HTTP server while measuring the time taken by clients to download the file and number of
times the file is downloaded.

EXAMPLE-1:
Command Line Interface to run download scenario for Real clients
python3 lf_webpage.py --ap_name "Cisco" --mgr 192.168.200.165 --ssid Cisco-5g --security wpa2 --passwd sharedsecret
--upstream_port eth1 --duration 10m --bands 5G --client_type Real --file_size 2MB

EXAMPLE-2:
Command Line Interface to run download scenario on 5GHz band for Virtual clients
python3 lf_webpage.py --ap_name "Cisco" --mgr 192.168.200.165 --fiveg_ssid Cisco-5g --fiveg_security wpa2 --fiveg_passwd sharedsecret
--fiveg_radio wiphy0 --upstream_port eth1 --duration 1h --bands 5G --client_type Virtual --file_size 2MB --num_stations 3

EXAMPLE-3:
Command Line Interface to run download scenario on 2.4GHz band for Virtual clients
python3 lf_webpage.py --ap_name "Cisco" --mgr 192.168.200.165 --twog_ssid Cisco-2g --twog_security wpa2 --twog_passwd sharedsecret
--twog_radio wiphy0 --upstream_port eth1 --duration 1h --bands 2.4G --client_type Virtual --file_size 2MB --num_stations 3

EXAMPLE-4:
Command Line Interface to run download scenario on 6GHz band for Virtual clients
python3 lf_webpage.py --ap_name "Cisco" --mgr 192.168.200.165 --sixg_ssid Cisco-6g --sixg_security wpa3 --sixg_passwd sharedsecret
--sixg_radio wiphy0 --upstream_port eth1 --duration 1h --bands 6G --client_type Virtual --file_size 2MB --num_stations 3

EXAMPLE-5:
Command Line Interface to run download scenario for Real clients with device list
python3 lf_webpage.py --ap_name "Cisco" --mgr 192.168.214.219 --ssid Cisco-5g --security wpa2 --passwd sharedsecret  --upstream_port eth1
--duration 1m --bands 5G --client_type Real --file_size 2MB --device_list 1.12,1.22

EXAMPLE-6:
Command Line Interface to run download scenario for Real clients with device list and Expected Pass/Fail CSV
python3 lf_webpage.py  --file_size 1MB --mgr 192.168.213.218 --duration 1m --client_type Real --bands 5G --upstream_port eth1 --device_list 1.11,1.95 --device_csv_name test.csv

EXAMPLE-7:
Command Line Interface to run download scenario for Real clients with device list and expected passfail value
python3 lf_webpage.py  --file_size 1MB --mgr 192.168.204.74 --duration 1m --client_type Real --bands 5G --upstream_port eth1 --device_list 1.11,1.95 --expected_passfail_value 5

EXAMPLE-8:
Command Line Interface to run download scenario for Real clients with Groups and Profiles
python3 lf_webpage.py  --file_size 1MB --mgr 192.168.213.218 --duration 1m --client_type Real --bands 5G --upstream_port eth1 --file_name grp218 --group_name laptops --profile_name Opensd

EXAMPLE-9:
Command Line Interface to run download scenario for Real clients with device list and config
python3 lf_webpage.py --file_size 1MB --mgr 192.168.244.97 --duration 1m --client_type Real --bands 5G --upstream_port eth1 --ssid
xiab_2G_WPA2 --passwd lanforge --security wpa2 --device_list 1.160,1.146,1.13,1.20 --config

EXAMPLE-10:
Command Line Interface to run the Test along with IOT without device list
python3 lf_webpage.py --ap_name "Cisco" --mgr 192.168.207.78 --ssid Cisco-5g --security wpa2 --passwd sharedsecret --upstream_port eth1
--duration 1m --bands 5G --client_type Real --file_size 2MB --iot_test --iot_testname "httpiot"

EXAMPLE-11:
Command Line Interface to run the Test along with IOT with device list
python3 lf_webpage.py --ap_name "Cisco" --mgr 192.168.207.78 --ssid Cisco-5g --security wpa2 --passwd sharedsecret --upstream_port eth1
--duration 1m --bands 5G --client_type Real --file_size 2MB --iot_test --iot_testname "httpiot" --iot_device_list "switch.smart_plug_1_socket_1"

EXAMPLE-12:
Command Line Interface to run download scenario for Real clients with Robot with only coordinates
python3 lf_webpage.py --ap_name "Netgear" --mgr 192.168.204.78 --ssid NETGEAR_2G_wpa2 --security wpa2 --passwd Password@123
--upstream_port eth1 --duration 10m --bands 5G --client_type Real --file_size 2MB --robot_ip 192.168.204.101 --coordinate 3,4 --robot_test

EXAMPLE-13:
Command Line Interface to run download scenario for Real clients with Robot with coordinates and rotations
python3 lf_webpage.py --ap_name "Netgear" --mgr 192.168.204.78 --ssid NETGEAR_2G_wpa2 --security wpa2 --passwd Password@123
--upstream_port eth1 --duration 10m --bands 5G --client_type Real --file_size 2MB --robot_ip 192.168.204.101 --coordinate 3,4 --rotation 30,45 --robot_test

EXAMPLE-14:
Command Line Interface to run download scenario for Real clients with Robot with coordinates and band steering enabled
python3 lf_webpage.py --ap_name "Netgear" --mgr 192.168.204.75 --ssid NETGEAR_2G_wpa2 --security wpa2 --passwd Password@123 --upstream_port eth1
--duration 1m --bands 5G --client_type Real --file_size 2MB --robot_test --coordinate 3,4 --robot_ip 192.168.204.101 --do_bandsteering --cycles 1 --bssids 7a:1d:35:c8:da:b9

SCRIPT_CLASSIFICATION : Test

SCRIPT_CATEGORIES:   Performance,  Functional,  Report Generation

NOTES:
1.Please enter the duration in s,m,h (seconds or minutes or hours).Eg: 30s,5m,48h.
2.After passing cli, a list will be displayed on terminal which contains available resources to run test.
The following sentence will be displayed
Enter the desired resources to run the test:
Please enter the port numbers seperated by commas ','.
Example:
Enter the desired resources to run the test:1.10,1.11,1.12,1.13,1.202,1.203,1.303

STATUS : Functional

VERIFIED_ON:
26-JULY-2024,
GUI Version:  5.4.8
Kernel Version: 6.2.16+

LICENSE :
Copyright (C) 2020-2026 Candela Technologies Inc
Free to distribute and modify. LANforge systems must be licensed.

INCLUDE_IN_README: False
"""

# from lf_interop_qos import ThroughputQOS
import sys
import os
import importlib
import time
import argparse
import paramiko
from datetime import datetime, timedelta
import pandas as pd
import logging
import requests
import shutil
import json
from lf_graph import lf_bar_graph_horizontal, lf_bar_graph
import traceback
import threading
from collections import OrderedDict, Counter
import asyncio
from typing import List, Optional
import csv
from lf_base_robo import RobotClass

sys.path.append(os.path.join(os.path.abspath(__file__ + "../../../")))

LFUtils = importlib.import_module("py-json.LANforge.LFUtils")
lfcli_base = importlib.import_module("py-json.LANforge.lfcli_base")
LFCliBase = lfcli_base.LFCliBase
realm = importlib.import_module("py-json.realm")
Realm = realm.Realm
PortUtils = realm.PortUtils
lf_report = importlib.import_module("py-scripts.lf_report")
lf_graph = importlib.import_module("py-scripts.lf_graph")
lf_kpi_csv = importlib.import_module("py-scripts.lf_kpi_csv")
lf_logger_config = importlib.import_module("py-scripts.lf_logger_config")
DeviceConfig = importlib.import_module("py-scripts.DeviceConfig")

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)


iot_scripts_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../local/interop-webGUI/IoT/scripts/"))
if os.path.exists(iot_scripts_path):
    sys.path.insert(0, iot_scripts_path)
    from test_automation import Automation  # noqa: E402


class HttpDownload(Realm):
    def __init__(self, lfclient_host, lfclient_port, upstream, num_sta, security, ssid, password, ap_name,
                 target_per_ten, file_size, bands, start_id=0, twog_radio=None, fiveg_radio=None, sixg_radio=None, _debug_on=False, _exit_on_error=False,
                 test_name=None, _exit_on_fail=False, client_type="", port_list=None, devices_list=None, macid_list=None, lf_username="lanforge", lf_password="lanforge", result_dir="", dowebgui=False,
                 device_list=None, get_url_from_file=None, file_path=None, device_csv_name='', expected_passfail_value=None, file_name=None, group_name=None, profile_name=None, eap_method=None,
                 eap_identity=None, ieee80211=None, ieee80211u=None, ieee80211w=None, enable_pkc=None, bss_transition=None, power_save=None, disable_ofdma=None, roam_ft_ds=None, key_management=None,
                 pairwise=None, private_key=None, ca_cert=None, client_cert=None, pk_passwd=None, pac_file=None, config=False, wait_time=60, get_live_view=False, total_floors=0, robot_test=False,
                 robot_ip=None, coordinate=None, rotation=None, duration=None, do_bandsteering=False, cycles=None, bssids=None, duration_to_skip=None):
        # super().__init__(lfclient_host=lfclient_host,
        #                  lfclient_port=lfclient_port)
        self.ssid_list = []
        self.devices = []
        self.mode_list = []
        self.channel_list = []
        self.host = lfclient_host
        self.port = lfclient_port
        self.upstream = upstream
        self.num_sta = num_sta
        self.security = security
        self.ssid = ssid
        self.sta_start_id = start_id
        self.password = password
        self.twog_radio = twog_radio
        self.fiveg_radio = fiveg_radio
        self.sixg_radio = sixg_radio
        self.target_per_ten = target_per_ten
        self.file_size = file_size
        self.bands = bands
        self.debug = _debug_on
        self.port_list = port_list
        self.result_dir = result_dir
        self.test_name = test_name
        self.dowebgui = dowebgui
        self.device_list = device_list
        self.eid_list = []
        self.devices_list = devices_list
        self.macid_list = []
        self.client_type = client_type
        self.lf_username = lf_username
        self.lf_password = lf_password
        self.ap_name = ap_name
        self.windows_ports = []
        self.windows_eids = []
        self.local_realm = realm.Realm(lfclient_host=self.host, lfclient_port=self.port)
        self.station_profile = self.local_realm.new_station_profile()
        self.http_profile = self.local_realm.new_http_profile()
        self.http_profile.requests_per_ten = self.target_per_ten
        # self.http_profile.url = self.url
        self.port_util = PortUtils(self.local_realm)
        self.http_profile.debug = _debug_on
        self.created_cx = {}
        self.station_list = []
        self.radio = []
        self.failed_cx = []
        self.tracking_map = {}
        self.get_url_from_file = get_url_from_file
        self.file_path = file_path
        self.file_name = file_name
        self.group_name = group_name
        self.profile_name = profile_name
        # for advanced config
        self.eap_method = eap_method
        self.eap_identity = eap_identity
        self.ieee80211 = ieee80211
        self.ieee80211u = ieee80211u
        self.ieee80211w = ieee80211w
        self.enable_pkc = enable_pkc
        self.bss_transition = bss_transition
        self.power_save = power_save
        self.disable_ofdma = disable_ofdma
        self.roam_ft_ds = roam_ft_ds
        self.key_management = key_management
        self.pairwise = pairwise
        self.private_key = private_key
        self.ca_cert = ca_cert
        self.client_cert = client_cert
        self.pk_passwd = pk_passwd
        self.pac_file = pac_file
        self.expected_passfail_value = expected_passfail_value
        self.device_csv_name = device_csv_name
        self.wait_time = wait_time
        self.config = config
        self.api_url = 'http://{}:{}'.format(self.host, self.port)
        self.group_device_map = {}
        self.individual_device_csv_names = []
        self.get_live_view = get_live_view
        self.duration = duration
        self.total_floors = total_floors
        # Robot Automation parameters
        self.robot_test = robot_test
        self.robot_ip = robot_ip
        self.coordinate = coordinate
        self.rotation = rotation
        self.rotation_enabled = False
        if self.robot_test:
            #  To consider coordinates list and rotation list when running with robot
            self.coordinate_list = coordinate.split(',')
            self.rotation_list = rotation.split(',')
        self.current_coordinate = ""
        self.current_angle = 0
        self.robot_data = {}
        self.robot_obj = {}
        self.individual_device_data = {}
        self.rx_rate_val = []
        self.max_bytes_rd = []
        self.do_bandsteering = do_bandsteering
        self.cycles = cycles
        self.bssids = bssids.split(',') if bssids else []
        self.duration_to_skip = duration_to_skip

# The 'phantom_check' will be handled within the 'get_real_client_list' function
    def get_real_client_list(self):
        user_list = []
        real_client_list1 = []
        real_client_list2 = []
        android_list = []
        mac_list = []
        windows_list = []
        linux_list = []
        working_resources_list = []
        eid_list = []
        devices_available = []
        input_devices_list = []
        mac_id_list1 = []
        mac_id_list2 = []
        port_eid_list = []
        same_eid_list = []
        original_port_list = []
        device_found = False
        obj = DeviceConfig.DeviceConfig(lanforge_ip=self.host, file_name=self.file_name, wait_time=self.wait_time)
        config_devices = {}
        # upstream port IP for configuration
        upstream_port_ip = self.change_port_to_ip(self.upstream)
        config_dict = {
            'ssid': self.ssid,
            'passwd': self.password,
            'enc': self.security,
            'eap_method': self.eap_method,
            'eap_identity': self.eap_identity,
            'ieee80211': self.ieee80211,
            'ieee80211u': self.ieee80211u,
            'ieee80211w': self.ieee80211w,
            'enable_pkc': self.enable_pkc,
            'bss_transition': self.bss_transition,
            'power_save': self.power_save,
            'disable_ofdma': self.disable_ofdma,
            'roam_ft_ds': self.roam_ft_ds,
            'key_management': self.key_management,
            'pairwise': self.pairwise,
            'private_key': self.private_key,
            'ca_cert': self.ca_cert,
            'client_cert': self.client_cert,
            'pk_passwd': self.pk_passwd,
            'pac_file': self.pac_file,
            'server_ip': upstream_port_ip,
        }
        # When groups and profiles specified for configuration
        if self.group_name and self.file_name and self.device_list == [] and self.profile_name:
            selected_groups = self.group_name.split(',')
            selected_profiles = self.profile_name.split(',')
            if len(selected_groups) == len(selected_profiles):
                for i in range(len(selected_groups)):
                    config_devices[selected_groups[i]] = selected_profiles[i]
            obj.initiate_group()
            self.group_device_map = obj.get_groups_devices(data=selected_groups, groupdevmap=True)
            # Configuration of group of devices for the corresponding profiles
            self.device_list = asyncio.run(obj.connectivity(config_devices, upstream=upstream_port_ip))
            if len(self.device_list) == 0:
                devices_list = ""
        elif self.device_list != []:
            obj.get_all_devices()
            self.device_list = self.device_list.split(',')
            # Configuration of devices with SSID,Password and Security when device list is specified
            if self.config:
                self.device_list = asyncio.run(obj.connectivity(device_list=self.device_list, wifi_config=config_dict))

        elif self.device_list == [] and self.config:
            all_devices = obj.get_all_devices()
            device_list = []
            for device in all_devices:
                if device["type"] == 'laptop':
                    device_list.append(device["shelf"] + '.' + device["resource"] + " " + device["hostname"])
                else:
                    device_list.append(device["shelf"] + '.' + device["resource"] + " " + device["serial"])
            logger.info("Available devices: %s", device_list)
            self.device_list = input("Enter the desired resources to run the test:").split(',')
            # Configuration of devices with SSID , Password and Security when the device list is not specified
            if self.config:
                self.device_list = asyncio.run(obj.connectivity(device_list=self.device_list, wifi_config=config_dict))

        response = self.local_realm.json_get("/resource/all")
        for key, value in response.items():
            if key == "resources":
                for element in value:
                    for _, b in element.items():
                        if not b['phantom']:
                            working_resources_list.append(b["hw version"])
                            if "Win" in b['hw version']:
                                eid_list.append(b['eid'])
                                windows_list.append(b['hw version'])
                                # self.hostname_list.append(b['eid']+ " " +b['hostname'])
                                devices_available.append(b['eid'] + " " + 'Win' + " " + b['hostname'])
                            elif "Linux" in b['hw version']:
                                if ('ct' not in b['hostname']):
                                    if ('lf' not in b['hostname']):
                                        eid_list.append(b['eid'])
                                        linux_list.append(b['hw version'])
                                        # self.hostname_list.append(b['eid']+ " " +b['hostname'])
                                        devices_available.append(b['eid'] + " " + 'Lin' + " " + b['hostname'])
                            elif "Apple" in b['hw version']:
                                if b['kernel'] == '':
                                    continue
                                else:
                                    eid_list.append(b['eid'])
                                    mac_list.append(b['hw version'])
                                    # self.hostname_list.append(b['eid']+ " " +b['hostname'])
                                    devices_available.append(b['eid'] + " " + 'Mac' + " " + b['hostname'])
                            else:
                                eid_list.append(b['eid'])
                                android_list.append(b['hw version'])
                                # self.username_list.append(b['eid']+ " " +b['user'])
                                devices_available.append(b['eid'] + " " + 'android' + " " + b['user'])
        # print("hostname list :",self.hostname_list)
        # print("username list :", self.username_list)
        # print("Available resources in resource tab :", devices_available)
        # print("eid_list : ",eid_list)
        # All the available resources are fetched from resource mgr tab ----

        response_port = self.local_realm.json_get("/port/all")
        # print(response_port)
        for interface in response_port['interfaces']:
            for port, port_data in interface.items():
                if (not port_data['phantom'] and not port_data['down'] and port_data['parent dev'] == "wiphy0" and port_data['alias'] != 'p2p0'):
                    for id in eid_list:
                        if (id + '.' in port):
                            original_port_list.append(port)
                            port_eid_list.append(str(self.name_to_eid(port)[0]) + '.' + str(self.name_to_eid(port)[1]))
                            mac_id_list1.append(str(self.name_to_eid(port)[0]) + '.' + str(self.name_to_eid(port)[1]) + ' ' + port_data['mac'])
        # print("port eid list",port_eid_list)
        for i in range(len(eid_list)):
            for j in range(len(port_eid_list)):
                if eid_list[i] == port_eid_list[j]:
                    same_eid_list.append(eid_list[i])
        same_eid_list = [_eid + ' ' for _eid in same_eid_list]
        # print("same eid list",same_eid_list)
        # print("mac_id list",mac_id_list)
        # All the available ports from port manager are fetched from port manager tab ---
        for eid in same_eid_list:
            for device in devices_available:
                if eid in device:
                    logger.info("%s %s", eid, device)
                    user_list.append(device)
        if not self.config and len(self.device_list) == 0 and self.group_name is None:
            logger.info("AVAILABLE DEVICES TO RUN TEST : {}".format(user_list))
            self.device_list = input("Enter the desired resources to run the test:")
            self.device_list = self.filter_iOS_devices(self.device_list).split(',')
        # checking for the availability of slected devices to run test
        if len(self.device_list) != 0:
            devices_list = self.device_list
            available_list = []
            not_available = []
            for input_device in devices_list:
                found = False
                for device in user_list:
                    if input_device + " " in device:
                        available_list.append(input_device)
                        found = True
                        break
                if not found:
                    not_available.append(input_device)
                    logger.warning(input_device + " is not available to run test")
            if len(available_list) > 0:
                logger.info("Test is initiated on devices: {}".format(available_list))
                devices_list = ','.join(available_list)
                device_found = True
            else:
                devices_list = ""
                device_found = False
                logger.warning("Test can not be initiated on any selected devices")

        else:
            devices_list = ""

        if devices_list == "" or devices_list == ",":
            logger.error("Selected Devices are not available in the lanforge")
            exit(1)
        resource_eid_list = devices_list.split(',')
        logger.info("devices list {} {}".format(devices_list, resource_eid_list))
        resource_eid_list2 = [eid + ' ' for eid in resource_eid_list]
        resource_eid_list1 = [resource + '.' for resource in resource_eid_list]
        logger.info("resource eid list {} {}".format(resource_eid_list1, original_port_list))

        # User desired eids are fetched ---

        for eid in resource_eid_list1:
            for ports_m in original_port_list:
                if eid in ports_m:
                    input_devices_list.append(ports_m)
        logger.info("INPUT DEVICES LIST {}".format(input_devices_list))

        # user desired real client list 1.1 wlan0 ---

        for i in resource_eid_list2:
            for j in range(len(user_list)):
                if i in user_list[j]:
                    real_client_list1.append(user_list[j])
                    real_client_list2.append((user_list[j])[:25])
        logger.info("REAL CLIENT LIST: %s", real_client_list1)

        self.num_sta = len(real_client_list1)

        for eid in resource_eid_list2:
            for i in mac_id_list1:
                if eid in i:
                    mac_id_list2.append(i.strip(eid + ' '))
        logger.info("MAC ID LIST: %s", mac_id_list2)
        self.port_list, self.devices_list, self.macid_list = input_devices_list, real_client_list1, mac_id_list2
        # user desired real client list 1.1 OnePlus, 1.1 Apple for report generation ---
    # Todo- Make use of lf_base_interop_profile.py : Real device class to fetch available devices data

        for port in self.port_list:
            eid = self.name_to_eid(port)
            self.eid_list.append(str(eid[0]) + '.' + str(eid[1]))
        for eid in self.eid_list:
            for device in self.devices_list:
                if ("Win" in device) and (eid + ' ' in device):
                    self.windows_eids.append(eid)

        for eid in self.windows_eids:
            for port in self.port_list:
                if eid + '.' in port:
                    self.windows_ports.append(port)
        if self.dowebgui == "True":
            if not device_found:
                print("No Device is available to run the test hence aborting the testllmlml")
                df1 = pd.DataFrame([{
                    "client": [],
                    "status": "Stopped",
                    "url_data": 0
                }]
                )
                df1.to_csv('{}/http_datavalues.csv'.format(self.result_dir), index=False)
                raise ValueError("Aborting the test....")
        return self.port_list, self.devices_list, self.macid_list, config_devices

    def api_get(self, endp: str):
        """
        Sends a GET request to fetch data

        Args:
            endp (str): API endpoint

        Returns:
            response: response code for the request
            data: data returned in the response
        """
        if endp[0] != '/':
            endp = '/' + endp
        response = requests.get(url=self.api_url + endp)
        data = response.json()
        return response, data

    def filter_iOS_devices(self, device_list):
        modified_device_list = device_list
        if type(device_list) is str:
            modified_device_list = device_list.split(',')
        filtered_list = []
        for device in modified_device_list:
            if device.count('.') == 1:
                shelf, resource = device.split('.')
            elif device.count('.') == 2:
                shelf, resource, port = device.split('.')
            elif device.count('.') == 0:
                shelf, resource = 1, device
            response_code, device_data = self.api_get('/resource/{}/{}'.format(shelf, resource))
            if 'status' in device_data and device_data['status'] == 'NOT_FOUND':
                logger.info("Device %s is not found.", device)
                continue
            device_data = device_data['resource']
            # print(device_data)
            if 'Apple' in device_data['hw version'] and (device_data['app-id'] != '') and (device_data['app-id'] != '0' or device_data['kernel'] == ''):
                logger.info("%s is an iOS device. Currently, we do not support iOS devices.", device)
            else:
                filtered_list.append(device)
        if type(device_list) is str:
            filtered_list = ','.join(filtered_list)
        self.device_list = filtered_list
        return filtered_list

    def set_values(self):
        # This method will set values according user input
        if self.bands == "5G":
            self.radio = [self.fiveg_radio]
            self.station_list = [LFUtils.portNameSeries(prefix_="http_sta", start_id_=self.sta_start_id,
                                                        end_id_=self.num_sta - 1, padding_number_=10000,
                                                        radio=self.fiveg_radio)]
        elif self.bands == "6G":
            self.radio = [self.sixg_radio]
            self.station_list = [LFUtils.portNameSeries(prefix_="http_sta", start_id_=self.sta_start_id,
                                                        end_id_=self.num_sta - 1, padding_number_=10000,
                                                        radio=self.sixg_radio)]
        elif self.bands == "2.4G":
            self.radio = [self.twog_radio]
            self.station_list = [LFUtils.portNameSeries(prefix_="http_sta", start_id_=self.sta_start_id,
                                                        end_id_=self.num_sta - 1, padding_number_=10000,
                                                        radio=self.twog_radio)]
        elif self.bands == "Both":
            self.radio = [self.twog_radio, self.fiveg_radio]
            # self.num_sta = self.num_sta // 2
            self.station_list = [
                LFUtils.portNameSeries(prefix_="http_sta", start_id_=self.sta_start_id,
                                       end_id_=self.num_sta - 1, padding_number_=10000,
                                       radio=self.twog_radio),
                LFUtils.portNameSeries(prefix_="http_sta", start_id_=self.sta_start_id,
                                       end_id_=self.num_sta - 1, padding_number_=10000,
                                       radio=self.fiveg_radio)
            ]

    def precleanup(self):
        self.count = 0
        for rad in range(len(self.radio)):
            if self.radio[rad] == self.fiveg_radio:
                # select an mode
                self.station_profile.mode = 14
                self.count = self.count + 1
            elif self.radio[rad] == self.sixg_radio:
                # select an mode
                self.station_profile.mode = 15
                self.count = self.count + 1
            elif self.radio[rad] == self.twog_radio:
                # select an mode
                self.station_profile.mode = 13
                self.count = self.count + 1

            if self.count == 2:
                self.sta_start_id = self.num_sta
                self.num_sta = 2 * (self.num_sta)
                self.station_profile.mode = 10
                self.http_profile.cleanup()
                # cleanup station list which started sta_id 20
                self.station_profile.cleanup(self.station_list[rad], debug_=self.local_realm.debug)
                LFUtils.wait_until_ports_disappear(base_url=self.local_realm.lfclient_url,
                                                   port_list=self.station_list[rad],
                                                   debug=self.local_realm.debug)
                return
            # clean dlayer4 ftp traffic
            self.http_profile.cleanup()

            # cleans stations
            self.station_profile.cleanup(self.station_list[rad], delay=1, debug_=self.local_realm.debug)
            LFUtils.wait_until_ports_disappear(base_url=self.local_realm.lfclient_url,
                                               port_list=self.station_list[rad],
                                               debug=self.local_realm.debug)
            time.sleep(1)
        print("precleanup done")

    def build(self):
        # enable http on ethernet
        self.port_util.set_http(port_name=self.local_realm.name_to_eid(self.upstream)[2],
                                resource=self.local_realm.name_to_eid(self.upstream)[1], on=True)
        if self.client_type == "Virtual":
            if self.bands == "2.4G":
                self.station_profile.mode = 13
            elif self.bands == "5G":
                self.station_profile.mode = 14
            elif self.bands == "6G":
                self.station_profile.mode = 15
            for rad in range(len(self.radio)):
                self.station_profile.use_security(self.security[rad], self.ssid[rad], self.password[rad])
                self.station_profile.set_command_flag("add_sta", "create_admin_down", 1)
                self.station_profile.set_command_param("set_port", "report_timer", 1500)
                self.station_profile.set_command_flag("set_port", "rpt_timer", 1)
                self.station_profile.create(radio=self.radio[rad], sta_names_=self.station_list[rad], debug=self.local_realm.debug)
                self.local_realm.wait_until_ports_appear(sta_list=self.station_list[rad])
                self.station_profile.admin_up()
                if self.local_realm.wait_for_ip(self.station_list[rad], timeout_sec=60):
                    self.local_realm._pass("All stations got IPs")
                else:
                    self.local_realm._fail("Stations failed to get IPs")
                # building layer4
                self.http_profile.direction = 'dl'
                self.http_profile.dest = '/dev/null'
                data = self.local_realm.json_get("ports/list?fields=IP")

                # getting eth ip
                eid = self.local_realm.name_to_eid(self.upstream)
                for i in data["interfaces"]:
                    for j in i:
                        if "{shelf}.{resource}.{port}".format(shelf=eid[0], resource=eid[1], port=eid[2]) == j:
                            ip_upstream = i["{shelf}.{resource}.{port}".format(
                                shelf=eid[0], resource=eid[1], port=eid[2])]['ip']

                # create http profile
                if self.get_url_from_file:  # enabling the GET-URL-FROM-FILE flag if its ture
                    self.http_profile.create(ports=self.station_profile.station_names, sleep_time=.5,
                                             suppress_related_commands_=None, http=True, user=self.lf_username,
                                             passwd=self.lf_password, http_ip=self.file_path, proxy_auth_type=0x200,
                                             timeout=1000, get_url_from_file=True)
                else:
                    self.http_profile.create(ports=self.station_profile.station_names, sleep_time=.5,
                                             suppress_related_commands_=None, http=True, user=self.lf_username,
                                             passwd=self.lf_password, http_ip=ip_upstream + "/webpage.html",
                                             proxy_auth_type=0x200, timeout=1000)
                if self.count == 2:
                    self.station_profile.mode = 6
        else:
            if self.client_type == "Real":
                self.http_profile.direction = 'dl'
                data = self.local_realm.json_get("ports/list?fields=IP")

                # getting eth ip
                eid = self.local_realm.name_to_eid(self.upstream)
                for i in data["interfaces"]:
                    for j in i:
                        if "{shelf}.{resource}.{port}".format(shelf=eid[0], resource=eid[1], port=eid[2]) == j:
                            ip_upstream = i["{shelf}.{resource}.{port}".format(
                                shelf=eid[0], resource=eid[1], port=eid[2])]['ip']

                self.http_profile.create(ports=self.port_list, sleep_time=.5,
                                         suppress_related_commands_=None, http=True, interop=True,
                                         user=self.lf_username, passwd=self.lf_password,
                                         http_ip=ip_upstream + "/webpage.html", proxy_auth_type=0x200, timeout=1000, windows_list=self.windows_ports)

        print("Test Build done")

    def start(self):
        self.http_profile.start_cx()
        try:
            for i in self.http_profile.created_cx.keys():
                while self.local_realm.json_get("/cx/" + i).get(i).get('state') != 'Run':
                    continue
        except Exception:
            # TODO: Handle exception
            pass

    def stop(self):
        self.http_profile.stop_cx()
        # To update status of devices and remaining_time in ftp_datavalues.csv file to stopped and 0 respectively.
        if self.client_type == 'Real':
            if not self.robot_test:
                self.data["status"] = ["STOPPED"] * len(self.macid_list)
            self.data["remaining_time"] = ["0"] * len(self.macid_list)
            df1 = pd.DataFrame(self.data)
            df1.to_csv("http_datavalues.csv", index=False)
            if not self.do_bandsteering and self.robot_test:
                # For Robot test, save data for each coordinate and rotation
                if self.rotation_enabled:
                    self.robot_data.setdefault(self.current_coordinate, {})[self.current_angle] = self.data
                else:
                    self.robot_data[self.current_coordinate] = self.data
                if self.dowebgui:
                    df1.to_csv(f"{self.result_dir}/{self.current_coordinate}_http_datavalues.csv", index=False)
                else:
                    df1.to_csv(f"{self.current_coordinate}_http_datavalues.csv", index=False)

    def update_stop_status_robot(self):
        # To update status of devices in csv file to stopped.
        self.data["status"] = ["STOPPED"] * len(self.macid_list)
        df1 = pd.DataFrame(self.data)
        df1.to_csv("http_datavalues.csv", index=False)
        if self.dowebgui:
            df1.to_csv(f"{self.result_dir}/{self.current_coordinate}_http_datavalues.csv", index=False)
        else:
            df1.to_csv(f"{self.current_coordinate}_http_datavalues.csv", index=False)

    def get_layer4_data(self):
        """
        Fetch Layer 4 stats (uc-avg, uc-min, uc-max, urls, rx rate, bytes read, errors)
        for all connections in self.cx_list.
        Returns:
            dict: mapping of metric names to lists of values, one per CX.
        """
        cx_list = list(self.http_profile.created_cx.keys())
        try:
            url_str = 'layer4/{}/list?fields=uc-avg,uc-max,uc-min,total-urls,rx rate (1m),bytes-rd,total-err'.format(','.join(cx_list))
            l4_data = self.local_realm.json_get(url_str)['endpoint']
        except Exception:
            logger.error("l4 DATA not found")
            exit(1)
        l4_dict = {
            'uc_avg_data': [],
            'uc_max_data': [],
            'uc_min_data': [],
            'url_times': [],
            'rx_rate': [],
            'bytes_rd': [],
            'total_err': []
        }
        if not isinstance(l4_data, list):
            l4_data = [{l4_data['name']: l4_data}]
        idx = 0
        for cx in cx_list:
            cx_found = False
            for i in l4_data:
                for cx_name, value in i.items():
                    if cx == cx_name:
                        l4_dict['uc_avg_data'].append(value['uc-avg'])
                        l4_dict['uc_max_data'].append(value['uc-max'])
                        l4_dict['uc_min_data'].append(value['uc-min'])
                        l4_dict['url_times'].append(value['total-urls'])
                        l4_dict['rx_rate'].append(value['rx rate (1m)'])
                        l4_dict['bytes_rd'].append(value['bytes-rd'])
                        l4_dict['total_err'].append(value['total-err'])
                        cx_found = True
            if not cx_found:
                self.failed_cx.append(cx)
                l4_dict['uc_avg_data'].append(0 if not self.tracking_map else self.tracking_map['uc_avg_data'][idx])
                l4_dict['uc_max_data'].append(0 if not self.tracking_map else self.tracking_map['uc_max_data'][idx])
                l4_dict['uc_min_data'].append(0 if not self.tracking_map else self.tracking_map['uc_min_data'][idx])
                l4_dict['url_times'].append(0 if not self.tracking_map else self.tracking_map['url_times'][idx])
                l4_dict['rx_rate'].append(0 if not self.tracking_map else self.tracking_map['rx_rate'][idx])
                l4_dict['bytes_rd'].append(0 if not self.tracking_map else self.tracking_map['bytes_rd'][idx])
                l4_dict['total_err'].append(0 if not self.tracking_map else self.tracking_map['total_err'][idx])
            idx += 1
        self.tracking_map = l4_dict.copy()

        return l4_dict

    def aggregate_rx_bytes(self, rx_rate, bytes_rd):
        """
        Compute average RX rate and update max bytes read.

        - Calculate device-wise average RX rate considering the values from start of test (ignore zero values)
        - Store averaged RX rates in self.rx_rate (rounded to 4 decimals)
        - Convert RX rate from bps to Mbps
        - Update self.bytes_rd with maximum values observed so far

        Args:
            rx_rate_val (list of list): RX rate values per device over time
            max_bytes_rd (list): Previously recorded max bytes read

        Returns:
            rx_rate (list): Current averaged RX rates in Mbps
            bytes_rd (list): Current updated max bytes read
        """
        if len(self.max_bytes_rd) == 0:
            self.max_bytes_rd = list(bytes_rd)
        for i in range(len(self.max_bytes_rd)):
            bytes_rd[i] = max(self.max_bytes_rd[i], bytes_rd[i])
        self.max_bytes_rd = list(bytes_rd)
        self.rx_rate_val.append(list(rx_rate))
        # taking average of rx-rate from the previous and current in the first row
        for j in range(len(self.rx_rate_val[0])):
            rx_rate_sum = 0
            non_zero = 0
            for i in range(len(self.rx_rate_val)):
                if self.rx_rate_val[i][j] != 0:
                    rx_rate_sum += self.rx_rate_val[i][j]
                    non_zero += 1
            rx_rate_avg = rx_rate_sum / non_zero if non_zero > 0 else 0  # updating each device's rx rate average in 1st row
            rx_rate[j] = round(rx_rate_avg, 4)
        return list(rx_rate), list(bytes_rd)

    def monitor_for_runtime_csv(self, duration):

        time_now = datetime.now()
        starttime = time_now.strftime("%d/%m %I:%M:%S %p")
        # duration = self.traffic_duration
        endtime = time_now + timedelta(seconds=duration)
        end_time = endtime
        # endtime = endtime
        current_time = datetime.now()
        self.data = {}
        self.data["client"] = self.devices_list
        # self.data["url_data"] = []
        self.data_for_webui = {}
        self.data_for_webui["client"] = self.devices_list
        self.get_device_port_details()
        # Creating individual Dataframe for each device
        for port in self.port_list:
            # Added this check to handle multiple external monitor calls for band steering.
            # This is common to both cases and does not affect the current execution.
            # It simply ensures safe handling when the monitor is invoked from lf_base_robo.
            if port not in self.individual_device_data:
                columns = ['TIMESTAMP', 'Bytes-rd', 'total urls', 'download_rate', 'rx_rate', 'tx_rate', 'RSSI', 'BSSID', 'Channel']
                if self.do_bandsteering:
                    columns.append('From Coordinate')
                    columns.append('To Coordinate')
                    columns.append('Robot X')
                    columns.append('Robot Y')
                self.individual_device_data[port] = pd.DataFrame(columns=columns)
        test_stopped_by_user = False
        monitor_charge_time = current_time
        while (current_time < endtime):
            # If robot test mode is enabled, periodically check if a battery pause is needed
            if self.robot_test:
                # Check if enough time has passed to trigger a battery check (300 sec)
                if (datetime.now() - monitor_charge_time).total_seconds() >= 300:
                    pause_start = datetime.now()
                    # Wait for the robot to charge. Returns whether we paused and whether user aborted.
                    pause, test_stopped_by_user = self.robot_obj.wait_for_battery(stop=self.stop)
                    if test_stopped_by_user:
                        break
                    if pause:
                        # After charging, return to the last coordinate
                        reached, abort = self.robot_obj.move_to_coordinate(self.current_coordinate)
                        # If user stopped the test during movement
                        if abort:
                            test_stopped_by_user = True
                            break
                        if not reached:
                            # test_stopped_by_user = True
                            break
                        # Restore orientation if rotation is enabled
                        if self.rotation_enabled:
                            rotation_moni = self.robot_obj.rotate_angle(self.current_angle)
                            if not rotation_moni:
                                test_stopped_by_user = True
                                break
                        # restart traffic
                        self.start()
                        # Add pause duration to overall end time
                        pause_end = datetime.now()
                        charge_pause = pause_end - pause_start
                        endtime += charge_pause
                    # Reset battery-monitor timer
                    monitor_charge_time = datetime.now()

                    # IMPORTANT: Update loop time
                    current_time = datetime.now()

            # data in json format
            # data = self.json_get("layer4/list?fields=bytes-rd")
            # uc_avg_data = self.json_get("layer4/list?fields=uc-avg")
            # uc_max_data = self.json_get("layer4/list?fields=uc-max")
            # uc_min_data = self.json_get("layer4/list?fields=uc-min")
            # total_url_data = self.json_get("layer4/list?fields=total-urls")
            # bytes_rd = self.json_get("layer4/list?fields=bytes-rd")
            l4_dict = self.get_layer4_data()
            uc_avg_data = l4_dict['uc_avg_data']
            uc_max_data = l4_dict['uc_max_data']
            uc_min_data = l4_dict['uc_min_data']
            url_times = l4_dict['url_times']
            rx_rate = l4_dict['rx_rate']
            bytes_rd = l4_dict['bytes_rd']
            total_err = l4_dict['total_err']
            urls_downloaded = []
            for i in range(len(total_err)):
                urls_downloaded.append(url_times[i] - total_err[i])
            url_times = list(urls_downloaded)
            self.data["MAC"] = self.macid_list
            self.data["SSID"] = self.ssid_list
            self.data["Channel"] = self.channel_list
            self.data["Mode"] = self.mode_list
            rssi_list, tx_rate_list, rx_rate_list, bssid_list, channel_list = self.get_signal_and_link_speed_data()  # these data collected from port manager
            individual_rx_data = []
            individual_rx_data.extend([current_time])
            for i, port in enumerate(self.port_list):
                # logger.info(f"row data HTTP",row_data)

                try:
                    row_data = [current_time, bytes_rd[i], url_times[i], rx_rate[i], rx_rate_list[i], tx_rate_list[i], rssi_list[i], bssid_list[i], channel_list[i]]
                    if self.do_bandsteering:
                        robo_x, robo_y, from_coord, to_coord = self.robot_obj.get_robot_pose()
                        row_data.extend([from_coord, to_coord, robo_x, robo_y])
                    self.individual_device_data[port].loc[len(self.individual_device_data[port])] = row_data
                except Exception:
                    # Fail-safe: if any list index/key mismatch occurs while adding row_data,
                    # stop execution to avoid inconsistent results.
                    tb_str = traceback.format_exc()  # capture traceback as string
                    logger.error("An exception occurred:\n%s", tb_str)
                    exit(1)
            rx_rate, bytes_rd = self.aggregate_rx_bytes(rx_rate, bytes_rd)
            # dataset = [round(x / 1000000,4) for x in dataset] #converting bps to mbps

            if len(url_times) == len(self.devices_list):

                self.data["status"] = ["RUNNING"] * len(self.devices_list)
                self.data["url_data"] = url_times
                self.data["uc_min"] = uc_min_data
                self.data["uc_max"] = uc_max_data
                self.data["uc_avg"] = uc_avg_data
                self.data["bytes_rd"] = bytes_rd
                self.data["rx rate (1m)"] = rx_rate
                self.data["total_err"] = total_err
            else:
                self.data["status"] = ["RUNNING"] * len(self.devices_list)
                self.data["url_data"] = [0] * len(self.devices_list)
                self.data["uc_avg"] = [0] * len(self.devices_list)
                self.data["uc_max"] = [0] * len(self.devices_list)
                self.data["uc_min"] = [0] * len(self.devices_list)
                self.data["bytes_rd"] = [0] * len(self.devices_list)
                self.data["rx rate (1m)"] = [0] * len(self.devices_list)
                self.data["total_err"] = [0] * len(self.devices_list)
            time_difference = abs(end_time - datetime.now())
            total_hours = time_difference.total_seconds() / 3600
            remaining_minutes = (total_hours % 1) * 60
            self.data["start_time"] = [starttime] * len(self.devices_list)
            if self.robot_test:
                # To update end time at each interval
                end_time = endtime
            self.data["end_time"] = [end_time.strftime("%d/%m %I:%M:%S %p")] * len(self.devices_list)
            self.data["remaining_time"] = [[str(int(total_hours)) + " hr and " + str(
                int(remaining_minutes)) + " min" if int(total_hours) != 0 or int(remaining_minutes) != 0 else '<1 min'][
                0]] * len(self.devices_list)
            if self.robot_test and self.rotation_enabled:
                self.data["current_angle"] = [self.current_angle] * len(self.devices_list)
            try:
                df1 = pd.DataFrame(self.data)
            except Exception:
                tb_str = traceback.format_exc()  # capture traceback as string
                logger.error("An exception occurred:\n%s", tb_str)
                exit(1)
            if self.dowebgui:
                df1.to_csv('{}/http_datavalues.csv'.format(self.result_dir), index=False)
                if not self.do_bandsteering and self.robot_test:
                    df1.to_csv(f"{self.result_dir}/{self.current_coordinate}_http_datavalues.csv", index=False)
            elif self.client_type == 'Real':
                df1.to_csv("http_datavalues.csv", index=False)
                # IF ROBOT TEST PERFORMED
                if not self.do_bandsteering and self.robot_test:
                    # Save FTP data values for the current coordinate when in robot test
                    df1.to_csv(f"{self.current_coordinate}_http_datavalues.csv", index=False)
            # No sleep is added here for band steering, as we need to capture data every second.
            # The per-second sleep interval is already handled in lf_base_robo.
            if not self.do_bandsteering:
                time.sleep(5)
            if self.dowebgui == "True":
                with open(self.result_dir + "/../../Running_instances/{}_{}_running.json".format(self.host,
                                                                                                 self.test_name),
                          'r') as file:
                    data = json.load(file)
                    if data["status"] != "Running":
                        print('Test is stopped by the user')
                        self.data["end_time"] = [datetime.now().strftime("%d/%m %I:%M:%S %p")] * len(self.devices_list)
                        test_stopped_by_user = True
                        break

            current_time = datetime.now()
            # Reusing monitor logic for band steering, but only need one record per call,
            # so break after first iteration instead of running for full duration.
            if self.do_bandsteering:
                break
        individual_device_csv_names = []  # To store individial device csv names
        # Iterate over each port and its corresponding DataFrame in the dictionary Saving the DataFrame to CSV
        for port, df in self.individual_device_data.items():
            df.to_csv(f"{endtime}-http-{port}.csv", index=False)
            individual_device_csv_names.append(f'{endtime}-http-{port}')
        self.individual_device_csv_names = individual_device_csv_names.copy()
        try:
            all_l4_data = self.get_all_l4_data()
            df = pd.DataFrame(all_l4_data)
            df.to_csv("all_l4_data.csv", index=False)
        except Exception:
            logger.error("All l4 data not found")
        return test_stopped_by_user

    def get_all_l4_data(self):
        """
        Fetches the complete set of Layer-4 data and writes it to a dictionary
        Returns:
            dict: A dictionary mapping each Layer 4 field to a list of values in the order of CXs.
        """
        fields = [
            "name", "eid", "type", "status", "total-urls", "urls/s", "bytes-rd", "bytes-wr",
            "total-buffers", "total-rebuffers", "total-wait-time", "video-format-bitrate",
            "audio-format-bitrate", "frame-rate", "video-quality", "tx rate", "tx-rate-1m",
            "rx rate", "rx rate (1m)", "fb-min", "fb-avg", "fb-max", "uc-min", "uc-avg",
            "uc-max", "dns-min", "dns-avg", "dns-max", "total-err", "bad-proto", "bad-url",
            "rslv-p", "rslv-h", "!conn", "timeout", "nf (4xx)", "http-r", "http-p", "http-t",
            "acc. denied", "ftp-host", "ftp-stor", "ftp-port", "write", "read", "redir",
            "login-denied", "other-err", "elapsed", "rpt timer", "time-stamp"
        ]

        data = self.local_realm.json_get(f"layer4/list?fields={','.join(fields)}")

        result = {field: [] for field in fields}

        endpoint = data.get("endpoint", {})
        cx_list = self.http_profile.created_cx.keys()
        if isinstance(endpoint, dict):
            for field in fields:
                result[field].append(endpoint.get(field, None))
        else:
            for created_cx in cx_list:
                for cx in endpoint:
                    if created_cx in cx:
                        for field in fields:
                            result[field].append(cx[created_cx].get(field, None))
                        break

        if "bytes-rd" in result:
            result["bytes-rd"] = [
                float(f"{int(x) / 1_000_000:.4f}") if x is not None else None
                for x in result["bytes-rd"]
            ]

        return result

    def my_monitor(self, data_mon):
        # data in json format
        data = self.local_realm.json_get("layer4/%s/list?fields=%s" %
                                         (','.join(self.http_profile.created_cx.keys()), data_mon.replace(' ', '+')))
        # print(data)
        data1 = []
        try:
            data = data['endpoint']
            if self.client_type == "Real":
                self.num_sta = len(self.port_list)
            if self.num_sta == 1:
                data1.append(data[data_mon])
            else:
                for cx in self.http_profile.created_cx.keys():
                    for info in data:
                        if cx in info:
                            data1.append(info[cx][data_mon])
            return data1
        except Exception as e:
            total_data = self.local_realm.json_get("layer4/all")
            logger.error(f"no endpoint found: {e}")
            logger.error(total_data)

    def postcleanup(self):
        self.http_profile.cleanup()
        self.station_profile.cleanup()
        LFUtils.wait_until_ports_disappear(base_url=self.local_realm.lfclient_url, port_list=self.station_profile.station_names,
                                           debug=self.debug)

    def file_create(self, ssh_port):
        ip = self.host
        user = "root"
        pswd = "lanforge"
        port = ssh_port
        ssh = paramiko.SSHClient()  # creating shh client object we use this object to connect to router
        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())  # automatically adds the missing host key
        ssh.connect(ip, port=port, username=user, password=pswd, banner_timeout=600)
        cmd = '[ -f /usr/local/lanforge/nginx/html/webpage.html ] && echo "True" || echo "False"'
        stdin, stdout, stderr = ssh.exec_command(str(cmd))
        output = stdout.readlines()
        if output == ["True\n"]:
            cmd1 = "rm /usr/local/lanforge/nginx/html/webpage.html"
            stdin, stdout, stderr = ssh.exec_command(str(cmd1))
            output = stdout.readlines()
            time.sleep(10)
            cmd2 = "sudo fallocate -l " + self.file_size + " /usr/local/lanforge/nginx/html/webpage.html"
            stdin, stdout, stderr = ssh.exec_command(str(cmd2))
            print("File creation done", self.file_size)
            output = stdout.readlines()
        else:
            cmd2 = "sudo fallocate -l " + self.file_size + " /usr/local/lanforge/nginx/html/webpage.html"
            stdin, stdout, stderr = ssh.exec_command(str(cmd2))
            print("File creation done", self.file_size)
            output = stdout.readlines()
        ssh.close()
        time.sleep(1)
        return output

    def download_time_in_sec(self, result_data):
        self.result_data = result_data
        download_time = dict.fromkeys(result_data.keys())
        for i in download_time:
            try:
                download_time[i] = result_data[i]['dl_time']
            except Exception:
                download_time[i] = []
        print("dl_times: ", download_time)
        lst = []
        lst1 = []
        lst2 = []
        lst3 = []
        dwnld_time = dict.fromkeys(result_data.keys())
        dataset = []
        for i in download_time:
            if i == "6G":
                logger.info("download time[%d]: %s", i, download_time[i])
                for j in download_time[i]:
                    x = (j / 1000)
                    y = round(x, 1)
                    lst3.append(y)
                dwnld_time["6G"] = lst3
                dataset.append(dwnld_time["6G"])
            if i == "5G":
                logger.info("download time[%d]: %s", i, download_time[i])
                for j in download_time[i]:
                    x = (j / 1000)
                    y = round(x, 1)
                    lst.append(y)
                dwnld_time["5G"] = lst
                dataset.append(dwnld_time["5G"])
            if i == "2.4G":
                for j in download_time[i]:
                    x = (j / 1000)
                    y = round(x, 1)
                    lst1.append(y)
                dwnld_time["2.4G"] = lst1
                dataset.append(dwnld_time["2.4G"])
            if i == "Both":
                # print("yes", download_time[i])
                for j in download_time[i]:
                    x = (j / 1000)
                    y = round(x, 1)
                    lst2.append(y)
                # print(lst2)
                dwnld_time["Both"] = lst2
                dataset.append(dwnld_time["Both"])
        return dataset

    def speed_in_Mbps(self, result_data):
        self.result_data = result_data
        speed = dict.fromkeys(result_data.keys())
        for i in speed:
            try:
                speed[i] = result_data[i]['speed']
            except Exception:
                speed[i] = []
        lst = []
        lst1 = []
        lst2 = []
        speed_ = dict.fromkeys(result_data.keys())
        dataset = []
        for i in speed:
            if i == "5G":
                for j in speed[i]:
                    x = (j / 1000000)
                    y = round(x, 1)
                    lst.append(y)
                speed_["5G"] = lst
                dataset.append(speed_["5G"])
            if i == "2.4G":
                for j in speed[i]:
                    x = (j / 1000000)
                    y = round(x, 1)
                    lst1.append(y)
                speed_["2.4G"] = lst1
                dataset.append(speed_["2.4G"])
            if i == "Both":
                # print("yes", speed[i])
                for j in speed[i]:
                    x = (j / 1000000)
                    y = round(x, 1)
                    lst2.append(y)
                speed_["Both"] = lst2
                dataset.append(speed_["Both"])
        return dataset

    def summary_calculation(self, result_data, bands, threshold_5g, threshold_2g, threshold_both):
        self.result_data = result_data

        avg_dl_time = []
        for fcc in list(result_data.keys()):
            fcc_type = result_data[fcc]["avg"]
            for i in fcc_type:
                avg_dl_time.append(i)

        avg_dl_time_per_thou = []
        for i in avg_dl_time:
            i = i / 1000
            avg_dl_time_per_thou.append(i)

        avg_time_rounded = []
        for i in avg_dl_time_per_thou:
            i = str(round(i, 1))
            avg_time_rounded.append(i)

        pass_fail_list = []
        sumry2 = []
        sumry5 = []
        sumryB = []
        data = []

        for band in range(len(bands)):
            if bands[band] == "2.4G":
                # 2.4G
                if float(avg_time_rounded[band]) == 0.0 or float(avg_time_rounded[band]) > float(threshold_2g):
                    var = "FAIL"
                    pass_fail_list.append(var)
                    sumry2.append("FAIL")
                elif float(avg_time_rounded[band]) < float(threshold_2g):
                    pass_fail_list.append("PASS")
                    sumry2.append("PASS")
                data.append(','.join(sumry2))

            elif bands[band] == "5G":
                # 5G
                if float(avg_time_rounded[band]) == 0.0 or float(avg_time_rounded[band]) > float(threshold_5g):
                    print("FAIL")
                    pass_fail_list.append("FAIL")
                    sumry5.append("FAIL")
                elif float(avg_time_rounded[band]) < float(threshold_5g):
                    print("PASS")
                    pass_fail_list.append("PASS")
                    sumry5.append("PASS")
                data.append(','.join(sumry5))

            elif bands[band] == "Both":
                # BOTH
                if float(avg_time_rounded[band]) == 0.0 or float(avg_time_rounded[band]) > float(threshold_both):
                    var = "FAIL"
                    pass_fail_list.append(var)
                    sumryB.append("FAIL")
                elif float(avg_time_rounded[band]) < float(threshold_both):
                    pass_fail_list.append("PASS")
                    sumryB.append("PASS")
                data.append(','.join(sumryB))

        return data

    def check_station_ip(self):
        pass

    def generate_graph(self, dataset, lis, bands, graph_image_name="ucg-avg_http"):
        bands = ['Download']
        if self.client_type == "Real":
            lis = self.devices_list
        elif self.client_type == "Virtual":
            lis = self.station_list[0]
        logger.info("%s %s", dataset, lis)
        x_fig_size = 18
        y_fig_size = len(lis) * .5 + 4
        # graph = lf_graph.lf_bar_graph(_data_set=dataset, _xaxis_name="Stations", _yaxis_name="Time in Seconds",
        #                               _xaxis_categories=lis, _label=bands, _xticks_font=8,
        #                               _graph_image_name="webpage download time graph",
        #                               _color=['forestgreen', 'darkorange', 'blueviolet'], _color_edge='black', _figsize=(14, 5),
        #                               _grp_title="Download time taken by each client", _xaxis_step=1, _show_bar_value=True,
        #                               _text_font=6, _text_rotation=60,
        #                               _legend_loc="upper right",
        #                               _legend_box=(1, 1.15),
        #                               _enable_csv=True
        #                               )
        graph = lf_bar_graph_horizontal(_data_set=[dataset], _xaxis_name="Average time taken to Download file in ms",
                                        _yaxis_name="Client names",
                                        _yaxis_categories=[i for i in lis],
                                        _yaxis_label=[i for i in lis],
                                        _yaxis_step=1,
                                        _yticks_font=8,
                                        _yticks_rotation=None,
                                        _graph_title="Average time taken to Download file",
                                        _title_size=16,
                                        _figsize=(x_fig_size, y_fig_size),
                                        _legend_loc="best",
                                        _legend_box=(1.0, 1.0),
                                        _color_name=['steelblue'],
                                        _show_bar_value=True,
                                        _enable_csv=True,
                                        _graph_image_name=graph_image_name, _color_edge=['black'],
                                        _color=['steelblue'],
                                        _label=bands)
        graph_png = graph.build_bar_graph_horizontal()
        print("graph name {}".format(graph_png))
        return graph_png

    def graph_2(self, dataset2, lis, bands, graph_name="Total-url_http"):
        bands = ['Download']
        if self.client_type == "Real":
            lis = self.devices_list
        elif self.client_type == "Virtual":
            lis = self.station_list[0]
        print(dataset2)
        print(lis)
        x_fig_size = 18
        y_fig_size = len(lis) * .5 + 4
        graph_2 = lf_bar_graph_horizontal(_data_set=[dataset2], _xaxis_name="No of times file Download",
                                          _yaxis_name="Client names",
                                          _yaxis_categories=[i for i in lis],
                                          _yaxis_label=[i for i in lis],
                                          _yaxis_step=1,
                                          _yticks_font=8,
                                          _yticks_rotation=None,
                                          _graph_title="No of times file Download (Count)",
                                          _title_size=16,
                                          _figsize=(x_fig_size, y_fig_size),
                                          _legend_loc="best",
                                          _legend_box=(1.0, 1.0),
                                          _color_name=['orange'],
                                          _show_bar_value=True,
                                          _enable_csv=True,
                                          _graph_image_name=graph_name, _color_edge=['black'],
                                          _color=['orange'],
                                          _label=bands)
        graph_png = graph_2.build_bar_graph_horizontal()
        return graph_png
    # This function is called to get details of devices during runtime

    def get_device_port_details(self):
        self.response_port = self.local_realm.json_get("/port/all")
        # Initialize lists to store channel, mode, and SSID information
        self.channel_list, self.mode_list, self.ssid_list = [], [], []
        if self.client_type == "Real":
            self.devices = self.devices_list
            for interface in self.response_port['interfaces']:
                for port, port_data in interface.items():
                    if port in self.port_list:
                        channel_value = str(port_data.get('channel', ''))
                        if channel_value in ('', '0', '-1'):
                            self.channel_list.append('NA')
                        else:
                            self.channel_list.append(channel_value)
                        self.mode_list.append(str(port_data['mode']))
                        self.ssid_list.append(str(port_data['ssid']))

    def add_live_view_images_to_report(self, report):
        for floor in range(0, int(self.total_floors)):
            http_img_path = os.path.join(self.result_dir, "live_view_images", f"http_{self.test_name}_{floor + 1}.png")
            timeout = 60  # seconds
            start_time = time.time()

            while not (os.path.exists(http_img_path)):
                if time.time() - start_time > timeout:
                    print("Timeout: Images not found within 60 seconds.")
                    break
                time.sleep(1)
            while not os.path.exists(http_img_path):
                if os.path.exists(http_img_path):
                    break
            if os.path.exists(http_img_path):
                report.set_custom_html('<div style="page-break-before: always;"></div>')
                report.build_custom()
                report.set_custom_html(f'<img style="width:1200px" src="file://{http_img_path}"></img>')
                report.build_custom()

    def get_bandsteering_stats(self, report):
        """
        Generate Band Steering statistics and report for each device.

        This function processes per-device connection data to:
        - Detect BSSID transitions (band steering events)
        - Count occurrences of each configured BSSID
        - Generate a bar graph showing BSSID change counts
        - Create a detailed table of band steering events (if any)

        Data Source:
            self.individual_device_data → {
                dev_name: pandas.DataFrame,
                ...
            }

        Expected DataFrame Columns:
            - timestamp
            - BSSID
            - Channel
            - from_coordinate
            - to_coordinate

        Behavior:
            - Only considers BSSID changes within the configured BSSID list (self.bssids)
            - Ignores consecutive duplicate BSSID entries
            - Skips table generation if no valid band steering events are found
            - Always generates a graph (even if counts are zero)

        Output:
            Adds bandstreering statistics to the report for each device, including:
            - Bar graph of BSSID change counts per device
            - Table of band steering transitions (if available)
        """

        data = self.individual_device_data

        for dev_name, df in data.items():

            if df.empty:
                continue

            rename_map = {
                "timestamp": "TIMESTAMP",
                "from_coordinate": "From Coordinate",
                "to_coordinate": "To Coordinate",
            }
            df = df.rename(columns=rename_map)

            allowed_bssids = set(self.bssids)
            # Create a mask to detect valid BSSID transitions:
            # - BSSID changes compared to previous row
            # - BSSID belongs to configured list
            mask = (
                (df["BSSID"] != df["BSSID"].shift()) &
                (df["BSSID"].isin(allowed_bssids))
            )

            skip_table = not mask.any()

            if skip_table:
                # Initialize all BSSID counts to zero if no events found
                bssid_counts = {bssid: 0 for bssid in self.bssids}
            else:
                bssid_list = df.loc[mask, "BSSID"].tolist()
                channel_list = df.loc[mask, "Channel"].tolist()
                timestamp_list = df.loc[mask, "TIMESTAMP"].tolist()

                bssid_counts = Counter(bssid_list)

            from_coordinate_list = (
                df.loc[mask, "From Coordinate"].tolist()
                if "From Coordinate" in df.columns and not skip_table else []
            )
            to_coordinate_list = (
                df.loc[mask, "To Coordinate"].tolist()
                if "To Coordinate" in df.columns and not skip_table else []
            )
            # Ensure all configured BSSIDs are present in final count (default = 0)
            final_bssid_counts = {
                bssid: bssid_counts.get(bssid, 0)
                for bssid in self.bssids
            }

            x_axis = list(final_bssid_counts.keys())
            y_axis = [[float(v)] for v in final_bssid_counts.values()]

            report.set_obj_html(
                _obj_title=f"BSSID Change Count Of The Client {dev_name}",
                _obj=" "
            )
            report.build_objective()

            graph = lf_bar_graph(
                _data_set=y_axis,
                _xaxis_name="BSSID",
                _yaxis_name="Number of Changes",
                _xaxis_categories=[""],
                _xaxis_label=x_axis,
                _graph_image_name=f"bssid_change_count_{dev_name}",
                _label=x_axis,
                _xaxis_step=1,
                _graph_title=f"BSSID change count for device : {dev_name}",
                _title_size=16,
                _bar_width=0.15,
                _figsize=(18, 6),
                _dpi=96,
                _show_bar_value=True,
                _enable_csv=True,
            )

            graph_png = graph.build_bar_graph()
            report.set_graph_image(graph_png)
            report.move_graph_image()
            report.set_csv_filename(graph_png)
            report.move_csv_file()
            report.build_graph()

            # If no band steering events, show informational message
            if skip_table:
                report.set_obj_html(
                    _obj_title=f"Band Steering Results for {dev_name}",
                    _obj="No band steering events observed for the configured BSSID list."
                )
                report.build_objective()
                continue

            report.set_obj_html(
                _obj_title=f"Band Steering Results for {dev_name}",
                _obj=" "
            )
            report.build_objective()

            table_df = pd.DataFrame({
                "Timestamp": timestamp_list,
                "BSSID": bssid_list,
                "Channel": channel_list,
                "From Coordinate": from_coordinate_list,
                "To Coordinate": to_coordinate_list
            })

            report.set_table_dataframe(table_df)
            report.build_table()

    def generate_report(self, date, num_stations, duration, test_setup_info, dataset, lis, bands, threshold_2g,
                        threshold_5g, threshold_both, dataset2, dataset1,  # summary_table_value,
                        result_data, test_rig, rx_rate,
                        test_tag, dut_hw_version, dut_sw_version, dut_model_num, dut_serial_num, test_id,
                        test_input_infor, csv_outfile, _results_dir_name='webpage_test', report_path='', iot_summary=None):
        if self.dowebgui == "True" and report_path == '':
            report = lf_report.lf_report(_results_dir_name="webpage_test", _output_html="Webpage.html",
                                         _output_pdf="Webpage.pdf", _path=self.result_dir)
        else:
            report = lf_report.lf_report(_results_dir_name="webpage_test", _output_html="Webpage.html",
                                         _output_pdf="Webpage.pdf", _path=report_path)

        # To store http_datavalues.csv in report folder
        report_path_date_time = report.get_path_date_time()
        # It ensures no blocker for virtual clients
        if self.client_type == 'Real':
            shutil.move('http_datavalues.csv', report_path_date_time)
            try:
                shutil.move('all_l4_data.csv', report_path_date_time)
            except Exception:
                logging.info("failed to generate all l4 data csv")
            # Moving indiviudal csv's to report directory
            for csv_name in self.individual_device_csv_names:
                shutil.move(f"{csv_name}.csv", report_path_date_time)
        if bands == "Both":
            num_stations = num_stations * 2
        report.set_title("HTTP TEST Including IoT Devices" if iot_summary else "HTTP DOWNLOAD TEST")
        report.set_date(date)
        report.build_banner()
        report.set_table_title("Test Setup Information")
        report.build_table_title()
        if self.robot_test:
            # If robot test, add robot specific info to test setup
            test_setup_info["Robot IP"] = self.robot_ip
            test_setup_info["Coordinates"] = self.coordinate
            if not self.do_bandsteering:
                test_setup_info["Rotation"] = self.rotation
            else:
                del test_setup_info["Traffic Duration "]
                test_setup_info["No of Cycles"] = self.cycles
        if iot_summary:
            test_setup_info = with_iot_params_in_table(test_setup_info, iot_summary)
            report.set_obj_html(
                "Objective",
                "The Candela HTTP Test Including IoT Devices is designed to verify an Access Point’s performance and "
                "stability when handling both Real clients (Android, Windows, Linux, iOS) and IoT devices (controlled via "
                "Home Assistant). For Real clients, the test measures simultaneous file downloads over a specified band "
                "from an HTTP server, capturing metrics such as transfer time and throughput to validate that the AP can "
                "support multiple clients efficiently. For IoT clients, the test concurrently executes device-specific "
                "actions (e.g., camera streaming, switch toggling, lock/unlock) and monitors success rate, latency, and "
                "failure rate. The goal is to ensure that the AP can reliably manage HTTP traffic for multiple Real "
                "clients while maintaining responsive and consistent control of IoT devices."
            )
        else:
            report.set_obj_html("Objective", "The HTTP Download Test is designed to verify that N clients connected on specified band can "
                                "download some amount of file from HTTP server and measures the "
                                "time taken by the client to Download the file.")

        report.test_setup_table(value="Test Setup Information", test_setup_data=test_setup_info)

        report.build_objective()
        if not self.do_bandsteering and self.robot_test:
            if self.dowebgui and self.get_live_view:
                # Add live view images to the report
                self.add_live_view_images_to_report(report)
            if self.rotation_enabled:
                for coord, rotation_dict in self.robot_data.items():
                    for rotation, _ in rotation_dict.items():
                        # Build graphs and table for each coordinate and rotation
                        self.build_graphs_and_table(coord, rotation, report, lis, bands)
            else:
                for coord, _ in self.robot_data.items():
                    # Build graphs and table for each coordinate
                    self.build_graphs_and_table(coord, "", report, lis, bands)
            report.build_footer()
            html_file = report.write_html()
            report.write_pdf()
            return
        if self.do_bandsteering:
            self.get_bandsteering_stats(report)
        report.set_obj_html("No of times file Downloads", "The below graph represents number of times a file downloads for each client"
                            ". X- axis shows “No of times file downloads and Y-axis shows "
                            "Client names.")
        report.build_objective()
        graph2 = self.graph_2(dataset2, lis=lis, bands=bands)
        print("graph name {}".format(graph2))
        report.set_graph_image(graph2)
        report.set_csv_filename(graph2)
        report.move_csv_file()
        report.move_graph_image()
        report.build_graph()
        report.set_obj_html("Average time taken to download file ", "The below graph represents average time taken to download for each client  "
                            ".  X- axis shows “Average time taken to download a file ” and Y-axis shows "
                            "Client names.")
        report.build_objective()
        graph = self.generate_graph(dataset=dataset, lis=lis, bands=bands)
        report.set_graph_image(graph)
        report.set_csv_filename(graph)
        report.move_csv_file()
        report.move_graph_image()
        report.build_graph()
        if (self.dowebgui and self.get_live_view):
            self.add_live_view_images_to_report(report)

        # report.set_obj_html("Summary Table Description", "This Table shows you the summary "
        #                     "result of Webpage Download Test as PASS or FAIL criteria. If the average time taken by " +
        #                     str(num_stations) + " clients to access the webpage is less than " + str( threshold_2g) +
        #                     "s it's a PASS criteria for 2.4 ghz clients, If the average time taken by " + "" +
        #                     str( num_stations) + " clients to access the webpage is less than " + str( threshold_5g) +
        #                     "s it's a PASS criteria for 5 ghz clients and If the average time taken by " + str( num_stations) +
        #                     " clients to access the webpage is less than " + str(threshold_both) +
        #                     "s it's a PASS criteria for 2.4 ghz and 5ghz clients")

        # report.build_objective()
        # test_setup1 = pd.DataFrame(summary_table_value)
        # report.set_table_dataframe(test_setup1)
        # report.build_table()

        report.set_obj_html("Download Time Table Description", "This Table will provide you information of the "
                            "minimum, maximum and the average time taken by clients to download a webpage in seconds")

        report.build_objective()
        self.response_port = self.local_realm.json_get("/port/all")
        # print(response_port)
        # print("port list",self.port_list)
        # To set channel_list,mode_list,port_list to append once again
        self.channel_list, self.mode_list, self.ssid_list = [], [], []
        if self.client_type == "Real":
            self.devices = self.devices_list
            for interface in self.response_port['interfaces']:
                for port, port_data in interface.items():
                    if port in self.port_list:
                        channel_value = str(port_data.get('channel', ''))
                        if channel_value in ('', '0', '-1'):
                            self.channel_list.append('NA')
                        else:
                            self.channel_list.append(channel_value)
                        self.mode_list.append(str(port_data['mode']))
                        self.ssid_list.append(str(port_data['ssid']))
        elif self.client_type == "Virtual":
            self.devices = self.station_list[0]
            for interface in self.response_port['interfaces']:
                for port, port_data in interface.items():
                    if port in self.station_list[0]:
                        channel_value = str(port_data.get('channel', ''))
                        if channel_value in ('', '0', '-1'):
                            self.channel_list.append('NA')
                        else:
                            self.channel_list.append(channel_value)
                        self.mode_list.append(str(port_data['mode']))
                        self.macid_list.append(str(port_data['mac']))
                        self.ssid_list.append(str(port_data['ssid']))

        x = []
        for fcc in list(result_data.keys()):
            fcc_type = result_data[fcc]["min"]
            # print(fcc_type)
            for i in fcc_type:
                x.append(i)
            # print(x)
        y = []
        for i in x:
            i = i / 1000
            y.append(i)
        z = []
        for i in y:
            i = str(round(i, 1))
            z.append(i)
        # rint(z)
        x1 = []

        for fcc in list(result_data.keys()):
            fcc_type = result_data[fcc]["max"]
            # print(fcc_type)
            for i in fcc_type:
                x1.append(i)
            # print(x1)
        y1 = []
        for i in x1:
            i = i / 1000
            y1.append(i)
        z1 = []
        for i in y1:
            i = str(round(i, 1))
            z1.append(i)
        # print(z1)
        x2 = []

        for fcc in list(result_data.keys()):
            fcc_type = result_data[fcc]["avg"]
            # print(fcc_type)
            for i in fcc_type:
                x2.append(i)
            # print(x2)
        y2 = []
        for i in x2:
            i = i / 1000
            y2.append(i)
        z2 = []
        for i in y2:
            i = str(round(i, 1))
            z2.append(i)

        download_table_value_dup = {
            # "Band": bands,
            "Minimum": z,
            "Maximum": z1,
            "Average": z2
        }

        download_table_value = {
            "Band": bands,
            "Minimum": z,
            "Maximum": z1,
            "Average": z2
        }

        # Get the report path to create the kpi.csv path
        kpi_path = report.get_report_path()
        print("kpi_path :{kpi_path}".format(kpi_path=kpi_path))

        kpi_csv = lf_kpi_csv.lf_kpi_csv(
            _kpi_path=kpi_path,
            _kpi_test_rig=test_rig,
            _kpi_test_tag=test_tag,
            _kpi_dut_hw_version=dut_hw_version,
            _kpi_dut_sw_version=dut_sw_version,
            _kpi_dut_model_num=dut_model_num,
            _kpi_dut_serial_num=dut_serial_num,
            _kpi_test_id=test_id)
        kpi_csv.kpi_dict['Units'] = "Mbps"
        for band in range(len(download_table_value["Band"])):
            kpi_csv.kpi_csv_get_dict_update_time()
            kpi_csv.kpi_dict['Graph-Group'] = "Webpage Download {band}".format(
                band=download_table_value['Band'][band])
            kpi_csv.kpi_dict['short-description'] = "Webpage download {band} Minimum".format(
                band=download_table_value['Band'][band])
            kpi_csv.kpi_dict['numeric-score'] = "{min}".format(min=download_table_value['Minimum'][band])
            kpi_csv.kpi_csv_write_dict(kpi_csv.kpi_dict)
            kpi_csv.kpi_dict['short-description'] = "Webpage download {band} Maximum".format(
                band=download_table_value['Band'][band])
            kpi_csv.kpi_dict['numeric-score'] = "{max}".format(max=download_table_value['Maximum'][band])
            kpi_csv.kpi_csv_write_dict(kpi_csv.kpi_dict)
            kpi_csv.kpi_dict['short-description'] = "Webpage download {band} Average".format(
                band=download_table_value['Band'][band])
            kpi_csv.kpi_dict['numeric-score'] = "{avg}".format(avg=download_table_value['Average'][band])
            kpi_csv.kpi_csv_write_dict(kpi_csv.kpi_dict)

        if csv_outfile is not None:
            current_time = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime())
            csv_outfile = "{}_{}-test_l3_longevity.csv".format(
                csv_outfile, current_time)
            csv_outfile = report.file_add_path(csv_outfile)
            print("csv output file : {}".format(csv_outfile))

        test_setup = pd.DataFrame(download_table_value_dup)
        report.set_table_dataframe(test_setup)
        report.build_table()
        if self.group_name:
            report.set_table_title("Overall Results for Groups")
        else:
            report.set_table_title("Overall Results")
        report.build_table_title()
        if self.client_type == "Real":
            # When pass_fail criteria specified (expected_passfail_value / device_csv_name)
            if self.expected_passfail_value or self.device_csv_name:
                test_input_list, pass_fail_list = self.get_pass_fail_list(dataset2)
            if self.group_name:
                for key, val in self.group_device_map.items():
                    # Generating Dataframe when Groups with their profiles and pass_fail case is specified
                    if self.expected_passfail_value or self.device_csv_name:
                        dataframe = self.generate_dataframe(
                            val,
                            self.devices,
                            self.macid_list,
                            self.channel_list,
                            self.ssid_list,
                            self.mode_list,
                            dataset2,
                            test_input_list,
                            dataset,
                            dataset1,
                            rx_rate,
                            pass_fail_list,
                            self.data["total_err"])
                    # Generating Dataframe for groups when pass_fail case is not specified
                    else:
                        dataframe = self.generate_dataframe(val, self.devices, self.macid_list, self.channel_list, self.ssid_list,
                                                            self.mode_list, dataset2, [], dataset, dataset1, rx_rate, [], self.data["total_err"])

                    if dataframe:
                        report.set_obj_html("", "Group: {}".format(key))
                        report.build_objective()
                        dataframe1 = pd.DataFrame(dataframe)
                        report.set_table_dataframe(dataframe1)
                        report.build_table()
            else:
                dataframe = {
                    " Clients": self.devices,
                    " MAC ": self.macid_list,
                    " Channel": self.channel_list,
                    " SSID ": self.ssid_list,
                    " Mode": self.mode_list,
                    " No of times File downloaded ": dataset2,
                    " Average time taken to Download file (ms)": dataset,
                    " Bytes-rd (Mega Bytes) ": dataset1,
                    "Rx Rate (Mbps)": rx_rate,
                    "Failed url's": self.data["total_err"]
                }
                if self.expected_passfail_value or self.device_csv_name:
                    dataframe[" Expected value of no of times file downloaded"] = test_input_list
                    dataframe["Status"] = pass_fail_list
                dataframe1 = pd.DataFrame(dataframe)
                report.set_table_dataframe(dataframe1)
                report.build_table()
        else:
            dataframe = {
                " Clients": self.devices,
                " MAC ": self.macid_list,
                " Channel": self.channel_list,
                " SSID ": self.ssid_list,
                " Mode": self.mode_list,
                " No of times File downloaded ": dataset2,
                " Average time taken to Download file (ms)": dataset,
                " Bytes-rd (Mega Bytes) ": dataset1

            }
            dataframe1 = pd.DataFrame(dataframe)
            report.set_table_dataframe(dataframe1)
            report.build_table()
        if iot_summary:
            self.build_iot_report_section(report, iot_summary)
        # To add charging timestamps of robot in report when bandsteering is enabled
        if self.do_bandsteering:
            if len(self.robot_obj.charging_timestamps) != 0:
                report.set_obj_html(_obj_title="Charging Timestamps",
                                    _obj="")
                report.build_objective()
                df = pd.DataFrame(
                    self.robot_obj.charging_timestamps,
                    columns=[
                        "charge_dock_arrival_timestamp",
                        "charging_completion_timestamp"
                    ]
                )
                # Add S.No column
                df.insert(0, "S.No", range(1, len(df) + 1))
                report.set_table_dataframe(df)
                report.build_table()
            else:
                report.set_obj_html(_obj_title="Charging Timestamps",
                                    _obj="Robot did not went to charge during this test")
                report.build_objective()
        report.build_footer()
        html_file = report.write_html()
        print("returned file {}".format(html_file))
        print(html_file)
        report.write_pdf()

    def copy_reports_to_home_dir(self):
        curr_path = self.result_dir
        home_dir = os.path.expanduser("~")  # it returns the home directory [ base : home/username]
        out_folder_name = "WebGui_Reports"
        new_path = os.path.join(home_dir, out_folder_name)
        # webgui directory creation
        if not os.path.exists(new_path):
            os.makedirs(new_path)
        test_name = self.test_name
        test_name_dir = os.path.join(new_path, test_name)
        # in webgui-reports DIR creating a directory with test name
        if not os.path.exists(test_name_dir):
            os.makedirs(test_name_dir)
        shutil.copytree(curr_path, test_name_dir, dirs_exist_ok=True)

    def generate_dataframe(self, groupdevlist: List[str], clients_list: List[str], mac: List[str], channel: List[str], ssid: List[str], mode: List[str], file_download: List[int],
                           test_input: List[int], averagetime: List[float], bytes_read: List[float], rx_rate: List[float], status: List[str], failedurls: List[int]) -> Optional[pd.DataFrame]:
        """
        Creates a separate DataFrame for each group of devices.

        Returns:
            DataFrame: A DataFrame for each device group.
            Returns None if neither device in a group is configured.
        """
        clients = []
        macids = []
        channels = []
        ssids = []
        modes = []
        downloadtimes = []
        input_list = []
        avgtimes = []
        readbytes = []
        statuslist = []
        rxratelist = []
        urls_failed = []
        interop_tab_data = self.local_realm.json_get('/adb/')["devices"]
        for i in range(len(clients_list)):
            for j in groupdevlist:
                if j == clients_list[i].split(" ")[2] and clients_list[i].split(" ")[1] != 'android':
                    clients.append(clients_list[i])
                    macids.append(mac[i])
                    channels.append(channel[i])
                    ssids.append(ssid[i])
                    modes.append(mode[i])
                    downloadtimes.append(file_download[i])
                    avgtimes.append(averagetime[i])
                    readbytes.append(bytes_read[i])
                    rxratelist.append(rx_rate[i])
                    urls_failed.append(failedurls[i])
                    if self.expected_passfail_value or self.device_csv_name:
                        input_list.append(test_input[i])
                        statuslist.append(status[i])
                else:
                    for dev in interop_tab_data:
                        for item in dev.values():
                            if item['user-name'] == clients_list[i].split(' ')[2] and j == item['name'].split('.')[2]:
                                clients.append(clients_list[i])
                                macids.append(mac[i])
                                channels.append(channel[i])
                                ssids.append(ssid[i])
                                modes.append(mode[i])
                                downloadtimes.append(file_download[i])
                                avgtimes.append(averagetime[i])
                                readbytes.append(bytes_read[i])
                                rxratelist.append(rx_rate[i])
                                urls_failed.append(failedurls[i])
                                if self.expected_passfail_value or self.device_csv_name:
                                    input_list.append(test_input[i])
                                    statuslist.append(status[i])
        # Checks if either device in the group is configured
        if len(clients) != 0:
            dataframe = {
                " Clients": clients,
                " MAC ": macids,
                " Channel": channels,
                " SSID ": ssids,
                " Mode": modes,
                " No of times File downloaded ": downloadtimes,
                " Average time taken to Download file (ms)": avgtimes,
                " Bytes-rd (Mega Bytes) ": readbytes,
                "Rx Rate (Mbps)": rxratelist,
                "Failed url's": urls_failed
            }
            if self.expected_passfail_value or self.device_csv_name:
                dataframe[" Expected value of no of times file downloaded"] = input_list
                dataframe[" Status "] = statuslist
            return dataframe
        # if neither device in the group is configured returns 0
        else:
            return None

    # Updates the status in the running.json file while running a test from the Web UI
    def updating_webui_runningjson(self, obj):
        data = {}
        with open(self.result_dir + "/../../Running_instances/{}_{}_running.json".format(self.host, self.test_name),
                  'r') as file:
            data = json.load(file)
            for key in obj:
                data[key] = obj[key]
        with open(self.result_dir + "/../../Running_instances/{}_{}_running.json".format(self.host, self.test_name),
                  'w') as file:
            json.dump(data, file, indent=4)

    # Converting the upstream_port to IP address for configuration purposes
    def change_port_to_ip(self, upstream_port):
        if upstream_port.count('.') != 3:
            target_port_list = self.name_to_eid(upstream_port)
            shelf, resource, port, _ = target_port_list
            try:
                target_port_ip = self.local_realm.json_get(f'/port/{shelf}/{resource}/{port}?fields=ip')['interface']['ip']
                upstream_port = target_port_ip
            except Exception:
                logging.warning(f'The upstream port is not an ethernet port. Proceeding with the given upstream_port {upstream_port}.')
            logging.info(f"Upstream port IP {upstream_port}")
        else:
            logging.info(f"Upstream port IP {upstream_port}")

        return upstream_port

    def get_pass_fail_list(self, dataset2):
        # When device csv specified for pass_fail criteria
        if self.expected_passfail_value == '' or self.expected_passfail_value is None:
            res_list = []
            test_input_list = []
            pass_fail_list = []

            interop_tab_data = self.local_realm.json_get('/adb/')["devices"]
            for client in self.devices:
                # Check if the client type (second word in "1.15 android samsungmob") is 'android'
                if client.split(' ')[1] != 'android':
                    res_list.append(client.split(' ')[2])
                else:
                    for dev in interop_tab_data:
                        for item in dev.values():
                            # Extract the username from the client string (e.g., 'samsungmob' from "1.15 android samsungmob")
                            if item['user-name'] == client.split(' ')[2]:
                                res_list.append(item['name'].split('.')[2])
            with open(self.device_csv_name, mode='r') as file:
                reader = csv.DictReader(file)
                rows = list(reader)
            for device in res_list:
                found = False
                for row in rows:
                    if row['DeviceList'] == device and row['HTTP URLcount'].strip() != '':
                        test_input_list.append(row['HTTP URLcount'])
                        found = True
                        break
                # appending default value when not found in csv
                if not found:
                    logger.info(f'Pass/Fail value for device {device} not found in the CSV. Defaulting to a pass threshold of 5 URL counts.')
                    test_input_list.append(5)
            for i in range(len(test_input_list)):
                if int(test_input_list[i]) <= dataset2[i]:
                    pass_fail_list.append('PASS')
                else:
                    pass_fail_list.append('FAIL')
        # When expected pass_fail value specified for pass_fail criteria
        else:
            test_input_list = [self.expected_passfail_value for val in range(len(self.devices))]
            pass_fail_list = []
            for i in range(len(test_input_list)):
                if int(self.expected_passfail_value) <= dataset2[i]:
                    pass_fail_list.append("PASS")
                else:
                    pass_fail_list.append("FAIL")

        return test_input_list, pass_fail_list

    def get_signal_and_link_speed_data(self):
        """
        Retrieves signal strength, rx rate and link speed data for the specified stations from port.

        """
        station_names = self.port_list
        signal_list = []
        link_speed_list = []
        rx_rate_list = []
        channel_list = []
        bssid_list = []
        interfaces_dict = dict()
        try:
            port_data = self.local_realm.json_get('/ports/all/')['interfaces']
        except KeyError:
            logger.error("Error: 'interfaces' key not found in port data")
            exit(1)

        for port in port_data:
            interfaces_dict.update(port)
        for sta in station_names:
            if sta in interfaces_dict:
                if "dBm" in interfaces_dict[sta]['signal']:
                    signal_list.append(interfaces_dict[sta]['signal'].split(" ")[0])
                else:
                    signal_list.append(interfaces_dict[sta]['signal'])
            else:
                signal_list.append('-')
        for sta in station_names:
            if sta in interfaces_dict:
                link_speed_list.append(interfaces_dict[sta]['tx-rate'])
            else:
                link_speed_list.append('-')
        for sta in station_names:
            if sta in interfaces_dict:
                rx_rate_list.append(interfaces_dict[sta]['rx-rate'])
            else:
                rx_rate_list.append('-')
        for sta in station_names:
            if sta in interfaces_dict:
                bssid_list.append(interfaces_dict[sta]['ap'])
            else:
                bssid_list.append('-')
        for sta in station_names:
            if sta in interfaces_dict:
                channel_value = str(interfaces_dict[sta].get('channel', ''))
                if channel_value in ('', '0', '-1'):
                    channel_list.append('NA')
                else:
                    channel_list.append(interfaces_dict[sta]['channel'])
        return signal_list, link_speed_list, rx_rate_list, bssid_list, channel_list

    def monitor_cx(self):
        """
        This function waits for upto 20 iterations to allow all CXs (connections) to be created.

        If some CXs are still not created after 20 iterations, then the CXs related to that device are removed,
        along with their associated client and MAC entries from all relevant lists.
        """
        max_retry = 20
        current_retry = 0
        failed_cx = []
        flag = 0
        idx_list = []
        del_device_list, del_mac_list, del_port_list, del_device_list1 = [], [], [], []
        while current_retry < max_retry:
            failed_cx.clear()
            idx_list.clear()
            del_device_list.clear()
            del_mac_list.clear()
            del_port_list.clear()
            del_device_list1.clear()
            created_cx_list = list(self.http_profile.created_cx.keys())
            for i, created_cxs in enumerate(created_cx_list):
                try:
                    _ = self.local_realm.json_get("layer4/%s/list?fields=%s" %
                                                  (created_cxs, 'status'))['endpoint']['status']
                except Exception:
                    logger.error(f'cx not created for {self.port_list[i]}')
                    failed_cx.append(created_cxs)
                    del_device_list.append(self.device_list[i])
                    del_mac_list.append(self.macid_list[i])
                    del_port_list.append(self.port_list[i])
                    del_device_list1.append(self.devices_list[i])
            if len(failed_cx) == 0:
                flag = 1
                break
            logger.info(f'Try {current_retry} out of 20: Waiting for the cross-connections to be created.')
            time.sleep(2)
            current_retry += 1

        if flag:
            logger.info('cross connections found for all devices')
            return
        for cx in failed_cx:
            del self.http_profile.created_cx[cx]
        for i in range(len(del_port_list)):
            self.port_list.remove(del_port_list[i])
            self.macid_list.remove(del_mac_list[i])
            self.device_list.remove(del_device_list[i])
            self.devices_list.remove(del_device_list1[i])
        if len(self.port_list) == 0:
            logger.error('No cross connections created, aborting test')
            exit(1)

    def build_iot_report_section(self, report, iot_summary):
        """
        Handles all IoT-related charts, tables, and increment-wise reports.
        """
        outdir = report.path_date_time
        os.makedirs(outdir, exist_ok=True)

        def copy_into_report(raw_path, new_name):
            """Resolve and copy image into report dir."""
            if not raw_path:
                return None

            abs_src = os.path.abspath(raw_path)
            if not os.path.exists(abs_src):
                # Search recursively under 'results' if absolute path missing
                for root, _, files in os.walk(os.path.join(os.getcwd(), "results")):
                    if os.path.basename(raw_path) in files:
                        abs_src = os.path.join(root, os.path.basename(raw_path))
                        break
                else:
                    return None

            dst = os.path.join(outdir, new_name)
            if os.path.abspath(abs_src) != os.path.abspath(dst):
                shutil.copy2(abs_src, dst)
            return new_name

        # section header
        report.set_custom_html('<div style="page-break-before: always;"></div>')
        report.build_custom()
        report.set_custom_html('<h2><u>IoT Results</u></h2>')
        report.build_custom()

        # Statistics
        stats_png = copy_into_report(iot_summary.get("statistics_img"), "iot_statistics.png")
        if stats_png:
            report.build_chart_title("Test Statistics")
            report.set_custom_html(f'<img src="{stats_png}" style="width:100%; height:auto;">')
            report.build_custom()

        # Request vs Latency
        rvl_png = copy_into_report(iot_summary.get("req_vs_latency_img"), "iot_request_vs_latency.png")
        if rvl_png:
            report.build_chart_title("Request vs Average Latency")
            report.set_custom_html(f'<img src="{rvl_png}" style="width:100%;">')
            report.build_custom()

        # Overall results table
        ort = iot_summary.get("overall_result_table") or {}
        if ort:
            rows = [{
                "Device": dev,
                "Min Latency (ms)": stats.get("min_latency"),
                "Avg Latency (ms)": stats.get("avg_latency"),
                "Max Latency (ms)": stats.get("max_latency"),
                "Total Iterations": stats.get("total_iterations"),
                "Success Iters": stats.get("success_iterations"),
                "Failed Iters": stats.get("failed_iterations"),
                "No-Response Iters": stats.get("no_response_iterations"),
            } for dev, stats in ort.items()]

            df_overall = pd.DataFrame(rows).round(2)

            report.set_custom_html('<div style="page-break-inside: avoid;">')
            report.build_custom()
            report.set_obj_html(_obj_title="Overall IoT Result Table", _obj=" ")
            report.build_objective()
            report.set_table_dataframe(df_overall)
            report.build_table()
            report.set_custom_html('</div>')
            report.build_custom()

        # Increment reports
        inc = iot_summary.get("increment_reports") or {}
        if inc:
            report.set_custom_html('<h3>Reports by Increment Steps</h3>')
            report.build_custom()

            for step_name, rep in inc.items():

                report.set_custom_html(f'<h4><u>{step_name.replace("_", " ")}</u></h4>')
                report.build_custom()

                # Latency graph
                lat_png = copy_into_report(rep.get("latency_graph"), f"iot_{step_name}_latency.png")
                if lat_png:
                    report.build_chart_title("Average Latency")
                    report.set_custom_html(f'<img src="{lat_png}" style="width:100%; height:auto;">')
                    report.build_custom()

                # Success count graph
                res_png = copy_into_report(rep.get("result_graph"), f"iot_{step_name}_results.png")
                if res_png:
                    report.build_chart_title("Success Count")
                    report.set_custom_html(f'<img src="{res_png}" style="width:100%; height:auto;">')
                    report.build_custom()

                # Tabular data for detailed iteration-level results
                data_rows = rep.get("data") or []
                if data_rows:
                    df = pd.DataFrame(data_rows).rename(
                        columns={"latency__ms": "Latency_ms", "latency_ms": "Latency_ms"}
                    )
                    if "Latency_ms" in df.columns:
                        df["Latency_ms"] = pd.to_numeric(df["Latency_ms"], errors="coerce").round(3)
                    if "Result" in df.columns:
                        df["Result"] = df["Result"].map(lambda x: "Success" if bool(x) else "Failure")

                    desired_cols = ["Iteration", "Device", "Current State", "latency (ms)", "Result"]
                    df = df[[c for c in desired_cols if c in df.columns]]

                    report.set_table_dataframe(df)
                    report.build_table()

                report.set_custom_html('<hr>')
                report.build_custom()

    def perform_robo(self):
        """
        Controls robot movement through a list of coordinates.
        At each coordinate, optionally performs rotations and runs the test.
        Handles battery charging and user stop conditions safely.
        """

        if self.rotation_list[0] != "":
            self.rotation_enabled = True

        self.robot_obj = RobotClass()
        self.robot_obj.robo_ip = self.robot_ip
        base_dir = os.path.dirname(os.path.dirname(self.result_dir))
        nav_data = os.path.join(base_dir, 'nav_data.json')  # To generate nav_data.json in webgui folder
        self.robot_obj.nav_data_path = nav_data
        self.robot_obj.create_waypointlist()
        self.robot_obj.ip = self.host
        self.robot_obj.testname = self.test_name
        self.robot_obj.runtime_dir = self.result_dir
        self.robot_obj.coordinate_list = self.coordinate_list
        self.robot_obj.time_to_reach = self.duration_to_skip
        self.robot_obj.total_cycles = self.cycles
        test_stopped_by_user = False
        if self.do_bandsteering:
            cycle_coords = self.robot_obj.get_coordinates_list()
            if (len(cycle_coords) == 0):
                logger.info("Coordinate list is empty test execution is stopped")
                return
            self.robot_obj.do_bandsteering = True
            self.start()
            for coordinate in cycle_coords:
                if test_stopped_by_user:
                    break
                # Check for battery status before moving to next coordinate
                if_paused, test_stopped_by_user, test_status = self.robot_obj.wait_for_battery(monitor_function=lambda: self.monitor_for_runtime_csv(self.duration))
                # If test is stopped by user during battery wait
                if test_stopped_by_user:
                    break
                robo_moved, abort, test_status = self.robot_obj.move_to_coordinate(coordinate, monitor_function=lambda: self.monitor_for_runtime_csv(self.duration))
                # If robot failed to reach the coordinate
                if abort:
                    break
                if robo_moved:
                    logger.info("Reached the coordinate {}".format(coordinate))
            self.stop()
            return
        for coordinate in range(len(self.coordinate_list)):
            # Check for battery status before moving to next coordinate
            if test_stopped_by_user:
                break
            if_paused, test_stopped_by_user = self.robot_obj.wait_for_battery()
            # If test is stopped by user during battery wait
            if test_stopped_by_user:
                break
            robo_moved, abort = self.robot_obj.move_to_coordinate(self.coordinate_list[coordinate])
            # If robot failed to reach the coordinate
            if abort:
                break
            # If robot reached the coordinate
            if robo_moved:
                self.current_coordinate = self.coordinate_list[coordinate]
                # if no rotation mode
                if not self.rotation_enabled:
                    # Start the test
                    self.start()
                    test_stopped_by_user = self.monitor_for_runtime_csv(self.duration)
                    self.stop()
                    self.update_stop_status_robot()

                # if rotation mode
                else:
                    for angle in range(len(self.rotation_list)):
                        # Check for battery status before rotating to next angle
                        is_paused, test_stopped_by_user = self.robot_obj.wait_for_battery()
                        if test_stopped_by_user:
                            break
                        robo_rotated = self.robot_obj.rotate_angle(self.rotation_list[angle])
                        if robo_rotated:
                            self.current_angle = self.rotation_list[angle]
                            self.start()
                            test_stopped_by_user = self.monitor_for_runtime_csv(self.duration)
                            self.stop()
                            self.update_stop_status_robot()
                        # If test is stopped by user
                        if test_stopped_by_user:
                            break

    def build_graphs_and_table(self, coord="", rotation="", report="", lis=None, bands=None):
        """
        Builds graphs and summary table for a given coordinate and rotation.
        Parameters
        coord : str, optional
            Coordinate name for the current robot position.
        rotation : str or int, optional
            Rotation angle for the current robot orientation.
        report : object
            Report builder instance used to add headings, graphs, CSV files,
            and tables to the report.
        lis : list, optional
            List of client labels or identifiers used for graph axis labeling
            and data alignment.
        bands : list, optional
            List of bands used for graph
            labeling.
        """
        rotation_suffix = f"_{rotation}" if rotation else ""
        coord_label = f"<h2>Coordinate: {coord}</h2>"
        if self.rotation_enabled:
            coord_label = f"<h2>Coordinate: {coord}{', Rotation: ' + str(rotation) if rotation else ''}</h2>"
        report.set_custom_html(coord_label)
        report.build_custom()

        report.set_obj_html("No of times file Downloads", "The below graph represents number of times a file downloads for each client"
                            ". X- axis shows “No of times file downloads and Y-axis shows "
                            "Client names.")
        report.build_objective()

        robot_data = self.robot_data.get(coord, {})
        if self.rotation_enabled:
            robot_data = robot_data.get(rotation, {})

        graph2 = self.graph_2(robot_data['url_data'], lis=lis, bands=bands, graph_name=f"Total-url_http_{coord}{rotation_suffix}")
        report.set_graph_image(graph2)
        report.set_csv_filename(graph2)
        report.move_csv_file()
        report.move_graph_image()
        report.build_graph()

        report.set_obj_html("Average time taken to download file ", "The below graph represents average time taken to download for each client  "
                            ".  X- axis shows “Average time taken to download a file ” and Y-axis shows "
                            "Client names.")
        report.build_objective()
        graph = self.generate_graph(dataset=robot_data['uc_avg'], lis=lis, bands=bands, graph_image_name=f"ucg-avg_http_{coord}{rotation_suffix}")
        report.set_graph_image(graph)
        report.set_csv_filename(graph)
        report.move_csv_file()
        report.move_graph_image()
        report.build_graph()

        report.set_table_title("Overall Results")
        report.build_table_title()

        dataframe = {
            " Clients": self.devices,
            " MAC ": robot_data['MAC'],
            " Channel": robot_data['Channel'],
            " SSID ": robot_data['SSID'],
            " Mode": robot_data['Mode'],
            " No of times File downloaded ": robot_data['url_data'],
            " Average time taken to Download file (ms)": robot_data['uc_avg'],
            " Bytes-rd (Mega Bytes) ": robot_data['bytes_rd'],
            "Rx Rate (Mbps)": robot_data['rx rate (1m)'],
            "Failed url's": robot_data["total_err"]
        }
        dataframe1 = pd.DataFrame(dataframe)
        report.set_table_dataframe(dataframe1)
        report.build_table()


def validate_args(args):
    if args.expected_passfail_value and args.device_csv_name:
        logger.error("Specify either --expected_passfail_value or --device_csv_name")
        exit(1)
    if args.group_name:
        selected_groups = args.group_name.split(',')
    else:
        selected_groups = []
    if args.profile_name:
        selected_profiles = args.profile_name.split(',')
    else:
        selected_profiles = []

    if len(selected_groups) != len(selected_profiles):
        logger.error("Number of groups should match number of profiles")
        exit(1)
    elif args.group_name and args.profile_name and args.file_name and args.device_list != []:
        logger.error("Either --group_name or --device_list should be entered not both")
        exit(1)
    elif args.ssid and args.profile_name:
        logger.error("Either --ssid or --profile_name should be given")
        exit(1)
    elif args.file_name and (args.group_name is None or args.profile_name is None):
        logger.error("Please enter the correct set of arguments for configuration")
        exit(1)
    if args.client_type == 'Real' and args.config and args.group_name is None:
        if args.ssid and args.security and args.security.lower() == 'open' and (args.passwd is None or args.passwd == ''):
            args.passwd = '[BLANK]'
        if args.ssid is None or args.passwd is None or args.passwd == '':
            logger.error('For configuration need to Specify --ssid , --passwd (Optional for "open" type security) , --security')
            exit(1)
        elif args.ssid and args.passwd == '[BLANK]' and args.security and args.security.lower() != 'open':
            logger.error('Please provide valid --passwd and --security configuration')
            exit(1)
        elif args.ssid and args.passwd:
            if args.security is None:
                logger.error('Security must be provided when --ssid and --password specified')
                exit(1)
            elif args.ssid and args.passwd == '[BLANK]' and args.security and args.security.lower() != 'open':
                logger.error('Please provide valid passwd and security configuration')
                exit(1)
            elif args.security.lower() == 'open' and args.passwd != '[BLANK]':
                logger.error("For a open type security there will be no password or the password should be left blank (i.e., set to '' or [BLANK]).")
                exit(1)


def with_iot_params_in_table(base: dict, iot_summary) -> dict:
    """
    Append IoT params into the existing Throughput Input Parameters table.
    Adds: IoT Test name, IoT Iterations, IoT Delay (s), IoT Increment.
    Accepts dict or JSON string.
    """
    print("function called with iot params-----")
    try:
        if not iot_summary:
            return base
        if isinstance(iot_summary, str):
            try:
                iot_summary = json.loads(iot_summary)
            except Exception:
                start = iot_summary.find("{")
                end = iot_summary.rfind("}")
                if start == -1 or end == -1 or end <= start:
                    return base
                try:
                    iot_summary = json.loads(iot_summary[start:end + 1])
                except Exception:
                    return base

        ti = (iot_summary.get("test_input_table") or {})
        out = OrderedDict(base)
        out["IoT Test name"] = ti.get("Testname", "")
        out["IoT Device List"] = ti.get("Device List", "")
        out["IoT Iterations"] = ti.get("Iterations", "")
        out["IoT Delay (s)"] = ti.get("Delay (seconds)", "")
        out["IoT Increment"] = ti.get("Increment Pattern", "")
        return out
    except Exception:
        return base


def trigger_iot(ip, port, iterations, delay, device_list, testname, increment):
    """
    Entry point to start the IoT test in a separate thread.
    This function is called from the throughput test script when IoT testing
    is enabled. It wraps the asynchronous `run_iot()`.
    """
    asyncio.run(run_iot(ip, port, iterations, delay, device_list, testname, increment))


async def run_iot(ip: str = '127.0.0.1',
                  port: str = '8000',
                  iterations: int = 1,
                  delay: int = 5,
                  device_list: str = '',
                  testname: str = '',
                  increment: str = ''):
    try:

        if delay < 5:
            logger.error('The minimum delay should be 5 seconds.')
            exit(1)

        if device_list != '':
            device_list = device_list.split(',')
        else:
            device_list = None
        # Parse and validate increment pattern if provided
        if increment:
            print("the increment is : ", increment)
            try:
                increment = list(map(int, increment.split(',')))
                if any(i < 1 for i in increment):
                    logger.error('Increment values must be positive integers')
                    exit(1)
            except ValueError:
                logger.error('Invalid increment format. Please provide comma-separated integers (e.g., "1,3,5")')
                exit(1)

        testname = testname

        # Ensure test name is unique (avoid overwriting previous results)
        if testname in os.listdir('../../local/interop-webGUI/IoT/scripts/results/'):
            logger.error('Test with same name already existing. Please give a different testname.')
            exit(1)
        automation = Automation(ip=ip,
                                port=port,
                                iterations=iterations,
                                delay=delay,
                                device_list=device_list,
                                testname=testname,
                                increment=increment)

        # fetch the available iot devices
        automation.devices = await automation.fetch_iot_devices()

        # select the iot devices for testing
        automation.select_iot_devices()

        # run the iot test on selected devices
        automation.run_test()

        # generate the iot report
        automation.generate_report()

    except Exception as e:
        logger.error(f"Iot Test failed: {str(e)}")
        raise

    await automation.session.close()

    logger.info('Iot Test Completed.')


def main():
    # TODO: set up logger
    # logger_config = lf_logger_config.lf_logger_config()
    parser = argparse.ArgumentParser(
        prog="lf_webpage.py",
        formatter_class=argparse.RawTextHelpFormatter,
        description='''
    NAME: lf_webpage.py

    PURPOSE:
    lf_webpage.py will verify that N clients are connected on a specified band and can download
    some amount of file data from the HTTP server while measuring the time taken by clients to download the file and number of
    times the file is downloaded.

    EXAMPLE-1:
    Command Line Interface to run download scenario for Real clients
    python3 lf_webpage.py --ap_name "Cisco" --mgr 192.168.200.165 --ssid Cisco-5g --security wpa2 --passwd sharedsecret
    --upstream_port eth1 --duration 10m --bands 5G --client_type Real --file_size 2MB

    EXAMPLE-2:
    Command Line Interface to run download scenario on 5GHz band for Virtual clients
    python3 lf_webpage.py --ap_name "Cisco" --mgr 192.168.200.165 --fiveg_ssid Cisco-5g --fiveg_security wpa2 --fiveg_passwd sharedsecret
    --fiveg_radio wiphy0 --upstream_port eth1 --duration 1h --bands 5G --client_type Virtual --file_size 2MB --num_stations 3

    EXAMPLE-3:
    Command Line Interface to run download scenario on 2.4GHz band for Virtual clients
    python3 lf_webpage.py --ap_name "Cisco" --mgr 192.168.200.165 --twog_ssid Cisco-2g --twog_security wpa2 --twog_passwd sharedsecret
    --twog_radio wiphy0 --upstream_port eth1 --duration 1h --bands 2.4G --client_type Virtual --file_size 2MB --num_stations 3

    EXAMPLE-4:
    Command Line Interface to run download scenario on 6GHz band for Virtual clients
    python3 lf_webpage.py --ap_name "Cisco" --mgr 192.168.200.165 --sixg_ssid Cisco-6g --sixg_security wpa3 --sixg_passwd sharedsecret
    --sixg_radio wiphy0 --upstream_port eth1 --duration 1h --bands 6G --client_type Virtual --file_size 2MB --num_stations 3

    EXAMPLE-5:
    Command Line Interface to run the download or upload HTTP urls from a file using Virtual clients on 5GHz band
    Note: The file should contain the the URLs in following mentioned formate
            formate : "dl https://google.com /dev/null"

    EXAMPLE-6:
    Command Line Interface to run download scenario for Real clients with device list
    python3 lf_webpage.py --ap_name "Cisco" --mgr 192.168.214.219 --fiveg_ssid Cisco-5g --fiveg_security wpa2 --fiveg_passwd sharedsecret  --upstream_port eth1
    --duration 1m --bands 5G --client_type Real --file_size 2MB --device_list 1.12,1.22

    EXAMPLE-7:
    Command Line Interface to run download scenario for Real clients with Robot with only coordinates
    python3 lf_webpage.py --ap_name "Netgear" --mgr 192.168.204.78 --ssid NETGEAR_2G_wpa2 --security wpa2 --passwd Password@123
    --upstream_port eth1 --duration 10m --bands 5G --client_type Real --file_size 2MB --robot_ip 192.168.204.101 --coordinate 3,4 --robot_test

    EXAMPLE-8:
    Command Line Interface to run download scenario for Real clients with Robot with coordinates and rotations
    python3 lf_webpage.py --ap_name "Netgear" --mgr 192.168.204.78 --ssid NETGEAR_2G_wpa2 --security wpa2 --passwd Password@123
    --upstream_port eth1 --duration 10m --bands 5G --client_type Real --file_size 2MB --robot_ip 192.168.204.101 --coordinate 3,4 --rotation 30,45 --robot_test

    Verified CLI:
    python3 lf_webpage.py --ap_name "Netgear1234" --mgr 192.168.200.38 --fiveg_ssid NETGEAR_5G --fiveg_security wpa2
    --fiveg_passwd Password@123 --fiveg_radio 1.1.wiphy1 --upstream_port 1.1.eth2 --duration 1m --bands 5G
    --client_type Virtual --num_stations 5 --get_url_from_file --file_path /home/lanforge/Desktop/dummy.txt

    SCRIPT_CLASSIFICATION : Test

    SCRIPT_CATEGORIES:   Performance,  Functional,  Report Generation

    NOTES:
    1.Please enter the duration in s,m,h (seconds or minutes or hours).Eg: 30s,5m,48h.
    2.After passing cli, a list will be displayed on terminal which contains available resources to run test.
    The following sentence will be displayed
    Enter the desired resources to run the test:
    Please enter the port numbers seperated by commas ','.
    Example:
    Enter the desired resources to run the test:1.10,1.11,1.12,1.13,1.202,1.203,1.303

    STATUS : Functional

    VERIFIED_ON:
    26-JULY-2024,
    GUI Version:  5.4.8
    Kernel Version: 6.2.16+

    LICENSE :
    Copyright (C) 2020-2026 Candela Technologies Inc
    Free to distribute and modify. LANforge systems must be licensed.

    INCLUDE_IN_README: False

        ''')
    required = parser.add_argument_group('Required arguments to run lf_webpage.py')
    optional = parser.add_argument_group('Optional arguments to run lf_webpage.py')

    required.add_argument('--mgr', help='hostname for where LANforge GUI is running', default='localhost')
    required.add_argument('--mgr_port', help='port LANforge GUI HTTP service is running on', default=8080)
    required.add_argument('--upstream_port', help='non-station port that generates traffic: eg: eth1', default='eth2')
    optional.add_argument('--num_stations', type=int, help='number of stations to create for virtual clients', default=0)
    optional.add_argument('--twog_radio', help='specify radio for 2.4G clients', default='wiphy3')
    optional.add_argument('--fiveg_radio', help='specify radio for 5 GHz client', default='wiphy0')
    optional.add_argument('--sixg_radio', help='Specify radio for 6GHz client', default='wiphy2')
    optional.add_argument('--twog_security', help='WiFi Security protocol: {open|wep|wpa2|wpa3} for 2.4G clients')
    optional.add_argument('--twog_ssid', help='WiFi SSID for script object to associate for 2.4G clients')
    optional.add_argument('--twog_passwd', help='WiFi passphrase/password/key for 2.4G clients')
    optional.add_argument('--fiveg_security', help='WiFi Security protocol: {open|wep|wpa2|wpa3} for 5G clients')
    optional.add_argument('--fiveg_ssid', help='WiFi SSID for script object to associate for 5G clients')
    optional.add_argument('--fiveg_passwd', help='WiFi passphrase/password/key for 5G clients')
    optional.add_argument('--sixg_security', help='WiFi Security protocol: {open|wep|wpa2|wpa3} for 2.4G clients')
    optional.add_argument('--sixg_ssid', help='WiFi SSID for script object to associate for 2.4G clients')
    optional.add_argument('--sixg_passwd', help='WiFi passphrase/password/key for 2.4G clients')
    optional.add_argument('--target_per_ten', help='number of request per 10 minutes', default=100)
    required.add_argument('--file_size', type=str, help='specify the size of file you want to download', default='5MB')
    required.add_argument('--bands', nargs="+", help='specify which band testing you want to run eg 5G, 2.4G, 6G',
                          default=["5G", "2.4G", "6G"])
    required.add_argument('--duration', help='Please enter the duration in s,m,h (seconds or minutes or hours).Eg: 30s,5m,48h')
    required.add_argument('--client_type', help='Enter the type of client. Example:"Real","Virtual"')
    optional.add_argument('--threshold_5g', help="Enter the threshold value for 5G Pass/Fail criteria", default="60")
    optional.add_argument('--threshold_2g', help="Enter the threshold value for 2.4G Pass/Fail criteria", default="90")
    optional.add_argument('--threshold_both', help="Enter the threshold value for Both Pass/Fail criteria", default="50")
    required.add_argument('--ap_name', help="specify the ap model ", default="TestAP")
    optional.add_argument('--lf_username', help="Enter the lanforge user name. Example : 'lanforge' ", default="lanforge")
    optional.add_argument('--lf_password', help="Enter the lanforge password. Example : 'lanforge' ", default="lanforge")
    optional.add_argument('--ssh_port', type=int, help="specify the ssh port eg 22", default=22)
    optional.add_argument("--test_rig", default="", help="test rig for kpi.csv, testbed that the tests are run on")
    optional.add_argument("--test_tag", default="",
                          help="test tag for kpi.csv,  test specific information to differentiate the test")
    optional.add_argument("--dut_hw_version", default="",
                          help="dut hw version for kpi.csv, hardware version of the device under test")
    optional.add_argument("--dut_sw_version", default="",
                          help="dut sw version for kpi.csv, software version of the device under test")
    optional.add_argument("--dut_model_num", default="",
                          help="dut model for kpi.csv,  model number / name of the device under test")
    optional.add_argument("--dut_serial_num", default="",
                          help="dut serial for kpi.csv, serial number / serial number of the device under test")
    optional.add_argument("--test_priority", default="", help="dut model for kpi.csv,  test-priority is arbitrary number")
    optional.add_argument("--test_id", default="lf_webpage", help="test-id for kpi.csv,  script or test name")
    optional.add_argument('--csv_outfile', help="--csv_outfile <Output file for csv data>", default="")
    # ARGS for webGUI
    required.add_argument('--dowebgui', help="If true will execute script for webgui", default=False)  # FOR WEBGUI
    optional.add_argument('--result_dir',
                          help='Specify the result dir to store the runtime logs <Do not use in CLI, --used by webui>',
                          default='')
    optional.add_argument('--web_ui_device_list', '--device_list',
                          help='Enter the devices on which the test should be run <Do not use in CLI,--used by webui>', dest='device_list',
                          default=[])
    optional.add_argument('--test_name',
                          help='Specify test name to store the runtime csv results <Do not use in CLI, --used by webui>',
                          default=None)
    optional.add_argument('--get_url_from_file', help='Specify to enable the get url from file flag for cx',
                          action='store_true')
    optional.add_argument('--file_path', help='Specify the path of the file, which has the URLs to download'
                                              ' or upload the URLs', default=None)
    optional.add_argument('--help_summary', action="store_true", help='Show summary of what this script does')
    # Arguments for Configurations and pass_fail criteria (Applicable for real cleints)
    optional.add_argument('--ssid', help='WiFi SSID for script object to associate for Real clients')
    optional.add_argument('--passwd', type=str, nargs='?', const='', help="Specify password for ssid provided")
    optional.add_argument('--security', help='Specify the security')
    optional.add_argument('--file_name', type=str, help='Specify the file name containing group details. Example:file1')
    optional.add_argument('--group_name', type=str, help='Specify the groups name that contains a list of devices. Example: group1,group2')
    optional.add_argument('--profile_name', type=str, help='Specify the profile name to apply configurations to the devices.')
    optional.add_argument("--eap_method", type=str, default='DEFAULT', help="Specify the EAP method for authentication.")
    optional.add_argument("--eap_identity", type=str, default='', help="Specify the EAP identity for authentication.")
    optional.add_argument("--ieee8021x", action="store_true", help='Enables 802.1X enterprise authentication for test stations.')
    optional.add_argument("--ieee80211u", action="store_true", help='Enables IEEE 802.11u (Hotspot 2.0) support.')
    optional.add_argument("--ieee80211w", type=int, default=1, help='Enables IEEE 802.11w (Management Frame Protection) support.')
    optional.add_argument("--enable_pkc", action="store_true", help='Enables pkc support.')
    optional.add_argument("--bss_transition", action="store_true", help='Enables BSS transition support.')
    optional.add_argument("--power_save", action="store_true", help='Enables power-saving features.')
    optional.add_argument("--disable_ofdma", action="store_true", help='Disables OFDMA support.')
    optional.add_argument("--roam_ft_ds", action="store_true", help='Enables fast BSS transition (FT) support')
    optional.add_argument("--key_management", type=str, default='DEFAULT', help='Specify the key management method (e.g., WPA-PSK, WPA-EAP')
    optional.add_argument("--pairwise", type=str, default='NA')
    optional.add_argument("--private_key", type=str, default='NA', help='Specify EAP private key certificate file.')
    optional.add_argument("--ca_cert", type=str, default='NA', help='Specifiy the CA certificate file name')
    optional.add_argument("--client_cert", type=str, default='NA', help='Specify the client certificate file name')
    optional.add_argument("--pk_passwd", type=str, default='NA', help='Specify the password for the private key')
    optional.add_argument("--pac_file", type=str, default='NA', help='Specify the pac file name')
    optional.add_argument("--expected_passfail_value", help="Specify the expected number of urls", default=None)
    optional.add_argument("--device_csv_name", type=str, help='Specify the csv name to store expected url values', default=None)
    optional.add_argument("--wait_time", type=int, help='Specify the maximum time to wait for Configuration', default=60)
    optional.add_argument("--config", action="store_true", help="Specify for configuring the devices")

    optional.add_argument('--get_live_view', help="If true will heatmap will be generated from testhouse automation WebGui ", action='store_true')
    optional.add_argument('--total_floors', help="Total floors from testhouse automation WebGui ", default="0")
    # IOT ARGS
    parser.add_argument('--iot_test', help="If true will execute script for iot", action='store_true')
    optional.add_argument('--iot_ip',
                          default='127.0.0.1',
                          help='IP of the server')

    optional.add_argument('--iot_port',
                          default='8000',
                          help='Port of the server')
    optional.add_argument('--iot_iterations',
                          type=int,
                          default=1,
                          help='Iterations to run the test')

    optional.add_argument('--iot_delay',
                          type=int,
                          default=5,
                          help='Delay in seconds between iterations (min. 5 seconds)')

    optional.add_argument('--iot_device_list',
                          type=str,
                          default='',
                          help='Entity IDs of the devices to include in testing (comma separated)')

    optional.add_argument('--iot_testname',
                          type=str,
                          default='',
                          help='Testname for reporting')

    optional.add_argument('--iot_increment',
                          type=str,
                          default='',
                          help='Comma-separated list of device counts to incrementally test (e.g., "1,3,5")')
    # Arguments for Robot Automation
    optional.add_argument("--robot_test", help='to trigger robot test', action='store_true')
    optional.add_argument('--robot_ip', type=str, default='', help='hostname for where Robot server is running')
    optional.add_argument('--coordinate', type=str, default='', help="The coordinate contains list of coordinates to be ")
    optional.add_argument('--rotation', type=str, default='', help="The set of angles to rotate at a particular point")
    optional.add_argument('--do_bandsteering', help='Enable bandsteering', action='store_true')
    optional.add_argument('--cycles', type=int, default=1, help='No of cycles to perform band steering')
    optional.add_argument('--bssids', type=str, default='', help='hostname for where Robot server is running')
    optional.add_argument("--duration_to_skip", type=int, help='Specify the maximum time in seconds to skip a point if there is an obstacle', default=60)

    help_summary = '''\
lf_webpage.py will verify that N clients are connected on a specified band and can download
some amount of file data from the HTTP server while measuring the time taken by clients to download the file and number of
times the file is downloaded.
'''
    args = parser.parse_args()
    if args.help_summary:
        print(help_summary)
        exit(0)

    args.bands.sort()

    # Error checking to prevent case issues
    for band in range(len(args.bands)):
        args.bands[band] = args.bands[band].upper()
        if args.bands[band] == "BOTH":
            args.bands[band] = "Both"

    # Error checking for non-existent bands
    valid_bands = ['2.4G', '5G', '6G', 'Both']
    for band in args.bands:
        if band not in valid_bands:
            raise ValueError("Invalid band '%s' used in bands argument!" % band)

    # Check for Both being used independently
    if len(args.bands) > 1 and "Both" in args.bands:
        raise ValueError("'Both' test type must be used independently!")
    if args.iot_test:
        iot_ip = args.iot_ip
        iot_port = args.iot_port
        iot_iterations = args.iot_iterations
        iot_delay = args.iot_delay
        iot_device_list = args.iot_device_list
        iot_testname = args.iot_testname
        iot_increment = args.iot_increment

    validate_args(args)
    if args.duration.endswith('s') or args.duration.endswith('S'):
        args.duration = int(args.duration[0:-1])
    elif args.duration.endswith('m') or args.duration.endswith('M'):
        args.duration = int(args.duration[0:-1]) * 60
    elif args.duration.endswith('h') or args.duration.endswith('H'):
        args.duration = int(args.duration[0:-1]) * 60 * 60
    elif args.duration.endswith(''):
        args.duration = int(args.duration)

    list6G, list6G_bytes, list6G_speed, list6G_urltimes = [], [], [], []
    list5G, list5G_bytes, list5G_speed, list5G_urltimes = [], [], [], []
    list2G, list2G_bytes, list2G_speed, list2G_urltimes = [], [], [], []
    Both, Both_bytes, Both_speed, Both_urltimes = [], [], [], []
    listReal, listReal_bytes, listReal_speed, listReal_urltimes = [], [], [], []  # For real devices (not band specific)
    dict_keys = []
    dict_keys.extend(args.bands)
    # print(dict_keys)
    final_dict = dict.fromkeys(dict_keys)
    # print(final_dict)
    dict1_keys = ['dl_time', 'min', 'max', 'avg', 'bytes_rd', 'speed', 'url_times']
    for i in final_dict:
        final_dict[i] = dict.fromkeys(dict1_keys)
    print(final_dict)
    min6 = []
    min5 = []
    min2 = []
    min_both = []
    max6 = []
    max5 = []
    max2 = []
    max_both = []
    avg6 = []
    avg2 = []
    avg5 = []
    avg_both = []
    port_list, device_list, macid_list = [], [], []
    for bands in args.bands:
        # For real devices while ensuring no blocker for Virtual devices
        if args.client_type == 'Real':
            ssid = args.ssid
            passwd = args.passwd
            security = args.security
        elif bands == "2.4G":
            security = [args.twog_security]
            ssid = [args.twog_ssid]
            passwd = [args.twog_passwd]
        elif bands == "5G":
            security = [args.fiveg_security]
            ssid = [args.fiveg_ssid]
            passwd = [args.fiveg_passwd]
        elif bands == "6G":
            security = [args.sixg_security]
            ssid = [args.sixg_ssid]
            passwd = [args.sixg_passwd]
        elif bands == "Both":
            security = [args.twog_security, args.fiveg_security]
            ssid = [args.twog_ssid, args.fiveg_ssid]
            passwd = [args.twog_passwd, args.fiveg_passwd]
        http = HttpDownload(lfclient_host=args.mgr, lfclient_port=args.mgr_port,
                            upstream=args.upstream_port, num_sta=args.num_stations,
                            security=security, ap_name=args.ap_name,
                            ssid=ssid, password=passwd,
                            target_per_ten=args.target_per_ten,
                            file_size=args.file_size, bands=bands,
                            twog_radio=args.twog_radio,
                            fiveg_radio=args.fiveg_radio,
                            sixg_radio=args.sixg_radio,
                            client_type=args.client_type,
                            lf_username=args.lf_username, lf_password=args.lf_password,
                            result_dir=args.result_dir,  # FOR WEBGUI
                            dowebgui=args.dowebgui,  # FOR WEBGUI
                            device_list=args.device_list,
                            test_name=args.test_name,  # FOR WEBGUI
                            get_url_from_file=args.get_url_from_file,
                            file_path=args.file_path,
                            file_name=args.file_name,
                            group_name=args.group_name,
                            profile_name=args.profile_name,
                            eap_method=args.eap_method,
                            eap_identity=args.eap_identity,
                            ieee80211=args.ieee8021x,
                            ieee80211u=args.ieee80211u,
                            ieee80211w=args.ieee80211w,
                            enable_pkc=args.enable_pkc,
                            bss_transition=args.bss_transition,
                            power_save=args.power_save,
                            disable_ofdma=args.disable_ofdma,
                            roam_ft_ds=args.roam_ft_ds,
                            key_management=args.key_management,
                            pairwise=args.pairwise,
                            private_key=args.private_key,
                            ca_cert=args.ca_cert,
                            client_cert=args.client_cert,
                            pk_passwd=args.pk_passwd,
                            pac_file=args.pac_file,
                            expected_passfail_value=args.expected_passfail_value,
                            device_csv_name=args.device_csv_name,
                            wait_time=args.wait_time,
                            config=args.config,
                            get_live_view=args.get_live_view,
                            total_floors=args.total_floors,
                            # Robot test parameters
                            robot_test=args.robot_test,
                            robot_ip=args.robot_ip,
                            coordinate=args.coordinate,
                            rotation=args.rotation,
                            duration=args.duration,
                            do_bandsteering=args.do_bandsteering,
                            cycles=args.cycles,
                            bssids=args.bssids,
                            duration_to_skip=args.duration_to_skip
                            )
        if args.client_type == "Real":
            if not isinstance(args.device_list, list):
                http.device_list = http.filter_iOS_devices(args.device_list)
                if len(http.device_list) == 0:
                    logger.info("There are no devices available")
                    exit(1)
            port_list, device_list, macid_list, configuration = http.get_real_client_list()
            if args.dowebgui and args.group_name:
                if len(device_list) == 0:
                    logger.info("No device is available to run the test")
                    obj = {
                        "status": "Stopped",
                        "configuration_status": "configured"
                    }
                    http.updating_webui_runningjson(obj)
                    return
                else:
                    obj = {
                        "configured_devices": device_list,
                        "configuration_status": "configured"
                    }
                    http.updating_webui_runningjson(obj)
            args.num_stations = len(port_list)
        if not args.get_url_from_file:
            http.file_create(ssh_port=args.ssh_port)
        else:
            if args.file_path is None:
                print("WARNING: Please Specify the path of the file, if you select the --get_url_from_file")
                exit(0)
        http.set_values()
        http.precleanup()
        if args.iot_test:
            if args.iot_iterations > 1:
                thread = threading.Thread(target=trigger_iot, args=(iot_ip, iot_port, iot_iterations, iot_delay, iot_device_list, iot_testname, iot_increment))
                thread.start()
            else:
                total_secs = int(args.duration)
                iot_iterations = max(1, total_secs // args.iot_delay)
                iot_thread = threading.Thread(
                    target=trigger_iot,
                    args=(
                        args.iot_ip,
                        args.iot_port,
                        iot_iterations,
                        args.iot_delay,
                        args.iot_device_list,
                        args.iot_testname,
                        args.iot_increment
                    ),
                    daemon=True
                )
                iot_thread.start()
        http.build()
        if args.client_type == 'Real':
            http.monitor_cx()
            logger.info(f'Test started on the devices : {http.port_list}')
        test_time = datetime.now()
        # Solution For Leap Year conflict changed it to %Y
        test_time = test_time.strftime("%Y %d %H:%M:%S")
        print("Test started at ", test_time)

        if args.robot_test:
            # To perform robot test
            http.perform_robo()
        else:
            http.start()
            if args.dowebgui:
                # FOR WEBGUI, -This fumction is called to fetch the runtime data from layer-4
                http.monitor_for_runtime_csv(args.duration)
            elif args.client_type == 'Real':
                # To fetch runtime csv during runtime
                http.monitor_for_runtime_csv(args.duration)
            else:
                time.sleep(args.duration)
            http.stop()
        # taking http.data, which got updated in the monitor_for_runtime_csv method
        if args.client_type == 'Real':
            uc_avg_val = http.data['uc_avg']
            url_times = http.data['url_data']
            rx_bytes_val = http.data['bytes_rd']
            rx_rate_val = list(http.data['rx rate (1m)'])
        else:
            uc_avg_val = http.my_monitor('uc-avg')
            url_times = http.my_monitor('total-urls')
            rx_bytes_val = http.my_monitor('bytes-rd')
            rx_rate_val = http.my_monitor('rx rate')
        if args.dowebgui:
            http.data_for_webui["url_data"] = url_times  # storing the layer-4 url data at the end of test
        if args.client_type == 'Real':  # for real clients
            listReal.extend(uc_avg_val)
            listReal_bytes.extend(rx_bytes_val)
            listReal_speed.extend(rx_rate_val)
            listReal_urltimes.extend(url_times)
            logger.info("%s %s %s", listReal, listReal_bytes, listReal_speed)
            final_dict[bands]['dl_time'] = listReal
            min2.append(min(listReal))
            final_dict[bands]['min'] = min2
            max2.append(max(listReal))
            final_dict[bands]['max'] = max2
            avg2.append((sum(listReal) / args.num_stations))
            final_dict[bands]['avg'] = avg2
            final_dict[bands]['bytes_rd'] = listReal_bytes
            final_dict[bands]['speed'] = listReal_speed
            final_dict[bands]['url_times'] = listReal_urltimes
        else:
            if bands == "5G":
                list5G.extend(uc_avg_val)
                list5G_bytes.extend(rx_bytes_val)
                list5G_speed.extend(rx_rate_val)
                list5G_urltimes.extend(url_times)
                logger.info("%s %s %s %s", list5G, list5G_bytes, list5G_speed, list5G_urltimes)
                final_dict['5G']['dl_time'] = list5G
                min5.append(min(list5G))
                final_dict['5G']['min'] = min5
                max5.append(max(list5G))
                final_dict['5G']['max'] = max5
                avg5.append((sum(list5G) / args.num_stations))
                final_dict['5G']['avg'] = avg5
                final_dict['5G']['bytes_rd'] = list5G_bytes
                final_dict['5G']['speed'] = list5G_speed
                final_dict['5G']['url_times'] = list5G_urltimes
            elif bands == "6G":
                list6G.extend(uc_avg_val)
                list6G_bytes.extend(rx_bytes_val)
                list6G_speed.extend(rx_rate_val)
                list6G_urltimes.extend(url_times)
                final_dict['6G']['dl_time'] = list6G
                min6.append(min(list6G))
                final_dict['6G']['min'] = min6
                max6.append(max(list6G))
                final_dict['6G']['max'] = max6
                avg6.append((sum(list6G) / args.num_stations))
                final_dict['6G']['avg'] = avg6
                final_dict['6G']['bytes_rd'] = list6G_bytes
                final_dict['6G']['speed'] = list6G_speed
                final_dict['6G']['url_times'] = list6G_urltimes
            elif bands == "2.4G":
                list2G.extend(uc_avg_val)
                list2G_bytes.extend(rx_bytes_val)
                list2G_speed.extend(rx_rate_val)
                list2G_urltimes.extend(url_times)
                logger.info("%s %s %s", list2G, list2G_bytes, list2G_speed)
                final_dict['2.4G']['dl_time'] = list2G
                min2.append(min(list2G))
                final_dict['2.4G']['min'] = min2
                max2.append(max(list2G))
                final_dict['2.4G']['max'] = max2
                avg2.append((sum(list2G) / args.num_stations))
                final_dict['2.4G']['avg'] = avg2
                final_dict['2.4G']['bytes_rd'] = list2G_bytes
                final_dict['2.4G']['speed'] = list2G_speed
                final_dict['2.4G']['url_times'] = list2G_urltimes
            elif bands == "Both":
                Both.extend(uc_avg_val)
                Both_bytes.extend(rx_bytes_val)
                Both_speed.extend(rx_rate_val)
                Both_urltimes.extend(url_times)
                final_dict['Both']['dl_time'] = Both
                min_both.append(min(Both))
                final_dict['Both']['min'] = min_both
                max_both.append(max(Both))
                final_dict['Both']['max'] = max_both
                avg_both.append((sum(Both) / args.num_stations))
                final_dict['Both']['avg'] = avg_both
                final_dict['Both']['bytes_rd'] = Both_bytes
                final_dict['Both']['speed'] = Both_speed
                final_dict['Both']['url_times'] = Both_urltimes

    result_data = final_dict
    print("result", result_data)
    print("Test Finished")
    test_end = datetime.now()
    test_end = test_end.strftime("%Y %d %H:%M:%S")
    print("Test ended at ", test_end)
    s1 = test_time
    s2 = test_end  # for example
    FMT = '%Y %d %H:%M:%S'
    test_duration = datetime.strptime(s2, FMT) - datetime.strptime(s1, FMT)

    info_ssid = []
    info_security = []
    # For real clients
    if args.client_type == 'Real':
        info_ssid.append(args.ssid)
        info_security.append(args.security)
    else:
        for band in args.bands:
            if band == "2.4G":
                info_ssid.append(args.twog_ssid)
                info_security.append(args.twog_security)
            elif band == "5G":
                info_ssid.append(args.fiveg_ssid)
                info_security.append(args.fiveg_security)
            elif band == "6G":
                info_ssid.append(args.sixg_ssid)
                info_security.append(args.sixg_security)
            elif band == "Both":
                info_ssid.append(args.fiveg_ssid)
                info_security.append(args.fiveg_security)
                info_ssid.append(args.twog_ssid)
                info_security.append(args.twog_security)

    print("total test duration ", test_duration)
    date = str(datetime.now()).split(",")[0].replace(" ", "-").split(".")[0]
    duration = args.duration
    if int(duration) < 60:
        duration = str(duration) + "s"
    elif int(duration == 60) or (int(duration) > 60 and int(duration) < 3600):
        duration = str(duration / 60) + "m"
    else:
        if int(duration == 3600) or (int(duration) > 3600):
            duration = str(duration / 3600) + "h"

    android_devices, windows_devices, linux_devices, mac_devices = 0, 0, 0, 0
    all_devices_names = []
    device_type = []
    total_devices = ""
    for i in http.devices_list:
        split_device_name = i.split(" ")
        if 'android' in split_device_name:
            all_devices_names.append(split_device_name[2] + ("(Android)"))
            device_type.append("Android")
            android_devices += 1
        elif 'Win' in split_device_name:
            all_devices_names.append(split_device_name[2] + ("(Windows)"))
            device_type.append("Windows")
            windows_devices += 1
        elif 'Lin' in split_device_name:
            all_devices_names.append(split_device_name[2] + ("(Linux)"))
            device_type.append("Linux")
            linux_devices += 1
        elif 'Mac' in split_device_name:
            all_devices_names.append(split_device_name[2] + ("(Mac)"))
            device_type.append("Mac")
            mac_devices += 1

    # Build total_devices string based on counts
    if android_devices > 0:
        total_devices += f" Android({android_devices})"
    if windows_devices > 0:
        total_devices += f" Windows({windows_devices})"
    if linux_devices > 0:
        total_devices += f" Linux({linux_devices})"
    if mac_devices > 0:
        total_devices += f" Mac({mac_devices})"
    if args.client_type == "Real":
        android_devices, windows_devices, linux_devices, mac_devices = 0, 0, 0, 0
        all_devices_names = []
        device_type = []
        total_devices = ""
        for i in http.devices_list:
            split_device_name = i.split(" ")
            if 'android' in split_device_name:
                all_devices_names.append(split_device_name[2] + ("(Android)"))
                device_type.append("Android")
                android_devices += 1
            elif 'Win' in split_device_name:
                all_devices_names.append(split_device_name[2] + ("(Windows)"))
                device_type.append("Windows")
                windows_devices += 1
            elif 'Lin' in split_device_name:
                all_devices_names.append(split_device_name[2] + ("(Linux)"))
                device_type.append("Linux")
                linux_devices += 1
            elif 'Mac' in split_device_name:
                all_devices_names.append(split_device_name[2] + ("(Mac)"))
                device_type.append("Mac")
                mac_devices += 1

        # Build total_devices string based on counts
        if android_devices > 0:
            total_devices += f" Android({android_devices})"
        if windows_devices > 0:
            total_devices += f" Windows({windows_devices})"
        if linux_devices > 0:
            total_devices += f" Linux({linux_devices})"
        if mac_devices > 0:
            total_devices += f" Mac({mac_devices})"
        if args.group_name:
            group_names = ', '.join(configuration.keys())
            profile_names = ', '.join(configuration.values())
            configmap = "Groups:" + group_names + " -> Profiles:" + profile_names
            test_setup_info = {
                "AP name": args.ap_name,
                "Configuration": configmap,
                "Configured Devices": ", ".join(all_devices_names),
                "No of Devices": "Total" + f"({len(all_devices_names)})" + total_devices,
                "Traffic Direction": "Download",
                "Traffic Duration ": duration
            }
        else:
            test_setup_info = {
                "AP Name": args.ap_name,
                "SSID": ssid,
                "Device List": ", ".join(all_devices_names),
                "Security": security,
                "No of Devices": "Total" + f"({len(all_devices_names)})" + total_devices,
                "Traffic Direction": "Download",
                "Traffic Duration ": duration
            }
    else:
        test_setup_info = {
            "AP Name": args.ap_name,
            "SSID": ssid,
            "Security": security,
            "No of Devices": args.num_stations,
            "Traffic Direction": "Download",
            "Traffic Duration ": duration
        }
    test_input_infor = {
        "LANforge ip": args.mgr,
        "Bands": args.bands,
        "Upstream": args.upstream_port,
        "Stations": args.num_stations,
        "SSID": ','.join(filter(None, info_ssid)) if info_ssid else "",
        "Security": ', '.join(filter(None, info_security)) if info_security else "",
        "Duration": args.duration,
        "Contact": "support@candelatech.com"
    }
    if not args.file_path:
        test_setup_info["File size"] = args.file_size
        test_setup_info["File location"] = "/usr/local/lanforge/nginx/html"
        test_input_infor["File size"] = args.file_size
    else:
        test_setup_info["File location (URLs from the File)"] = args.file_path
    if args.client_type == "Real":
        test_setup_info["failed_cx's"] = http.failed_cx if http.failed_cx else "NONE"
    # dataset = http.download_time_in_sec(result_data=result_data)
    rx_rate = []
    for i in result_data:
        dataset = result_data[i]['dl_time']
        dataset2 = result_data[i]['url_times']
        bytes_rd = result_data[i]['bytes_rd']
        rx_rate = result_data[i]['speed']
    dataset1 = [round(x / 1000000, 4) for x in bytes_rd]
    rx_rate = [round(x / 1000000, 4) for x in rx_rate]  # converting bps to mbps

    lis = []
    if bands == "Both":
        for i in range(1, args.num_stations * 2 + 1):
            lis.append(i)
    else:
        for i in range(1, args.num_stations + 1):
            lis.append(i)

    # dataset2 = http.speed_in_Mbps(result_data=result_data)

    # data = http.summary_calculation(
        # result_data=result_data,
        # bands=args.bands,
        # threshold_5g=args.threshold_5g,
        # threshold_2g=args.threshold_2g,
        # threshold_both=args.threshold_both)
    # summary_table_value = {
        # "": args.bands,
        # "PASS/FAIL": data
    # }
    iot_summary = None
    if args.iot_test and args.iot_testname:
        base = os.path.join("results", args.iot_testname)
        p = os.path.join(base, "iot_summary.json")
        if os.path.exists(p):
            with open(p) as f:
                iot_summary = json.load(f)
    if args.dowebgui:
        http.data_for_webui["status"] = ["STOPPED"] * len(http.devices_list)
        http.data_for_webui['rx rate (1m)'] = http.data['rx rate (1m)']
        http.data_for_webui['total_err'] = http.data['total_err']
        http.data_for_webui["start_time"] = http.data["start_time"]
        http.data_for_webui["end_time"] = http.data["end_time"]
        http.data_for_webui["remaining_time"] = http.data["remaining_time"]
        df1 = pd.DataFrame(http.data_for_webui)
        df1.to_csv('{}/http_datavalues.csv'.format(http.result_dir), index=False)

    http.generate_report(date, num_stations=args.num_stations,
                         duration=args.duration, test_setup_info=test_setup_info, dataset=dataset, lis=lis,
                         bands=args.bands, threshold_2g=args.threshold_2g, threshold_5g=args.threshold_5g,
                         threshold_both=args.threshold_both, dataset2=dataset2, dataset1=dataset1,
                         # summary_table_value=summary_table_value,
                         result_data=result_data, rx_rate=rx_rate,
                         test_rig=args.test_rig, test_tag=args.test_tag, dut_hw_version=args.dut_hw_version,
                         dut_sw_version=args.dut_sw_version, dut_model_num=args.dut_model_num,
                         dut_serial_num=args.dut_serial_num, test_id=args.test_id,
                         test_input_infor=test_input_infor, csv_outfile=args.csv_outfile, iot_summary=iot_summary)
    http.postcleanup()
    # FOR WEBGUI, filling csv at the end to get the last terminal logs
    if args.dowebgui:
        http.copy_reports_to_home_dir()


if __name__ == '__main__':
    main()