#include "iobox_api.h"
namespace ANSCENTER {
    iobox_api::iobox_api(std::string ipmcast, int port_mcast)
    {
        this->ip_mcast = ipmcast;
        this->port_mcast = port_mcast;
        WSADATA wsaData;
        if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
            std::cerr << "WSAStartup failed with error: " << WSAGetLastError() << std::endl;
            return;
        }
    }
    iobox_api::~iobox_api()
    {
        WSACleanup();
    }

    bool isStringExistInVectorString(const std::vector<std::string>& vec, const std::string& str) {
        for (const auto& item : vec) {
            if (item == str) {
                std::cout << "Found duplicate: " << str << std::endl;
                return true;
            }
        }
        return false;
        // return std::find(vec.begin(), vec.end(), str) != vec.end();
    }

    void printBufferAsHex(const char* buffer, size_t length) {
        for (size_t i = 0; i < length; ++i) {
            printf("%02X ", static_cast<unsigned char>(buffer[i]));
            if ((i + 1) % 16 == 0) {
                printf("\n");
            }
        }
        printf("\n");
    }
    void printStringAsHex(const std::string& str) {
        for (size_t i = 0; i < str.size(); ++i) {
            printf("%02X ", static_cast<unsigned char>(str[i]));
            if ((i + 1) % 16 == 0) {
                printf("\n");
            }
        }
        printf("\n");
    }
    iobox_info_t parseIoboxResponse(const std::string& response) {
        iobox_info_t info;
        size_t ipPos = response.find("IOBOX_RESPONSE:");
        size_t modbusPos = response.find("modbus_address:");

        if (ipPos != std::string::npos && modbusPos != std::string::npos) {
            ipPos += strlen("IOBOX_RESPONSE:");
            modbusPos += strlen("modbus_address:");

            size_t ipEnd = response.find(',', ipPos);
            if (ipEnd != std::string::npos) {
                info.ip_address = response.substr(ipPos, ipEnd - ipPos);
            }

            std::string modbusStr = response.substr(modbusPos);
            info.modbus_address = std::stoi(modbusStr);
        }

        return info;
    }
    void show_info_iobox(iobox_info_t iobox_info) {
        std::cout << "  IP Address: " << iobox_info.ip_address << std::endl;
        std::cout << "  Modbus Address: " << (int)iobox_info.modbus_address << std::endl;
    }
    void iobox_api::show_profile_iobox(std::string ip) {
        iobox_profile_t* profile = findProfileByIp(ip);
        if (profile == nullptr) {
            std::cerr << "IP address not found: " << ip << std::endl;
            return;
        }
        show_profile_iobox(*profile);
    }
    void iobox_api::show_profile_iobox(iobox_profile_t profile) {
        // std::cout << "Profile ioboxs: " << this->iobox_profiles.size() << std::endl;
        // for (const iobox_profile_t& profile : this->iobox_profiles) {
            // std::cout << "* Index: " << &profile - &this->iobox_profiles[0] << std::endl;
        show_info_iobox(profile.iobox_info);
        std::cout << "  Counting get: " << profile.counting_get << std::endl;
        std::cout << "  Is connected: " << profile.is_connected << std::endl;
        if (profile.counting_get)
        {
            std::cout << "  Modbus address: " << profile.iobox_data.modbus_address << std::endl;
            std::cout << "  Serial number: " << reinterpret_cast<const char*>(profile.iobox_data.serial_number) << std::endl;
            uint8_t hw_version = (profile.iobox_data.version >> 8) & 0xFF;
            uint8_t fw_version = profile.iobox_data.version & 0xFF;
            std::cout << "  HW Version: " << static_cast<int>(hw_version) << std::endl;
            std::cout << "  FW Version: " << static_cast<int>(fw_version) << std::endl;
            std::cout << "  Channel DO: ";
            std::cout << profile.iobox_data.channel_DO[0] << " ";
            std::cout << profile.iobox_data.channel_DO[1] << " ";
            std::cout << profile.iobox_data.channel_DO[2] << " ";
            std::cout << profile.iobox_data.channel_DO[3] << std::endl;
            std::cout << "  Channel DI: ";
            std::cout << profile.iobox_data.channel_DI[0] << " ";
            std::cout << profile.iobox_data.channel_DI[1] << " ";
            std::cout << profile.iobox_data.channel_DI[2] << " ";
            std::cout << profile.iobox_data.channel_DI[3] << std::endl;
            std::cout << "  Channel AI: ";
            std::cout << profile.iobox_data.channel_AI[0] << " ";
            std::cout << profile.iobox_data.channel_AI[1] << std::endl;
        }

        // }
    }
    void iobox_api::show_profile_ioboxs() {
        if (this->iobox_profiles.size() == 0) {
            std::cout << "No iobox profiles" << std::endl;
            return;
        }
        for (const auto& profile : this->iobox_profiles) {
            std::cout << "* Index: " << &profile - &this->iobox_profiles[0] << std::endl;
            show_profile_iobox(profile);
        }
    }
    //void iobox_api::save_info_iobox(iobox_info_t iobox_info) {
    //    iobox_profile_t profile = {
    //        .counting_get = 0, 
    //        .is_connected = false, 
    //        .sock_tcp = INVALID_SOCKET,
    //    };
    //    profile.iobox_info = iobox_info;
    //    this->iobox_profiles.push_back(profile);
    //}
    void iobox_api::save_info_iobox(iobox_info_t iobox_info) {
        iobox_profile_t profile;
        profile.counting_get = 0;
        profile.is_connected = false;
        profile.sock_tcp = INVALID_SOCKET;
        profile.iobox_info = iobox_info;

        this->iobox_profiles.push_back(profile);
    }
    bool iobox_api::sendTcpMessage(const std::string& ip, const char* buffer, size_t length) {
        for (auto& profile : this->iobox_profiles) {
            if (profile.iobox_info.ip_address == ip && profile.is_connected && profile.sock_tcp != INVALID_SOCKET) {
                int result = send(profile.sock_tcp, buffer, length, 0);
                if (result == SOCKET_ERROR) {
                    std::cerr << "send failed with error: " << WSAGetLastError() << std::endl;
                    return false;
                }
                std::cout << "Sent " << length << " bytes message to " << ip << std::endl;
                printBufferAsHex(buffer, length);
                return true;
            }
        }
        std::cerr << "IP address not found or not connected: " << ip << std::endl;
        return false;
    }

    bool iobox_api::receiveTcpMessage(const std::string& ip, char* buffer, size_t& length) {
        for (auto& profile : this->iobox_profiles) {
            if (profile.iobox_info.ip_address == ip && profile.is_connected && profile.sock_tcp != INVALID_SOCKET) {
                setSocketTimeout(profile.sock_tcp, 3000);
                int recvLen = recv(profile.sock_tcp, buffer, length, 0);
                if (recvLen > 0) {
                    length = recvLen;
                    std::cout << "Received message: " << length << " bytes" << std::endl;
                    printBufferAsHex(buffer, recvLen);
                    return true;
                }
                else {
                    std::cerr << "recv failed with error: " << WSAGetLastError() << std::endl;
                    return false;
                }
            }
        }
        std::cerr << "IP address not found or not connected: " << ip << std::endl;
        return false;
    }

    void iobox_api::sendMulticastMessage(const std::string& message) {
        SOCKET sock = INVALID_SOCKET;
        struct sockaddr_in multicastAddr;

        sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        if (sock == INVALID_SOCKET) {
            std::cerr << "socket failed with error: " << WSAGetLastError() << std::endl;
            WSACleanup();
            return;
        }

        memset(&multicastAddr, 0, sizeof(multicastAddr));
        multicastAddr.sin_family = AF_INET;
        multicastAddr.sin_addr.s_addr = inet_addr(this->ip_mcast.c_str());
        multicastAddr.sin_port = htons(this->port_mcast);

        if (sendto(sock, message.c_str(), message.length(), 0, (struct sockaddr*)&multicastAddr, sizeof(multicastAddr)) == SOCKET_ERROR) {
            std::cerr << "sendto failed with error: " << WSAGetLastError() << std::endl;
        }
        else {
            std::cout << "Sent message: " << message << std::endl;
        }

        closesocket(sock);
    }
    void iobox_api::setSocketTimeout(SOCKET sock, int timeout) {
        struct timeval tv;
        tv.tv_sec = timeout;
        tv.tv_usec = 0;
        if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv)) < 0) {
            std::cerr << "setsockopt failed with error: " << WSAGetLastError() << std::endl;
        }
    }
    std::vector<std::string> iobox_api::scanNetworkDevicesMulticast(int timeout) {
        std::vector<std::string> devices;

        for (const auto& item : this->iobox_profiles) {
            if (item.is_connected || item.sock_tcp != INVALID_SOCKET) {
                std::cout << "Please close connection to " << item.iobox_info.ip_address << "befor new scan" << std::endl;
                return devices;
            }
        }
        //remove all elements from iobox_profiles before and we start with new scan
        this->iobox_profiles.clear();

        // WSADATA wsaData;
        SOCKET sock = INVALID_SOCKET;
        struct sockaddr_in multicastAddr;
        struct ip_mreq multicastRequest;
        char recvBuf[1024];
        struct sockaddr_in recvAddr;
        int recvAddrLen = sizeof(recvAddr);
        std::string message = "IOBOX_DISCOVERY";

        // if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        //     std::cerr << "WSAStartup failed with error: " << WSAGetLastError() << std::endl;
        //     return devices;
        // }

        sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        if (sock == INVALID_SOCKET) {
            std::cerr << "socket failed with error: " << WSAGetLastError() << std::endl;
            // WSACleanup();
            return devices;
        }

        memset(&multicastAddr, 0, sizeof(multicastAddr));
        multicastAddr.sin_family = AF_INET;
        multicastAddr.sin_addr.s_addr = htonl(INADDR_ANY);
        multicastAddr.sin_port = htons(this->port_mcast);
        if (bind(sock, (struct sockaddr*)&multicastAddr, sizeof(multicastAddr)) == SOCKET_ERROR) {
            std::cerr << "bind failed with error: " << WSAGetLastError() << std::endl;
            closesocket(sock);
            // WSACleanup();
            return devices;
        }
        multicastRequest.imr_multiaddr.s_addr = inet_addr(this->ip_mcast.c_str());
        multicastRequest.imr_interface.s_addr = htonl(INADDR_ANY);

#ifndef TEST_FIX_IP
        if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&multicastRequest, sizeof(multicastRequest)) < 0) {
            std::cerr << "setsockopt failed with error: " << WSAGetLastError() << std::endl;
            closesocket(sock);
            // WSACleanup();
            return devices;
        }
#endif
        setSocketTimeout(sock, 3000);

        auto start = std::chrono::steady_clock::now();
        // sendMulticastMessage(message);
        while (std::chrono::steady_clock::now() - start < std::chrono::seconds(timeout)) {
            int recvLen = recvfrom(sock, recvBuf, sizeof(recvBuf) - 1, 0, (struct sockaddr*)&recvAddr, &recvAddrLen);
            if (recvLen > 0) {
                recvBuf[recvLen] = '\0';
                std::string message_rsp(recvBuf);
                std::string senderIp = inet_ntoa(recvAddr.sin_addr);
                std::cout << "Received message: \"" << message_rsp << "\" from " << senderIp << std::endl;

                iobox_info_t info = parseIoboxResponse(message_rsp);
                if (info.ip_address == senderIp && info.ip_address != "" && !isStringExistInVectorString(devices, senderIp)) {
                    std::string deviceInfo;
                    std::string deviceAlias = "ANSDAQ1";
					std::string deviceSN = "SN123456";
					std::string deviceModel = "ANSIOBOX";
					deviceInfo = deviceAlias + "-" 
                               + deviceModel + "-" 
                               + deviceSN + "-"+ senderIp;                 
                    devices.push_back(deviceInfo);
                    save_info_iobox(info);
                }
            }
            else {
                //std::cerr << "recvfrom failed with error: " << WSAGetLastError() << std::endl;
                sendMulticastMessage(message);
            }
        }
#ifndef TEST_FIX_IP
        setsockopt(sock, IPPROTO_IP, IP_DROP_MEMBERSHIP, (char*)&multicastRequest, sizeof(multicastRequest));
#endif
        closesocket(sock);
        // WSACleanup();
        return devices;
    }


    bool iobox_api::connectToIobox(const std::string& ip, int port, const std::string& username, const std::string& password) {
        // check ip is already in iobox_profiles
        bool is_exist = false;
        iobox_profile_t* item = nullptr;

        for (auto& profile : this->iobox_profiles) {
            if (profile.iobox_info.ip_address == ip) {
                is_exist = true;
                item = &profile;
                if (item->is_connected) {
                    std::cout << "Ip is already connected: " << ip << std::endl;
                    return true;
                }
                break;
            }
        }
        if (is_exist == false) {
            std::cout << "Ip is not exist in list scan" << ip << std::endl;
            return false;
        }

        // WSADATA wsaData;
        SOCKET sock = INVALID_SOCKET;
        struct sockaddr_in serverAddr;
        //char recvBuf[1024];
        int recvLen = 0;
        struct timeval tv;
        tv.tv_sec = 3;
        tv.tv_usec = 0;
        // Initialize Winsock
        // int result = WSAStartup(MAKEWORD(2, 2), &wsaData);
        // if (result != 0) {
        //     std::cerr << "WSAStartup failed: " << result << std::endl;
        //     return false;
        // }
        sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (sock == INVALID_SOCKET) {
            std::cerr << "socket failed with error: " << WSAGetLastError() << std::endl;
            // WSACleanup();
            return false;
        }

        serverAddr.sin_family = AF_INET;
        serverAddr.sin_addr.s_addr = inet_addr(ip.c_str());
        serverAddr.sin_port = htons(port);

        if (connect(sock, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
            std::cerr << "connect failed with error: " << WSAGetLastError() << std::endl;
            closesocket(sock);
            // WSACleanup();
            return false;
        }

        // setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv));
        // recvLen = recv(sock, recvBuf, sizeof(recvBuf) - 1, 0);
        // if (recvLen > 0) {
        //     recvBuf[recvLen] = '\0';
        //     std::cout << "Received message: " << recvBuf << std::endl;
        // } else {
        //     std::cerr << "recv failed with error: " << WSAGetLastError() << std::endl;
        // }

        // closesocket(sock);
        // WSACleanup();
        item->sock_tcp = sock;
        item->is_connected = true;
        return true;
    }

    bool iobox_api::disconnectToIobox(const std::string& ip) {
        // check ip is already in iobox_profiles
        bool is_exist = false;
        iobox_profile_t* item = nullptr;

        for (auto& profile : this->iobox_profiles) {
            if (profile.iobox_info.ip_address == ip) {
                item = &profile;
                is_exist = true;
                if (item->is_connected) {
                    std::cout << "Ip is already connected: " << ip << std::endl;
                }
                break;
            }
        }
        if (is_exist == false) {
            std::cout << "Ip is not exist in list scan" << ip << std::endl;
            return false;
        }
        item->counting_get = 0;
        item->is_connected = false;
        closesocket(item->sock_tcp);
        item->sock_tcp = INVALID_SOCKET;
        // WSACleanup();
        return true;
    }

    uint16_t calculateCRC(const uint8_t* data, size_t length) {
        uint16_t crc = 0xFFFF;
        for (size_t i = 0; i < length; ++i) {
            crc ^= data[i];
            for (int j = 0; j < 8; ++j) {
                if (crc & 0x0001) {
                    crc >>= 1;
                    crc ^= 0xA001;
                }
                else {
                    crc >>= 1;
                }
            }
        }
        return crc;
    }
    std::vector<uint8_t> createModbusWriteSingleRegisterRequest(uint8_t slaveAddress, uint16_t address, uint16_t value) {
        std::vector<uint8_t> request(8);
        request[0] = slaveAddress; // Slave address
        request[1] = 0x06; // Function code for Write Single Register
        request[2] = (address >> 8) & 0xFF; // Register address high byte
        request[3] = address & 0xFF; // Register address low byte
        request[4] = (value >> 8) & 0xFF; // Value high byte
        request[5] = value & 0xFF; // Value low byte

        // Calculate CRC
        uint16_t crc = calculateCRC(request.data(), 6);
        request[6] = crc & 0xFF; // CRC low byte
        request[7] = (crc >> 8) & 0xFF; // CRC high byte

        return request;
    }


    std::vector<uint8_t> createModbusReadHoldingRegistersRequest(uint8_t slaveAddress, uint16_t startAddress, uint16_t quantity) {
        std::vector<uint8_t> request(8);
        request[0] = slaveAddress; // Slave address
        request[1] = 0x03; // Function code for Read Holding Registers
        request[2] = (startAddress >> 8) & 0xFF; // Starting address high byte
        request[3] = startAddress & 0xFF; // Starting address low byte
        request[4] = (quantity >> 8) & 0xFF; // Quantity of registers high byte
        request[5] = quantity & 0xFF; // Quantity of registers low byte

        // Calculate CRC
        uint16_t crc = calculateCRC(request.data(), 6);
        request[6] = crc & 0xFF; // CRC low byte
        request[7] = (crc >> 8) & 0xFF; // CRC high byte

        return request;
    }
    std::vector<uint16_t> parseModbusReadHoldingRegistersResponse(const std::vector<uint8_t>& response) {
        std::vector<uint16_t> data;
        if (response.size() < 5) {
            return data;
        }

        // Verify CRC
        uint16_t receivedCrc = (response[response.size() - 1] << 8) | response[response.size() - 2];
        uint16_t calculatedCrc = calculateCRC(response.data(), response.size() - 2);
        if (receivedCrc != calculatedCrc) {
            std::cerr << "CRC check failed" << std::endl;
            return data;
        }
        if (response[1] & 0x80) {
            std::cerr << "Error code received: " << static_cast<int>(response[2]) << std::endl;
            return data;
        }
        uint8_t byteCount = response[2];
        if (response.size() < 5 + byteCount) {
            return data;
        }
        for (size_t i = 0; i < byteCount / 2; ++i) {
            uint16_t value = (response[3 + i * 2] << 8) | response[4 + i * 2];
            data.push_back(value);
        }

        return data;
    }



    iobox_profile_t* iobox_api::findProfileByIp(const std::string& ip) {
        iobox_profile_t* profile = nullptr;
        for (auto& item : this->iobox_profiles) {
            if (item.iobox_info.ip_address == ip) {
                profile = &item;
            }
        }
        return profile;
    }
    bool iobox_api::getAllDataFromIobox(const std::string& ip) {
        iobox_profile_t* profile = findProfileByIp(ip);
        if (profile == nullptr) {
            std::cerr << "IP address not found: " << ip << std::endl;
            return false;
        }
        std::vector<uint8_t> request = createModbusReadHoldingRegistersRequest(profile->iobox_info.modbus_address, DEVICE_DATA_ADDRESS, DEVICE_DATA_LENGTH);
        if (!sendTcpMessage(ip, reinterpret_cast<const char*>(request.data()), request.size())) {
            return false;
        }

        char response[256];
        size_t responseLength = sizeof(response);
        if (!receiveTcpMessage(ip, response, responseLength)) {
            return false;
        }

        std::vector<uint8_t> responseVec(response, response + responseLength);
        std::vector<uint16_t> registers = parseModbusReadHoldingRegistersResponse(responseVec);

        if (registers.empty()) {
            std::cerr << "Failed to parse Modbus response" << std::endl;
            return false;
        }
        // Process the registers as needed
        // for (size_t i = 0; i < registers.size(); ++i) {
        //     std::cout << "Register " << i << ": " << registers[i] << std::endl;
        // }
        if (registers.size() == DEVICE_DATA_LENGTH) {
            memcpy(&profile->iobox_data, registers.data(), sizeof(profile->iobox_data));
        }
        if (profile->iobox_data.modbus_address != (uint16_t)profile->iobox_info.modbus_address) {
            std::cout << "Modbus address changed to " << profile->iobox_data.modbus_address << std::endl;
            profile->iobox_info.modbus_address = profile->iobox_data.modbus_address;
        }
        profile->counting_get++;
        return true;
    }

    bool iobox_api::setValueDataToIobox(const std::string& ip, uint16_t address, uint16_t value) {
        iobox_profile_t* profile = findProfileByIp(ip);
        if (profile == nullptr) {
            std::cerr << "IP address not found: " << ip << std::endl;
            return false;
        }
        std::vector<uint8_t> request = createModbusWriteSingleRegisterRequest(profile->iobox_info.modbus_address, address, value);
        if (!sendTcpMessage(ip, reinterpret_cast<const char*>(request.data()), request.size())) {
            return false;
        }

        char response[256];
        size_t responseLength = sizeof(response);
        if (!receiveTcpMessage(ip, response, responseLength)) {
            return false;
        }

        // Process the response as needed
        std::vector<uint8_t> responseVec(response, response + responseLength);
        if (responseVec.size() < 8) {
            std::cerr << "Invalid response length" << std::endl;
            return false;
        }

        // Verify CRC
        uint16_t receivedCrc = (responseVec[7] << 8) | responseVec[6];
        uint16_t calculatedCrc = calculateCRC(responseVec.data(), 6);
        if (receivedCrc != calculatedCrc) {
            std::cerr << "CRC check failed" << std::endl;
            return false;
        }

        // Check if the response matches the request
        if (responseVec[0] != request[0] || responseVec[1] != request[1] ||
            responseVec[2] != request[2] || responseVec[3] != request[3] ||
            responseVec[4] != request[4] || responseVec[5] != request[5]) {
            std::cerr << "Response does not match the request" << std::endl;
            return false;
        }

        std::cout << "Write single register succeeded" << std::endl;
        return true;
    }

    bool iobox_api::isValidChannelName(const std::string& channelName) {
        for (const std::string& name : this->channel_name) {
            if (name == channelName) {
                return true;
            }
        }
        return false;
    }
    bool iobox_api::getAllValueIobox(const std::string& ip)
    {
        iobox_profile_t* profile = findProfileByIp(ip);
        if (profile == nullptr) {
            std::cerr << "IP address not found: " << ip << std::endl;
            return false;
        }
        if (!getAllDataFromIobox(ip)) {
            std::cerr << "Failed to get data from IOBox: " << ip << std::endl;
            return false;
        }
        return true;
    }
    std::string iobox_api::getValueDataStringIoboxFromChannelName(const std::string& ip, const std::string& channelName) {
        if (!isValidChannelName(channelName)) {
            std::cerr << "Invalid channel name: " << channelName << std::endl;
            return "";
        }
        if (!getAllValueIobox(ip)) {
            std::cerr << "Failed to get all data from IOBox: " << ip << std::endl;
            return "";
        }
        int16_t value_int = 0;
        iobox_profile_t* profile = findProfileByIp(ip);
        if (profile == nullptr) {
            std::cerr << "IP address not found: " << ip << std::endl;
            return "";
        }
        if (channelName == "DO1") {
            value_int = profile->iobox_data.channel_DO[0];
        }
        else if (channelName == "DO2") {
            value_int = profile->iobox_data.channel_DO[1];
        }
        else if (channelName == "DO3") {
            value_int = profile->iobox_data.channel_DO[2];
        }
        else if (channelName == "DO4") {
            value_int = profile->iobox_data.channel_DO[3];
        }
        else if (channelName == "DI1") {
            value_int = profile->iobox_data.channel_DI[0];
        }
        else if (channelName == "DI2") {
            value_int = profile->iobox_data.channel_DI[1];
        }
        else if (channelName == "DI3") {
            value_int = profile->iobox_data.channel_DI[2];
        }
        else if (channelName == "DI4") {
            value_int = profile->iobox_data.channel_DI[3];
        }
        else if (channelName == "AI1") {
            value_int = profile->iobox_data.channel_AI[0];
        }
        else if (channelName == "AI2") {
            value_int = profile->iobox_data.channel_AI[1];
        }
        else {
            std::cerr << "Invalid channel name: " << channelName << std::endl;
            return "";
        }
        return std::to_string(value_int);
    }
    bool iobox_api::setValueDataStringIoboxFromChannelName(const std::string& ip, const std::string& channelName, const std::string& value) {
        iobox_profile_t* profile = findProfileByIp(ip);
        if (profile == nullptr) {
            std::cerr << "IP address not found: " << ip << std::endl;
            return false;
        }
        if (!isValidChannelName(channelName)) {
            std::cerr << "Invalid channel name: " << channelName << std::endl;
            return false;
        }

        int channelIndex = -1;
        for (channelIndex = 0; channelIndex < IOBOX_CHANNEL_NUM; channelIndex++) {
            if (this->channel_name[channelIndex] == channelName) {
                break;
            }
        }
        if (channelIndex == -1) {
            std::cerr << "Invalid channel name: " << channelName << std::endl;
            return false;
        }

        int16_t value_int = std::stoi(value);
        if (!setValueDataToIobox(ip, this->iobox_channel_address[channelIndex], value_int)) {
            std::cerr << "Failed to set data to IOBox: " << ip << std::endl;
            return false;
        }

        if (channelName == "DO1") {
            profile->iobox_data.channel_DO[0] = value_int;
        }
        else if (channelName == "DO2") {
            profile->iobox_data.channel_DO[1] = value_int;
        }
        else if (channelName == "DO3") {
            profile->iobox_data.channel_DO[2] = value_int;
        }
        else if (channelName == "DO4") {
            profile->iobox_data.channel_DO[3] = value_int;
        }
        else if (channelName == "DI1") {
            profile->iobox_data.channel_DI[0] = value_int;
        }
        else if (channelName == "DI2") {
            profile->iobox_data.channel_DI[1] = value_int;
        }
        else if (channelName == "DI3") {
            profile->iobox_data.channel_DI[2] = value_int;
        }
        else if (channelName == "DI4") {
            profile->iobox_data.channel_DI[3] = value_int;
        }
        else if (channelName == "AI1") {
            profile->iobox_data.channel_AI[0] = value_int;
        }
        else if (channelName == "AI2") {
            profile->iobox_data.channel_AI[1] = value_int;
        }
        else {
            std::cerr << "Invalid channel name: " << channelName << std::endl;
            return false;
        }
        return true;
    }
    void testGetAllValueFromChannelName(iobox_api& api, const std::string& ip) {
        std::vector<std::string> channelNames = { "DO1", "DO2", "DO3", "DO4", "DI1", "DI2", "DI3", "DI4", "AI1", "AI2" };
        for (const std::string& channelName : channelNames) {
            std::string value = api.getValueDataStringIoboxFromChannelName(ip, channelName);
            std::cout << "Channel " << channelName << ": " << value << std::endl;
        }
    }

    bool iobox_api::setAuthenticationIobox(const std::string& ip, const std::string& username, const std::string& password) {
        // Todo
		// Override default username and password
        return true;
    }

    std::vector<std::string> iobox_api::getDeviceChannelNames(const std::string& ip, int timeout) {
        // To do
		// Get channel names from IOBox (if available)
		std::vector<std::string> channelNames = { "DO1", "DO2", "DO3", "DO4", "DI1", "DI2", "DI3", "DI4", "AI1", "AI2" };
		return channelNames;
    }

}