/*
 *
 *    Copyright (c) 2021-2022 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

#include "ConnectivityUtils.h"

#include <errno.h>
#include <ifaddrs.h>
#include <linux/ethtool.h>
#include <linux/sockios.h>
#include <linux/wireless.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <unistd.h>

#include <cstring>

#include <lib/support/CHIPMemString.h>
#include <lib/support/logging/CHIPLogging.h>
#include <platform/Tizen/ConnectivityUtils.h>
#include <platform/internal/CHIPDeviceLayerInternal.h>

using namespace ::chip::app::Clusters::GeneralDiagnostics;
using namespace ::chip::app::Clusters::EthernetNetworkDiagnostics;

namespace {

constexpr uint16_t Map2400MHz(const uint8_t inChannel)
{
    if (inChannel >= 1 && inChannel <= 13)
        return static_cast<uint16_t>(2412 + ((inChannel - 1) * 5));
    if (inChannel == 14)
        return 2484;
    return 0;
}

constexpr uint8_t MapFrequencyToChannel(const uint16_t frequency)
{
    if (frequency < 2412)
        return 0;
    if (frequency < 2484)
        return static_cast<uint8_t>((frequency - 2407) / 5);
    if (frequency == 2484)
        return 14;
    return static_cast<uint8_t>(frequency / 5 - 1000);
}

constexpr uint16_t Map5000MHz(const uint8_t inChannel)
{
    switch (inChannel)
    {
    case 183:
        return 4915;
    case 184:
        return 4920;
    case 185:
        return 4925;
    case 187:
        return 4935;
    case 188:
        return 4940;
    case 189:
        return 4945;
    case 192:
        return 4960;
    case 196:
        return 4980;
    case 7:
        return 5035;
    case 8:
        return 5040;
    case 9:
        return 5045;
    case 11:
        return 5055;
    case 12:
        return 5060;
    case 16:
        return 5080;
    case 34:
        return 5170;
    case 36:
        return 5180;
    case 38:
        return 5190;
    case 40:
        return 5200;
    case 42:
        return 5210;
    case 44:
        return 5220;
    case 46:
        return 5230;
    case 48:
        return 5240;
    case 52:
        return 5260;
    case 56:
        return 5280;
    case 60:
        return 5300;
    case 64:
        return 5320;
    case 100:
        return 5500;
    case 104:
        return 5520;
    case 108:
        return 5540;
    case 112:
        return 5560;
    case 116:
        return 5580;
    case 120:
        return 5600;
    case 124:
        return 5620;
    case 128:
        return 5640;
    case 132:
        return 5660;
    case 136:
        return 5680;
    case 140:
        return 5700;
    case 149:
        return 5745;
    case 153:
        return 5765;
    case 157:
        return 5785;
    case 161:
        return 5805;
    case 165:
        return 5825;
    default:
        return 0;
    }
}

constexpr double ConvertFrequencyToFloat(const iw_freq * in)
{
    double result = (double) in->m;
    for (int i = 0; i < in->e; i++)
        result *= 10;
    return result;
}

CHIP_ERROR GetWiFiParameter(int sock,            /* Socket to the kernel */
                            const char * ifname, /* Device name */
                            int request,         /* WE ID */
                            struct iwreq * pwrq) /* Fixed part of the request */
{
    chip::Platform::CopyString(pwrq->ifr_name, ifname);
    if (ioctl(sock, request, pwrq) == -1)
        return CHIP_ERROR_POSIX(errno);
    return CHIP_NO_ERROR;
}

CHIP_ERROR GetWiFiStats(int sock, const char * ifname, struct iw_statistics * stats)
{
    struct iwreq wrq   = {};
    wrq.u.data.pointer = (caddr_t) stats;
    wrq.u.data.length  = sizeof(*stats);
    wrq.u.data.flags   = 1; /* Clear updated flag */
    return GetWiFiParameter(sock, ifname, SIOCGIWSTATS, &wrq);
}

} // namespace

namespace chip {
namespace DeviceLayer {
namespace Internal {
namespace ConnectivityUtils {

InterfaceTypeEnum GetInterfaceConnectionType(const char * ifname)
{
    InterfaceTypeEnum ret = InterfaceTypeEnum::kUnspecified;
    int sock              = -1;

    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        ChipLogError(DeviceLayer, "Failed to create INET socket: %s", strerror(errno));
        return ret;
    }

    // Test wireless extensions for CONNECTION_WIFI
    struct iwreq pwrq = {};
    Platform::CopyString(pwrq.ifr_name, ifname);

    if (ioctl(sock, SIOCGIWNAME, &pwrq) != -1)
    {
        ret = InterfaceTypeEnum::kWiFi;
    }
    else if ((strncmp(ifname, "en", 2) == 0) || (strncmp(ifname, "eth", 3) == 0))
    {
        struct ethtool_cmd ecmd = {};
        ecmd.cmd                = ETHTOOL_GSET;
        struct ifreq ifr        = {};
        ifr.ifr_data            = reinterpret_cast<char *>(&ecmd);
        Platform::CopyString(ifr.ifr_name, ifname);

        if (ioctl(sock, SIOCETHTOOL, &ifr) != -1)
            ret = InterfaceTypeEnum::kEthernet;
    }

    close(sock);

    return ret;
}

CHIP_ERROR GetInterfaceHardwareAddrs(const char * ifname, uint8_t * buf, size_t bufSize)
{
    CHIP_ERROR err = CHIP_NO_ERROR;

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    VerifyOrReturnError(sock != -1, CHIP_ERROR_POSIX(errno),
                        ChipLogError(DeviceLayer, "Failed to create INET socket: %s", strerror(errno)));

    struct ifreq req;
    Platform::CopyString(req.ifr_name, ifname);
    VerifyOrExit(ioctl(sock, SIOCGIFHWADDR, &req) != -1, err = CHIP_ERROR_POSIX(errno);
                 ChipLogError(DeviceLayer, "Failed to get hardware address: %s", strerror(errno)));

    // Copy 48-bit IEEE MAC Address
    VerifyOrExit(bufSize >= 6, err = CHIP_ERROR_BUFFER_TOO_SMALL);

    memset(buf, 0, bufSize);
    memcpy(buf, req.ifr_ifru.ifru_hwaddr.sa_data, 6);

exit:
    close(sock);
    return err;
}

CHIP_ERROR GetInterfaceIPv4Addrs(const char * ifname, uint8_t & size, NetworkInterface * ifp)
{
    CHIP_ERROR err          = CHIP_ERROR_READ_FAILED;
    struct ifaddrs * ifaddr = nullptr;

    if (getifaddrs(&ifaddr) == -1)
    {
        ChipLogError(DeviceLayer, "Failed to get network interfaces: %s", strerror(errno));
        return CHIP_ERROR_POSIX(errno);
    }

    uint8_t index = 0;
    for (struct ifaddrs * ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next)
    {
        if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET)
        {
            if (strcmp(ifname, ifa->ifa_name) == 0)
            {
                void * addPtr = &((struct sockaddr_in *) ifa->ifa_addr)->sin_addr;

                memcpy(ifp->Ipv4AddressesBuffer[index], addPtr, kMaxIPv4AddrSize);
                ifp->Ipv4AddressSpans[index] = ByteSpan(ifp->Ipv4AddressesBuffer[index], kMaxIPv4AddrSize);
                index++;

                if (index >= kMaxIPv4AddrCount)
                {
                    break;
                }
            }
        }
    }

    if (index > 0)
    {
        err  = CHIP_NO_ERROR;
        size = index;
    }

    freeifaddrs(ifaddr);
    return err;
}

CHIP_ERROR GetInterfaceIPv6Addrs(const char * ifname, uint8_t & size, NetworkInterface * ifp)
{
    CHIP_ERROR err          = CHIP_ERROR_READ_FAILED;
    struct ifaddrs * ifaddr = nullptr;

    if (getifaddrs(&ifaddr) == -1)
    {
        ChipLogError(DeviceLayer, "Failed to get network interfaces: %s", strerror(errno));
        return CHIP_ERROR_POSIX(errno);
    }

    uint8_t index = 0;
    for (struct ifaddrs * ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next)
    {
        if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET6)
        {
            if (strcmp(ifname, ifa->ifa_name) == 0)
            {
                void * addPtr = &((struct sockaddr_in6 *) ifa->ifa_addr)->sin6_addr;

                memcpy(ifp->Ipv6AddressesBuffer[index], addPtr, kMaxIPv6AddrSize);
                ifp->Ipv6AddressSpans[index] = ByteSpan(ifp->Ipv6AddressesBuffer[index], kMaxIPv6AddrSize);
                index++;

                if (index >= kMaxIPv6AddrCount)
                {
                    break;
                }
            }
        }
    }

    if (index > 0)
    {
        err  = CHIP_NO_ERROR;
        size = index;
    }

    freeifaddrs(ifaddr);
    return err;
}

CHIP_ERROR GetWiFiInterfaceName(char * ifname, size_t bufSize)
{
    CHIP_ERROR err          = CHIP_ERROR_READ_FAILED;
    struct ifaddrs * ifaddr = nullptr;

    if (getifaddrs(&ifaddr) == -1)
    {
        ChipLogError(DeviceLayer, "Failed to get network interfaces: %s", strerror(errno));
        return CHIP_ERROR_POSIX(errno);
    }

    struct ifaddrs * ifa = nullptr;
    for (ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next)
    {
        if (GetInterfaceConnectionType(ifa->ifa_name) == InterfaceTypeEnum::kWiFi)
        {
            Platform::CopyString(ifname, bufSize, ifa->ifa_name);
            err = CHIP_NO_ERROR;
            break;
        }
    }

    freeifaddrs(ifaddr);
    return err;
}

CHIP_ERROR GetWiFiChannelNumber(const char * ifname, uint16_t & channelNumber)
{
    CHIP_ERROR err;
    struct iwreq wrq;
    double freq;

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    VerifyOrReturnError(sock != -1, CHIP_ERROR_POSIX(errno),
                        ChipLogError(DeviceLayer, "Failed to create INET socket: %s", strerror(errno)));

    err = GetWiFiParameter(sock, ifname, SIOCGIWFREQ, &wrq);
    VerifyOrExit(err == CHIP_NO_ERROR,
                 ChipLogError(DeviceLayer, "Failed to get channel/frequency: %" CHIP_ERROR_FORMAT, err.Format()));

    freq = ConvertFrequencyToFloat(&(wrq.u.freq));
    VerifyOrExit((freq / 1000000) <= UINT16_MAX, err = CHIP_ERROR_INVALID_INTEGER_VALUE);
    channelNumber = MapFrequencyToChannel(static_cast<uint16_t>(freq / 1000000));

exit:
    close(sock);
    return err;
}

CHIP_ERROR GetWiFiRssi(const char * ifname, int8_t & rssi)
{
    CHIP_ERROR err;
    struct iw_statistics stats;

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    VerifyOrReturnError(sock != -1, CHIP_ERROR_POSIX(errno),
                        ChipLogError(DeviceLayer, "Failed to create INET socket: %s", strerror(errno)));

    err = GetWiFiStats(sock, ifname, &stats);
    VerifyOrExit(err == CHIP_NO_ERROR, ChipLogError(DeviceLayer, "Failed to get Wi-Fi stats: %" CHIP_ERROR_FORMAT, err.Format()));

    {
        struct iw_quality * qual = &stats.qual;
        if (qual->updated & IW_QUAL_RCPI)
        {
            /* RCPI = int{(Power in dBm +110)*2} for 0dbm > Power > -110dBm */
            if (!(qual->updated & IW_QUAL_LEVEL_INVALID))
            {
                double rcpilevel = (qual->level / 2.0) - 110.0;
                VerifyOrExit(rcpilevel <= INT8_MAX, err = CHIP_ERROR_INVALID_INTEGER_VALUE);
                rssi = static_cast<int8_t>(rcpilevel);
            }
        }
        else
        {
            if (qual->updated & IW_QUAL_DBM)
            {
                if (!(qual->updated & IW_QUAL_LEVEL_INVALID))
                {
                    int dblevel = qual->level;
                    /* dBm[-192; 63] */
                    if (qual->level >= 64)
                        dblevel -= 0x100;

                    VerifyOrExit(dblevel <= INT8_MAX, err = CHIP_ERROR_INVALID_INTEGER_VALUE);
                    rssi = static_cast<int8_t>(dblevel);
                }
            }
            else
            {
                if (!(qual->updated & IW_QUAL_LEVEL_INVALID))
                {
                    VerifyOrExit(qual->level <= INT8_MAX, err = CHIP_ERROR_INVALID_INTEGER_VALUE);
                    rssi = static_cast<int8_t>(qual->level);
                }
            }
        }
    }

exit:
    close(sock);
    return err;
}

CHIP_ERROR GetWiFiBeaconLostCount(const char * ifname, uint32_t & beaconLostCount)
{
    CHIP_ERROR err;
    struct iw_statistics stats;

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    VerifyOrReturnError(sock != -1, CHIP_ERROR_POSIX(errno),
                        ChipLogError(DeviceLayer, "Failed to create INET socket: %s", strerror(errno)));

    err = GetWiFiStats(sock, ifname, &stats);
    VerifyOrExit(err == CHIP_NO_ERROR, ChipLogError(DeviceLayer, "Failed to get Wi-Fi stats: %" CHIP_ERROR_FORMAT, err.Format()));

    beaconLostCount = stats.miss.beacon;

exit:
    close(sock);
    return err;
}

CHIP_ERROR GetWiFiCurrentMaxRate(const char * ifname, uint64_t & currentMaxRate)
{
    CHIP_ERROR err;
    struct iwreq wrq;

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    VerifyOrReturnError(sock != -1, CHIP_ERROR_POSIX(errno),
                        ChipLogError(DeviceLayer, "Failed to create INET socket: %s", strerror(errno)));

    err = GetWiFiParameter(sock, ifname, SIOCGIWRATE, &wrq);
    VerifyOrExit(err == CHIP_NO_ERROR,
                 ChipLogError(DeviceLayer, "Failed to get channel/frequency: %" CHIP_ERROR_FORMAT, err.Format()));

    currentMaxRate = wrq.u.bitrate.value;

exit:
    close(sock);
    return err;
}

CHIP_ERROR GetEthInterfaceName(char * ifname, size_t bufSize)
{
    CHIP_ERROR err          = CHIP_ERROR_READ_FAILED;
    struct ifaddrs * ifaddr = nullptr;

    if (getifaddrs(&ifaddr) == -1)
    {
        ChipLogError(DeviceLayer, "Failed to get network interfaces: %s", strerror(errno));
        return CHIP_ERROR_POSIX(errno);
    }

    struct ifaddrs * ifa = nullptr;
    for (ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next)
    {
        if (GetInterfaceConnectionType(ifa->ifa_name) == InterfaceTypeEnum::kEthernet)
        {
            Platform::CopyString(ifname, bufSize, ifa->ifa_name);
            err = CHIP_NO_ERROR;
            break;
        }
    }

    freeifaddrs(ifaddr);
    return err;
}

CHIP_ERROR GetEthPHYRate(const char * ifname, PHYRateEnum & pHYRate)
{
    CHIP_ERROR err          = CHIP_NO_ERROR;
    uint32_t speed          = 0;
    struct ethtool_cmd ecmd = {};
    ecmd.cmd                = ETHTOOL_GSET;
    struct ifreq ifr        = {};

    ifr.ifr_data = reinterpret_cast<char *>(&ecmd);
    Platform::CopyString(ifr.ifr_name, ifname);

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    VerifyOrReturnError(sock != -1, CHIP_ERROR_POSIX(errno),
                        ChipLogError(DeviceLayer, "Failed to create INET socket: %s", strerror(errno)));

    VerifyOrExit(ioctl(sock, SIOCETHTOOL, &ifr) != -1, err = CHIP_ERROR_POSIX(errno);
                 ChipLogError(DeviceLayer, "Cannot get device settings: %s", strerror(errno)));

    speed = (ecmd.speed_hi << 16) | ecmd.speed;
    switch (speed)
    {
    case 10:
        pHYRate = app::Clusters::EthernetNetworkDiagnostics::PHYRateEnum::kRate10M;
        break;
    case 100:
        pHYRate = app::Clusters::EthernetNetworkDiagnostics::PHYRateEnum::kRate100M;
        break;
    case 1000:
        pHYRate = app::Clusters::EthernetNetworkDiagnostics::PHYRateEnum::kRate1G;
        break;
    case 25000:
        pHYRate = app::Clusters::EthernetNetworkDiagnostics::PHYRateEnum::kRate25g;
        break;
    case 5000:
        pHYRate = app::Clusters::EthernetNetworkDiagnostics::PHYRateEnum::kRate5G;
        break;
    case 10000:
        pHYRate = app::Clusters::EthernetNetworkDiagnostics::PHYRateEnum::kRate10G;
        break;
    case 40000:
        pHYRate = app::Clusters::EthernetNetworkDiagnostics::PHYRateEnum::kRate40G;
        break;
    case 100000:
        pHYRate = app::Clusters::EthernetNetworkDiagnostics::PHYRateEnum::kRate100G;
        break;
    case 200000:
        pHYRate = app::Clusters::EthernetNetworkDiagnostics::PHYRateEnum::kRate200G;
        break;
    case 400000:
        pHYRate = app::Clusters::EthernetNetworkDiagnostics::PHYRateEnum::kRate400G;
        break;
    default:
        ChipLogError(DeviceLayer, "Undefined speed! (%d)\n", speed);
        err = CHIP_ERROR_READ_FAILED;
        break;
    };

exit:
    close(sock);
    return err;
}

CHIP_ERROR GetEthFullDuplex(const char * ifname, bool & fullDuplex)
{
    CHIP_ERROR err          = CHIP_NO_ERROR;
    struct ethtool_cmd ecmd = {};
    ecmd.cmd                = ETHTOOL_GSET;
    struct ifreq ifr        = {};

    ifr.ifr_data = reinterpret_cast<char *>(&ecmd);
    Platform::CopyString(ifr.ifr_name, ifname);

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    VerifyOrReturnError(sock != -1, CHIP_ERROR_POSIX(errno),
                        ChipLogError(DeviceLayer, "Failed to create INET socket: %s", strerror(errno)));

    VerifyOrExit(ioctl(sock, SIOCETHTOOL, &ifr) != -1, err = CHIP_ERROR_POSIX(errno);
                 ChipLogError(DeviceLayer, "Cannot get device settings: %s", strerror(errno)));

    fullDuplex = ecmd.duplex == DUPLEX_FULL;

exit:
    close(sock);
    return err;
}

} // namespace ConnectivityUtils
} // namespace Internal
} // namespace DeviceLayer
} // namespace chip