/*
 *  Copyright (c) 2016, The OpenThread Authors.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the copyright holder nor the
 *     names of its contributors may be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#define OTDLL 1
#include <openthread/openthread.h>
#include <openthread/border_router.h>
#include <openthread/thread_ftd.h>
#include <openthread/commissioner.h>
#include <openthread/joiner.h>

#include <wrl.h>
#include <collection.h>

using namespace Platform;
using namespace Platform::Collections;
using namespace Platform::Metadata;
using namespace Windows::Foundation::Collections;
using namespace Windows::Networking;

namespace ot
{

ref class otAdapter;

public delegate void otAdapterRemovalDelegate(otAdapter^ sender);

public delegate void otIpAddressAddedDelegate(otAdapter^ sender);
public delegate void otIpAddressRemovedDelegate(otAdapter^ sender);
public delegate void otIpRlocAddedDelegate(otAdapter^ sender);
public delegate void otIpRlocRemovedDelegate(otAdapter^ sender);
public delegate void otIpLinkLocalAddresChangedDelegate(otAdapter^ sender);
public delegate void otIpMeshLocalAddresChangedDelegate(otAdapter^ sender);

public delegate void otNetRoleChangedDelegate(otAdapter^ sender);
public delegate void otNetPartitionIdChangedDelegate(otAdapter^ sender);
public delegate void otNetKeySequenceCounterChangedDelegate(otAdapter^ sender);

public delegate void otThreadChildAddedDelegate(otAdapter^ sender);
public delegate void otThreadChildRemovedDelegate(otAdapter^ sender);
public delegate void otThreadNetDataUpdatedDelegate(otAdapter^ sender);

[Flags]
public enum class otLinkModeFlags : unsigned int
{
    None                = 0,
    RxOnWhenIdle        = 0x1,  /* 1, if the sender has its receiver on when not transmitting.  0, otherwise. */
    SecureDataRequests  = 0x2,  /* 1, if the sender will use IEEE 802.15.4 to secure all data requests.  0, otherwise. */
    DeviceType          = 0x4,  /* 1, if the sender is an FFD.  0, otherwise. */
    NetworkData         = 0x8   /* 1, if the sender requires the full Network Data.  0, otherwise. */
};

public enum class otThreadState
{
    Offline,
    Disabled,
    Detached,
    Child,
    Router,
    Leader
};

// Helper class for OpenThread Interface/Adapter specific APIs
public ref class otAdapter sealed
{
private:

    void *_Instance;
    #define DeviceInstance ((otInstance*)_Instance)

    #define ThrowOnFailure(exp) \
    do { \
        auto res = exp; \
        if (res != 0) \
            throw Exception::CreateException(TheadErrorToHResult(res), #exp); \
    } while (false)

public:

#pragma region Events

    event otAdapterRemovalDelegate^                 AdapterRemoval;

    event otIpAddressAddedDelegate^                 IpAddressAdded;
    event otIpAddressRemovedDelegate^               IpAddressRemoved;
    event otIpRlocAddedDelegate^                    IpRlocAdded;
    event otIpRlocRemovedDelegate^                  IpRlocRemoved;
    event otIpLinkLocalAddresChangedDelegate^       IpLinkLocalAddresChanged;
    event otIpMeshLocalAddresChangedDelegate^       IpMeshLocalAddresChanged;

    event otNetRoleChangedDelegate^                 NetRoleChanged;
    event otNetPartitionIdChangedDelegate^          NetPartitionIdChanged;
    event otNetKeySequenceCounterChangedDelegate^   NetKeySequenceCounterChanged;

    event otThreadChildAddedDelegate^               ThreadChildAdded;
    event otThreadChildRemovedDelegate^             ThreadChildRemoved;
    event otThreadNetDataUpdatedDelegate^           ThreadNetDataUpdated;

#pragma endregion

#pragma region Properties

    property IntPtr RawHandle
    {
        IntPtr get() { return _Instance; }
    }

    property Guid InterfaceGuid
    {
        Guid get() { return otGetDeviceGuid(DeviceInstance); }
    }

    property uint32_t IfIndex
    {
        uint32_t get() { return otGetDeviceIfIndex(DeviceInstance); }
    }

    property uint32_t CompartmentId
    {
        uint32_t get() { return otGetCompartmentId(DeviceInstance); }
    }

#pragma region Link Layer

    property signed int /*int8_t*/ MaxTransmitPower
    {
        signed int get() { return otLinkGetMaxTransmitPower(DeviceInstance); }
        void set(signed int value)
        {
            if (value > 127) throw Exception::CreateException(E_INVALIDARG);
            otLinkSetMaxTransmitPower(DeviceInstance, (int8_t)value);
        }
    }

    property uint32_t PollPeriod
    {
        uint32_t get() { return otLinkGetPollPeriod(DeviceInstance); }
        void set(uint32_t value) { otLinkSetPollPeriod(DeviceInstance, value); }
    }

    property uint8_t Channel
    { 
        uint8_t get() { return otLinkGetChannel(DeviceInstance); }
        void set(uint8_t value) { ThrowOnFailure(otLinkSetChannel(DeviceInstance, value)); }
    }

    property uint16_t PanId
    {
        uint16_t get() { return otLinkGetPanId(DeviceInstance); }
        void set(uint16_t value) { ThrowOnFailure(otLinkSetPanId(DeviceInstance, value)); }
    }

    property uint16_t ShortAddress
    {
        uint16_t get() { return otLinkGetShortAddress(DeviceInstance); }
    }

    property uint64_t ExtendedAddress
    {
        uint64_t get()
        {
            auto addr = otLinkGetExtendedAddress(DeviceInstance);
            auto ret = *(uint64_t*)addr;
            otFreeMemory(addr);
            return ret;
        }
        void set(uint64_t value) 
        {
            ThrowOnFailure(otLinkSetExtendedAddress(DeviceInstance, (otExtAddress*)&value));
        }
    }

    property uint64_t FactoryAssignedIeeeEui64
    {
        uint64_t get()
        {
            uint64_t addr;
            otLinkGetFactoryAssignedIeeeEui64(DeviceInstance, (otExtAddress*)&addr);
            return addr;
        }
    }

    property uint64_t JoinerId
    {
        uint64_t get()
        {
            uint64_t addr;
            otLinkGetJoinerId(DeviceInstance, (otExtAddress*)&addr);
            return addr;
        }
    }

#pragma endregion

#pragma region IP Layer

    property bool IpEnabled
    {
        bool get() { return otIp6IsEnabled(DeviceInstance); }
        void set(bool value) { ThrowOnFailure(otIp6SetEnabled(DeviceInstance, value)); }
    }

#pragma endregion

#pragma region Thread Layer

    property uint64_t ExtendedPanId
    {
        uint64_t get()
        {
            auto panid = otThreadGetExtendedPanId(DeviceInstance);
            auto ret = *(uint64_t*)panid;
            otFreeMemory(panid);
            return ret;
        }
        void set(uint64_t value)
        {
            otThreadSetExtendedPanId(DeviceInstance, (uint8_t*)&value);
        }
    }

    property otLinkModeFlags LinkMode
    {
        otLinkModeFlags get()
        {
            auto linkmode = otThreadGetLinkMode(DeviceInstance);
            otLinkModeFlags flags = otLinkModeFlags::None;
            if (linkmode.mRxOnWhenIdle)         flags = flags | otLinkModeFlags::RxOnWhenIdle;
            if (linkmode.mSecureDataRequests)   flags = flags | otLinkModeFlags::SecureDataRequests;
            if (linkmode.mDeviceType)           flags = flags | otLinkModeFlags::DeviceType;
            if (linkmode.mNetworkData)          flags = flags | otLinkModeFlags::NetworkData;
            return flags;
        }
        void set(otLinkModeFlags value)
        {
            otLinkModeConfig linkmode = { 0 };
            if ((value & otLinkModeFlags::RxOnWhenIdle) != otLinkModeFlags::None)
                linkmode.mRxOnWhenIdle = true;
            if ((value & otLinkModeFlags::SecureDataRequests) != otLinkModeFlags::None)
                linkmode.mSecureDataRequests = true;
            if ((value & otLinkModeFlags::DeviceType) != otLinkModeFlags::None)
                linkmode.mDeviceType = true;
            if ((value & otLinkModeFlags::NetworkData) != otLinkModeFlags::None)
                linkmode.mNetworkData = true;
            ThrowOnFailure(otThreadSetLinkMode(DeviceInstance, linkmode));
        }
    }

    static uint32_t charToValue(wchar_t c)
    {
        if (c >= L'a' && c <= L'f')
        {
            return c - L'a';
        }
        else if (c >= L'A' && c <= L'F')
        {
            return c - L'A';
        }
        else if (c >= L'0' && c <= L'9')
        {
            return c - L'0';
        }
        else
        {
            throw Exception::CreateException(E_INVALIDARG);
        }
    }

    property String^ MasterKey
    {
        String^ get()
        {
            constexpr char hexmap[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
            auto key = otThreadGetMasterKey(DeviceInstance);
            WCHAR szKey[OT_MASTER_KEY_SIZE * 2 + 1] = { 0 };
            for (uint8_t i = 0; i < OT_MASTER_KEY_SIZE; i++)
            {
                szKey[2 * i]     = hexmap[(key->m8[i] & 0xF0) >> 4];
                szKey[2 * i + 1] = hexmap[key->m8[i] & 0x0F];
            }
            otFreeMemory(key);
            return ref new String(szKey);
        }
        void set(String^ value)
        {
            otMasterKey key;
            uint8_t keyLen = 0;
            for (uint32_t i = 0; i < value->Length() - 1; i+=2)
            {
                key.m8[keyLen++] = (uint8_t)((charToValue(value->Data()[i]) << 4) |
                    charToValue(value->Data()[i + 1]));
            }
            if (keyLen * 2 == value->Length() - 1)
            {
                key.m8[keyLen++] = (uint8_t)(charToValue(value->Data()[value->Length()-1])) << 4;
            }
            memset(key.m8 + keyLen, 0, sizeof(key) - keyLen);
            ThrowOnFailure(otThreadSetMasterKey(DeviceInstance, &key));
        }
    }

    property String^ NetworkName
    {
        String^ get()
        {
            auto _name = otThreadGetNetworkName(DeviceInstance);
            WCHAR name[OT_NETWORK_NAME_MAX_SIZE + 1];
            MultiByteToWideChar(CP_UTF8, 0, _name, -1, name, ARRAYSIZE(name));
            otFreeMemory(_name);
            return ref new String(name);
        }
        void set(String^ value)
        {
            char name[OT_NETWORK_NAME_MAX_SIZE + 1];
            auto len = WideCharToMultiByte(CP_UTF8, 0, value->Data(), -1, name, ARRAYSIZE(name), nullptr, nullptr);
            if (len <= 0) throw Exception::CreateException(E_INVALIDARG);
            ThrowOnFailure(otThreadSetNetworkName(DeviceInstance, name));
        }
    }

    property uint8_t MaxAllowedChildren
    {
        uint8_t get() { return otThreadGetMaxAllowedChildren(DeviceInstance); }
        void set(uint8_t value) { ThrowOnFailure(otThreadSetMaxAllowedChildren(DeviceInstance, value)); }
    }

    property uint32_t ChildTimeout
    {
        uint32_t get() { return otThreadGetChildTimeout(DeviceInstance); }
        void set(uint32_t value) { otThreadSetChildTimeout(DeviceInstance, value); }
    }

    property bool ThreadEnabled
    {
        //bool get() { return otIsThreadStarted(DeviceInstance); }
        void set(bool value) { ThrowOnFailure(otThreadSetEnabled(DeviceInstance, value)); }
    }

    property bool AutoStart
    {
        bool get() { return otThreadGetAutoStart(DeviceInstance); }
        void set(bool value) { ThrowOnFailure(otThreadSetAutoStart(DeviceInstance, value)); }
    }

    property bool Singleton
    {
        bool get() { return otThreadIsSingleton(DeviceInstance); }
    }

    property bool RouterRoleEnabled
    {
        bool get() { return otThreadIsRouterRoleEnabled(DeviceInstance); }
        void set(bool value) { otThreadSetRouterRoleEnabled(DeviceInstance, value); }
    }

    property uint8_t PreferredRouterId
    {
        void set(uint8_t value) { ThrowOnFailure(otThreadSetPreferredRouterId(DeviceInstance, value)); }
    }

    property HostName^ MeshLocalEid
    {
        HostName^ get()
        {
            auto addr = otThreadGetMeshLocalEid(DeviceInstance);
            WCHAR szAddr[46];
            RtlIpv6AddressToString((IN6_ADDR*)addr, szAddr);
            otFreeMemory(addr);
            return ref new HostName(ref new String(szAddr));
        }
    }

    property HostName^ LeaderRloc
    {
        HostName^ get()
        {
            IN6_ADDR addr;
            ThrowOnFailure(otThreadGetLeaderRloc(DeviceInstance, (otIp6Address*)&addr));
            WCHAR szAddr[46];
            RtlIpv6AddressToString(&addr, szAddr);
            return ref new HostName(ref new String(szAddr));
        }
    }

    property uint8_t LocalLeaderWeight
    {
        uint8_t get() { return otThreadGetLocalLeaderWeight(DeviceInstance); }
        void set(uint8_t value) { otThreadSetLocalLeaderWeight(DeviceInstance, value); }
    }

    property uint32_t LocalLeaderPartitionId
    {
        uint32_t get() { return otThreadGetLocalLeaderPartitionId(DeviceInstance); }
        void set(uint32_t value) { otThreadSetLocalLeaderPartitionId(DeviceInstance, value); }
    }

    property uint8_t LeaderWeight
    {
        uint8_t get() { return otThreadGetLeaderWeight(DeviceInstance); }
    }

    property uint32_t LeaderRouterId
    {
        uint32_t get() { return otThreadGetLeaderRouterId(DeviceInstance); }
    }

    property uint32_t PartitionId
    {
        uint32_t get() { return otThreadGetPartitionId(DeviceInstance); }
    }

    property uint16_t Rloc16
    {
        uint16_t get() { return otThreadGetRloc16(DeviceInstance); }
    }

    property otThreadState State
    {
        otThreadState get()
        {
            return (otThreadState)otThreadGetDeviceRole(DeviceInstance);
        }
    }

#pragma endregion

#pragma endregion

#pragma region Constructor/Destructor

    otAdapter(_In_ IntPtr /*otInstance**/ aInstance)
    {
        _Instance = (void*)aInstance;

        IInspectable* pInspectable = reinterpret_cast<IInspectable*>(this);

        // Register for device availability callbacks
        otSetStateChangedCallback(DeviceInstance, ThreadStateChangeCallback, pInspectable);
    }

    virtual ~otAdapter()
    {
        // Unregister for callbacks for the device
        otSetStateChangedCallback(DeviceInstance, nullptr, nullptr);

        // Free the device
        otFreeMemory(DeviceInstance);
    }

#pragma endregion

#pragma region Functions

    void PlatformReset()
    {
        otInstanceReset(DeviceInstance);
    }

    void FactoryReset()
    {
        otInstanceFactoryReset(DeviceInstance);
    }

    void BecomeRouter()
    {
        ThrowOnFailure(otThreadBecomeRouter(DeviceInstance));
    }

    void BecomeLeader()
    {
        ThrowOnFailure(otThreadBecomeLeader(DeviceInstance));
    }

#pragma endregion

internal:

    void InvokeAdapterRemoval()
    {
        AdapterRemoval(this);
    }

private:

    friend ref class otApi;

    static void OTCALL
    ThreadStateChangeCallback(
        uint32_t aFlags,
        _In_ void* aContext
        )
    {
        IInspectable* pInspectable = (IInspectable*)aContext;
        otAdapter^ pThis = reinterpret_cast<otAdapter^>(pInspectable);

        if (aFlags & OT_CHANGED_IP6_ADDRESS_ADDED)
        {
            pThis->IpAddressAdded(pThis);
        }

        if (aFlags & OT_CHANGED_IP6_ADDRESS_REMOVED)
        {
            pThis->IpAddressRemoved(pThis);
        }

        if (aFlags & OT_CHANGED_THREAD_RLOC_ADDED)
        {
            pThis->IpRlocAdded(pThis);
        }

        if (aFlags & OT_CHANGED_THREAD_RLOC_REMOVED)
        {
            pThis->IpRlocRemoved(pThis);
        }

        if (aFlags & OT_CHANGED_THREAD_LL_ADDR)
        {
            pThis->IpLinkLocalAddresChanged(pThis);
        }

        if (aFlags & OT_CHANGED_THREAD_ML_ADDR)
        {
            pThis->IpMeshLocalAddresChanged(pThis);
        }

        if (aFlags & OT_CHANGED_THREAD_ROLE)
        {
            pThis->NetRoleChanged(pThis);
        }

        if (aFlags & OT_CHANGED_THREAD_PARTITION_ID)
        {
            pThis->NetPartitionIdChanged(pThis);
        }

        if (aFlags & OT_CHANGED_THREAD_KEY_SEQUENCE_COUNTER)
        {
            pThis->NetKeySequenceCounterChanged(pThis);
        }

        if (aFlags & OT_CHANGED_THREAD_CHILD_ADDED)
        {
            pThis->ThreadChildAdded(pThis);
        }

        if (aFlags & OT_CHANGED_THREAD_CHILD_REMOVED)
        {
            pThis->ThreadChildRemoved(pThis);
        }

        if (aFlags & OT_CHANGED_THREAD_NETDATA)
        {
            pThis->ThreadNetDataUpdated(pThis);
        }
    }

    static HRESULT
    TheadErrorToHResult(
        int /* otError */ error
    )
    {
        switch (error)
        {
        case OT_ERROR_NO_BUFS:           return E_OUTOFMEMORY;
        case OT_ERROR_DROP:
        case OT_ERROR_NO_ROUTE:          return HRESULT_FROM_WIN32(ERROR_NETWORK_UNREACHABLE);
        case OT_ERROR_INVALID_ARGS:      return E_INVALIDARG;
        case OT_ERROR_SECURITY:          return E_ACCESSDENIED;
        case OT_ERROR_NOT_CAPABLE:
        case OT_ERROR_NOT_IMPLEMENTED:   return E_NOTIMPL;
        case OT_ERROR_INVALID_STATE:     return E_NOT_VALID_STATE;
        case OT_ERROR_NOT_FOUND:         return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
        case OT_ERROR_ALREADY:           return HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS);
        case OT_ERROR_RESPONSE_TIMEOUT:  return HRESULT_FROM_WIN32(ERROR_TIMEOUT);
        default:                         return E_FAIL;
        }
    }
};

} // namespace ot