/*
 *
 *    Copyright (c) 2019 Google LLC
 *    Copyright (c) 2013-2017 Nest Labs, Inc.
 *    All rights reserved.
 *
 *    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.
 */

/**
 *    @file
 *      Objective-C representation of NetworkInfo payload communicated via network-provisioning profile.
 *
 */

#import "NLNetworkInfo_Protected.h"

// using nl::Weave::Profiles::NetworkProvisioning;
using nl::Weave::Profiles::NetworkProvisioning::NetworkType;
using nl::Weave::Profiles::NetworkProvisioning::WiFiMode;
using nl::Weave::Profiles::NetworkProvisioning::WiFiRole;
using nl::Weave::Profiles::NetworkProvisioning::WiFiSecurityType;

const int64_t NLNetworkID_NotSpecified = -1LL;
const int NLThreadPANId_NotSpecified = -1;
const int NLThreadChannel_NotSpecified = -1;

@implementation NLNetworkInfo

+ (NLNetworkInfo *)createUsing:(NetworkInfo *)pNetworkInfo
{
    return [[NLNetworkInfo alloc] initWith:pNetworkInfo];
}

- (instancetype)initWithWiFiSSID:(NSString *)ssid wifiKey:(NSData *)wifiKey securityType:(NLWiFiSecurityType)securityType
{
    if (self = [self init]) {
        _WiFiSSID = ssid;

        if (wifiKey)
            _WiFiKey = wifiKey;

        _WiFiSecurityType = securityType;

        _NetworkType = kNLNetworkType_WiFi;
        _WiFiMode = kNLWiFiMode_Managed;
        _WiFiRole = kNLWiFiRole_Station;
    }
    return self;
}

- (instancetype)init {
    nl::Weave::DeviceManager::NetworkInfo defaultNetworkInfo;
    return self = [self initWith:&defaultNetworkInfo];
}

- (instancetype)initWith:(nl::Weave::DeviceManager::NetworkInfo *)pNetworkInfo
{
    if (self = [super init]) {
        _NetworkType = (NLNetworkType) pNetworkInfo->NetworkType;
        _NetworkId = pNetworkInfo->NetworkId;

        if (pNetworkInfo->WiFiSSID) {
            _WiFiSSID = [[NSString alloc] initWithCString:pNetworkInfo->WiFiSSID encoding:NSUTF8StringEncoding];
            _WiFiMode = (NLWiFiMode) pNetworkInfo->WiFiMode;
            _WiFiRole = (NLWiFiRole) pNetworkInfo->WiFiRole;
            _WiFiSecurityType = (NLWiFiSecurityType) pNetworkInfo->WiFiSecurityType;
        }

        if (pNetworkInfo->WiFiKey) {
            printf("pNetworkInfo->WiFiKey: %s\n", pNetworkInfo->WiFiKey);
            _WiFiKey = [NSData dataWithBytes:pNetworkInfo->WiFiKey length:pNetworkInfo->WiFiKeyLen];
        }

        if (pNetworkInfo->ThreadNetworkName)
            _ThreadNetworkName = [[NSString alloc] initWithCString:pNetworkInfo->ThreadNetworkName encoding:NSUTF8StringEncoding];

        if (pNetworkInfo->ThreadExtendedPANId) {
            _ThreadExtendedPANId = [[NSData alloc] initWithBytes:pNetworkInfo->ThreadExtendedPANId length:nl::Weave::DeviceManager::NetworkInfo::kThreadExtendedPANIdLength];
        }

        if (pNetworkInfo->ThreadNetworkKey) {
            _ThreadNetworkKey = [[NSData alloc] initWithBytes:pNetworkInfo->ThreadNetworkKey
                                                       length:nl::Weave::DeviceManager::NetworkInfo::kThreadNetworkKeyLength];
            NSLog(@"_ThreadNetworkKey: %@", _ThreadNetworkKey);
        }

        if (pNetworkInfo->ThreadPSKc) {
            _ThreadPSKc = [[NSData alloc] initWithBytes:pNetworkInfo->ThreadPSKc
                                                       length:nl::Weave::DeviceManager::NetworkInfo::kThreadPSKcLength];
            NSLog(@"_ThreadPSKc: %@", _ThreadPSKc);
        }

        _ThreadPANId = pNetworkInfo->ThreadPANId;
        _ThreadChannel = pNetworkInfo->ThreadChannel;

        _WirelessSignalStrength = pNetworkInfo->WirelessSignalStrength;
    }
    return self;
}

- (id)copyWithZone:(NSZone *)zone
{
    NLNetworkInfo * networkInfo = [[NLNetworkInfo allocWithZone:zone] init];

    networkInfo.NetworkType = self.NetworkType;
    networkInfo.NetworkId = self.NetworkId;

    networkInfo.WiFiSSID = [self.WiFiSSID copy];
    networkInfo.WiFiMode = self.WiFiMode;
    networkInfo.WiFiRole = self.WiFiRole;

    networkInfo.WiFiSecurityType = self.WiFiSecurityType;

    networkInfo.WiFiKey = [self.WiFiKey copy];

    networkInfo.ThreadNetworkName = [self.ThreadNetworkName copy];
    networkInfo.ThreadExtendedPANId = [self.ThreadExtendedPANId copy];
    networkInfo.ThreadNetworkKey = [self.ThreadNetworkKey copy];
    networkInfo.ThreadPSKc = [self.ThreadPSKc copy];
    networkInfo.ThreadPANId = self.ThreadPANId;
    networkInfo.ThreadChannel = self.ThreadChannel;

    networkInfo.WirelessSignalStrength = self.WirelessSignalStrength;

    return networkInfo;
}

#pragma mark - Protected methods

- (NetworkInfo)toNetworkInfo
{

    NetworkInfo networkInfo;

    networkInfo.NetworkType = [self toNetworkType:_NetworkType];
    printf("toNetworkInfo, _NetworkId, %lld\n", _NetworkId);
    networkInfo.NetworkId = _NetworkId;

    if (_WiFiSSID)
        networkInfo.WiFiSSID = strdup([_WiFiSSID UTF8String]);

    networkInfo.WiFiMode = [self toWifiMode:_WiFiMode];
    networkInfo.WiFiRole = [self toWifiRole:_WiFiRole];
    networkInfo.WiFiSecurityType = [self toWifiSecurityType:_WiFiSecurityType];

    if (_WiFiKey) {
        networkInfo.WiFiKeyLen = [_WiFiKey length];
        networkInfo.WiFiKey = (uint8_t *) malloc(networkInfo.WiFiKeyLen);
        assert(networkInfo.WiFiKey != NULL);
        memcpy(networkInfo.WiFiKey, [_WiFiKey bytes], networkInfo.WiFiKeyLen);
    }

    if (_ThreadNetworkName)
        networkInfo.ThreadNetworkName = strdup([_ThreadNetworkName UTF8String]);

    if (_ThreadExtendedPANId) {
        networkInfo.ThreadExtendedPANId = (uint8_t *) malloc(8);
        memcpy(networkInfo.ThreadExtendedPANId, [_ThreadExtendedPANId bytes], 8);
    }

    if (_ThreadNetworkKey) {
        networkInfo.ThreadNetworkKey = (uint8_t *) malloc(NetworkInfo::kThreadNetworkKeyLength);
        memcpy(networkInfo.ThreadNetworkKey, [_ThreadNetworkKey bytes], NetworkInfo::kThreadNetworkKeyLength);
    }

    if (_ThreadPSKc) {
        networkInfo.ThreadPSKc = (uint8_t *) malloc(NetworkInfo::kThreadPSKcLength);
        memcpy(networkInfo.ThreadPSKc, [_ThreadPSKc bytes], NetworkInfo::kThreadPSKcLength);
    }

    networkInfo.ThreadPANId = _ThreadPANId;
    networkInfo.ThreadChannel = _ThreadChannel;
    networkInfo.WirelessSignalStrength = _WirelessSignalStrength;

    return networkInfo;
}

- (nl::Weave::Profiles::NetworkProvisioning::NetworkType)toNetworkType:(NLNetworkType)networkType
{
    switch (networkType) {
    case kNLNetworkType_WiFi:
        return nl::Weave::Profiles::NetworkProvisioning::kNetworkType_WiFi;
    case kNLNetworkType_Thread:
        return nl::Weave::Profiles::NetworkProvisioning::kNetworkType_Thread;
    default:
        return nl::Weave::Profiles::NetworkProvisioning::kNetworkType_NotSpecified;
    }
}

- (nl::Weave::Profiles::NetworkProvisioning::WiFiMode)toWifiMode:(NLWiFiMode)mode
{
    switch (mode) {
    case kNLWiFiMode_AdHoc:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiMode_AdHoc;
    case kNLWiFiMode_Managed:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiMode_Managed;
    default:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiMode_NotSpecified;
    }
}

- (nl::Weave::Profiles::NetworkProvisioning::WiFiRole)toWifiRole:(NLWiFiRole)role
{
    switch (role) {
    case kNLWiFiRole_Station:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiRole_Station;
    case kNLWiFiRole_AccessPoint:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiRole_AccessPoint;
    default:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiRole_NotSpecified;
    }
}

- (nl::Weave::Profiles::NetworkProvisioning::WiFiSecurityType)toWifiSecurityType:(NLWiFiSecurityType)securityType
{
    switch (securityType) {
    case kNLWiFiSecurityType_NotSpecified:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiSecurityType_NotSpecified;
    case kNLWiFiSecurityType_None:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiSecurityType_None;
    case kNLWiFiSecurityType_WEP:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiSecurityType_WEP;
    case kNLWiFiSecurityType_WPAPersonal:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiSecurityType_WPAPersonal;
    case kNLWiFiSecurityType_WPA2Personal:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiSecurityType_WPA2Personal;
    case kNLWiFiSecurityType_WPA2MixedPersonal:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiSecurityType_WPA2MixedPersonal;
    case kNLWiFiSecurityType_WPAEnterprise:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiSecurityType_WPAEnterprise;
    case kNLWiFiSecurityType_WPA2Enterprise:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiSecurityType_WPA2Enterprise;
    case kNLWiFiSecurityType_WPA2MixedEnterprise:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiSecurityType_WPA2MixedEnterprise;
    case kNLWiFiSecurityType_WPA3Personal:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiSecurityType_WPA3Personal;
    case kNLWiFiSecurityType_WPA3MixedPersonal:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiSecurityType_WPA3MixedPersonal;
    case kNLWiFiSecurityType_WPA3Enterprise:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiSecurityType_WPA3Enterprise;
    case kNLWiFiSecurityType_WPA3MixedEnterprise:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiSecurityType_WPA3MixedEnterprise;
    default:
        return nl::Weave::Profiles::NetworkProvisioning::kWiFiSecurityType_NotSpecified;
    }
}

#pragma mark - Public methods

- (NSString *)WiFiSecurityTypeAsString
{
    switch (_WiFiSecurityType) {
    case kNLWiFiSecurityType_NotSpecified:
        return @"NotSpecified";
    case kNLWiFiSecurityType_None:
        return @"None";
    case kNLWiFiSecurityType_WEP:
        return @"WEP";
    case kNLWiFiSecurityType_WPAPersonal:
        return @"WPAPersonal";
    case kNLWiFiSecurityType_WPA2Personal:
        return @"WPA2Personal";
    case kNLWiFiSecurityType_WPA2MixedPersonal:
        return @"WPA2MixedPersonal";
    case kNLWiFiSecurityType_WPAEnterprise:
        return @"WPAEnterprise";
    case kNLWiFiSecurityType_WPA2Enterprise:
        return @"WPA2Enterprise";
    case kNLWiFiSecurityType_WPA2MixedEnterprise:
        return @"WPA2MixedEnterprise";
    default:
        return @"Unknown NLWiFiSecurityType";
    }
}

#pragma mark - Private methods

- (NSString *)debugDescriptionWithNetworkInfo:(nl::Weave::DeviceManager::NetworkInfo *)pNetworkInfo
{
    NSString * descr =
        [NSString stringWithFormat:@"(%p), \n"
                                    "\tNetworkType: %d\n"
                                    "\tNetworkId: %lld\n"
                                    "\tWiFiSSID: %s\n"
                                    "\tWiFiMode: %d\n"
                                    "\tWiFiRole: %d\n"
                                    "\tWiFiSecurityType: %d\n"
                                    "\tWiFiKey: %s\n"
                                    "\tThreadNetworkName: %s\n"
                                    "\tThreadPANId: %04x\n"
                                    "\tThreadExtendedPANId: %s\n"
                                    "\tThreadChannel: %d\n"
                                    "\tWirelessSignalStrength: %d",
                  self, pNetworkInfo->NetworkType, pNetworkInfo->NetworkId, pNetworkInfo->WiFiSSID, pNetworkInfo->WiFiMode,
                  pNetworkInfo->WiFiRole, pNetworkInfo->WiFiSecurityType, pNetworkInfo->WiFiKey,
#if NLNETWORKINFO_DEBUG
                  pNetworkInfo->WiFiKey ? "*********" : "none",
#endif
                  pNetworkInfo->ThreadNetworkName, pNetworkInfo->ThreadPANId, pNetworkInfo->ThreadExtendedPANId,
                  pNetworkInfo->ThreadChannel, pNetworkInfo->WirelessSignalStrength];

    return descr;
}

- (NSString *)debugDescription
{
    NSMutableString * descr = [[NSMutableString alloc] init];
    NSString * line = [NSString stringWithFormat:@"(%p), \n"
                                                  "\tNetworkType: %ld\n",
                                self, (long) _NetworkType];

    [descr appendString:line];
    if (_NetworkId != NLNetworkID_NotSpecified) {
        line = [NSString stringWithFormat:@"\tNetworkId: %lld\n", _NetworkId];
        [descr appendString:line];
    } else {
        [descr appendString:@"NetworkId: -1 (Unspecified)"];
    }

    if (_WiFiSSID) {
        line = [NSString stringWithFormat:@"\tWiFiSSID: %@\n", _WiFiSSID];
        [descr appendString:line];
    }

    line = [NSString stringWithFormat:@"\tWiFiMode: %ld\n"
                                       "\tWiFiRole: %ld\n"
                                       "\tWiFiSecurityType: %ld\n"
                                       "\tWirelessSignalStrength: %ld\n",
                     (long) _WiFiMode, (long) _WiFiRole, (long) _WiFiSecurityType, (long) _WirelessSignalStrength];
    [descr appendString:line];

    if (_WiFiKey) {
        line = [NSString stringWithFormat:@"\tWiFiKey: <exists>\n"];
        [descr appendString:line];
    }

    if (_ThreadNetworkName) {
        line = [NSString stringWithFormat:@"\tThreadNetworkName: %@\n", _ThreadNetworkName];
        [descr appendString:line];
    }

    if (_ThreadPANId != NLThreadPANId_NotSpecified) {
        line = [NSString stringWithFormat:@"\tThreadPANId: %04x\n", _ThreadPANId];
        [descr appendString:line];
    }

    if (_ThreadExtendedPANId) {
        line = [NSString stringWithFormat:@"\tThreadExtendedPANId: %@\n", _ThreadExtendedPANId];
        [descr appendString:line];
    }

    if (_ThreadNetworkKey) {
        line = [NSString stringWithFormat:@"\tThreadNetworkKey: %@\n", _ThreadNetworkKey];
        [descr appendString:line];
    }

    if (_ThreadPSKc) {
        line = [NSString stringWithFormat:@"\tThreadPSKc: %@\n", _ThreadPSKc];
        [descr appendString:line];
    }

    if (_ThreadChannel != NLThreadChannel_NotSpecified) {
        line = [NSString stringWithFormat:@"\tThreadChannel: %d\n", _ThreadChannel];
        [descr appendString:line];
    }

    return descr;
}

@end