#include <cstdlib>
#include "CXWrapper.h"
#include <collection.h>
#include <robuffer.h>
#include <cstring>
#include <string>
#include <vector>
#include <windows.h>
#include <wrl.h>

using namespace Windows::Storage::Streams;
using namespace Microsoft::WRL;
using namespace libtgvoip;
using namespace Platform;
using namespace tgvoip;
using namespace Windows::Security::Cryptography;
using namespace Windows::Security::Cryptography::Core;
using namespace Windows::Storage::Streams;
using namespace Windows::Data::Json;
using namespace Windows::Phone::Media::Devices;

//CryptographicHash^ MicrosoftCryptoImpl::sha1Hash;
//CryptographicHash^ MicrosoftCryptoImpl::sha256Hash;
HashAlgorithmProvider ^ MicrosoftCryptoImpl::sha1Provider;
HashAlgorithmProvider ^ MicrosoftCryptoImpl::sha256Provider;
SymmetricKeyAlgorithmProvider ^ MicrosoftCryptoImpl::aesKeyProvider;

/*struct tgvoip_cx_data{
	VoIPControllerWrapper^ self;
};*/

VoIPControllerWrapper::VoIPControllerWrapper()
{
    VoIPController::crypto.aes_ige_decrypt = MicrosoftCryptoImpl::AesIgeDecrypt;
    VoIPController::crypto.aes_ige_encrypt = MicrosoftCryptoImpl::AesIgeEncrypt;
    VoIPController::crypto.aes_ctr_encrypt = MicrosoftCryptoImpl::AesCtrEncrypt;
    VoIPController::crypto.sha1 = MicrosoftCryptoImpl::SHA1;
    VoIPController::crypto.sha256 = MicrosoftCryptoImpl::SHA256;
    VoIPController::crypto.rand_bytes = MicrosoftCryptoImpl::RandBytes;
    MicrosoftCryptoImpl::Init();
    controller = new VoIPController();
    controller->implData = (void*)this;
    VoIPController::Callbacks callbacks = {0};
    callbacks.connectionStateChanged = VoIPControllerWrapper::OnStateChanged;
    callbacks.signalBarCountChanged = VoIPControllerWrapper::OnSignalBarsChanged;
    controller->SetCallbacks(callbacks);
}

VoIPControllerWrapper::~VoIPControllerWrapper()
{
    controller->Stop();
    delete controller;
}

void VoIPControllerWrapper::Start()
{
    controller->Start();
}

void VoIPControllerWrapper::Connect()
{
    controller->Connect();
}

void VoIPControllerWrapper::SetPublicEndpoints(const Platform::Array<libtgvoip::Endpoint ^> ^ endpoints, bool allowP2P, std::int32_t connectionMaxLayer)
{
    std::vector<tgvoip::Endpoint> eps;
    for (unsigned int i = 0; i < endpoints->Length; i++)
    {
        libtgvoip::Endpoint ^ _ep = endpoints[i];
        tgvoip::Endpoint ep;
        ep.id = _ep->id;
        ep.type = tgvoip::Endpoint::Type::UDP_RELAY;
        char buf[128];
        if (_ep->ipv4)
        {
            WideCharToMultiByte(CP_UTF8, 0, _ep->ipv4->Data(), -1, buf, sizeof(buf), nullptr, nullptr);
            ep.address = NetworkAddress::IPv4(buf);
        }
        if (_ep->ipv6)
        {
            WideCharToMultiByte(CP_UTF8, 0, _ep->ipv6->Data(), -1, buf, sizeof(buf), nullptr, nullptr);
            ep.v6address = NetworkAddress::IPv6(buf);
        }
        ep.port = _ep->port;
        if (_ep->peerTag->Length != 16)
            throw ref new Platform::InvalidArgumentException("Peer tag must be exactly 16 bytes long");
        std::memcpy(ep.peerTag, _ep->peerTag->Data, 16);
        eps.emplace_back(ep);
    }
    controller->SetRemoteEndpoints(eps, allowP2P, connectionMaxLayer);
}

void VoIPControllerWrapper::SetNetworkType(NetworkType type)
{
    controller->SetNetworkType((int)type);
}

void VoIPControllerWrapper::SetMicMute(bool mute)
{
    controller->SetMicMute(mute);
}

int64 VoIPControllerWrapper::GetPreferredRelayID()
{
    return controller->GetPreferredRelayID();
}

std::int32_t VoIPControllerWrapper::GetConnectionMaxLayer()
{
    return tgvoip::VoIPController::GetConnectionMaxLayer();
}

void VoIPControllerWrapper::SetEncryptionKey(const Platform::Array<uint8> ^ key, bool isOutgoing)
{
    if (key->Length != 256)
        throw ref new Platform::InvalidArgumentException("Encryption key must be exactly 256 bytes long");
    controller->SetEncryptionKey((char*)key->Data, isOutgoing);
}

int VoIPControllerWrapper::GetSignalBarsCount()
{
    return controller->GetSignalBarsCount();
}

CallState VoIPControllerWrapper::GetConnectionState()
{
    return (CallState)controller->GetConnectionState();
}

TrafficStats ^ VoIPControllerWrapper::GetStats()
{
    tgvoip::VoIPController::TrafficStats _stats;
    controller->GetStats(&_stats);

    TrafficStats ^ stats = ref new TrafficStats();
    stats->bytesSentWifi = _stats.bytesSentWifi;
    stats->bytesSentMobile = _stats.bytesSentMobile;
    stats->bytesRecvdWifi = _stats.bytesRecvdWifi;
    stats->bytesRecvdMobile = _stats.bytesRecvdMobile;

    return stats;
}

Platform::String ^ VoIPControllerWrapper::GetDebugString()
{
    std::string log = controller->GetDebugString();
    std::size_t len = sizeof(wchar_t) * (log.length() + 1);
    wchar_t* wlog = (wchar_t*)std::malloc(len);
    MultiByteToWideChar(CP_UTF8, 0, log.c_str(), -1, wlog, len / sizeof(wchar_t));
    Platform::String ^ res = ref new Platform::String(wlog);
    std::free(wlog);
    return res;
}

Platform::String ^ VoIPControllerWrapper::GetDebugLog()
{
    std::string log = controller->GetDebugLog();
    std::size_t len = sizeof(wchar_t) * (log.length() + 1);
    wchar_t* wlog = (wchar_t*)std::malloc(len);
    MultiByteToWideChar(CP_UTF8, 0, log.c_str(), -1, wlog, len / sizeof(wchar_t));
    Platform::String ^ res = ref new Platform::String(wlog);
    std::free(wlog);
    return res;
}

Error VoIPControllerWrapper::GetLastError()
{
    return (Error)controller->GetLastError();
}

Platform::String ^ VoIPControllerWrapper::GetVersion()
{
    const char* v = VoIPController::GetVersion();
    wchar_t buf[32];
    MultiByteToWideChar(CP_UTF8, 0, v, -1, buf, sizeof(buf));
    return ref new Platform::String(buf);
}

void VoIPControllerWrapper::OnStateChanged(VoIPController* c, int state)
{
    reinterpret_cast<VoIPControllerWrapper ^>(c->implData)->OnStateChangedInternal(state);
}

void VoIPControllerWrapper::OnSignalBarsChanged(VoIPController* c, int count)
{
    reinterpret_cast<VoIPControllerWrapper ^>(c->implData)->OnSignalBarsChangedInternal(count);
}

void VoIPControllerWrapper::OnStateChangedInternal(int state)
{
    CallStateChanged(this, (CallState)state);
}

void VoIPControllerWrapper::OnSignalBarsChangedInternal(int count)
{
    SignalBarsChanged(this, count);
}

void VoIPControllerWrapper::SetConfig(VoIPConfig ^ wrapper)
{
    VoIPController::Config config {0};
    config.initTimeout = wrapper->initTimeout;
    config.recvTimeout = wrapper->recvTimeout;
    config.dataSaving = (int)wrapper->dataSaving;
    config.logFilePath;
    config.statsDumpFilePath;

    config.enableAEC = wrapper->enableAEC;
    config.enableNS = wrapper->enableNS;
    config.enableAGC = wrapper->enableAGC;

    config.enableCallUpgrade = wrapper->enableCallUpgrade;

    config.logPacketStats = wrapper->logPacketStats;
    config.enableVolumeControl = wrapper->enableVolumeControl;

    config.enableVideoSend = wrapper->enableVideoSend;
    config.enableVideoReceive = wrapper->enableVideoReceive;

    if (wrapper->logFilePath != nullptr && !wrapper->logFilePath->IsEmpty())
    {
        config.logFilePath = wstring(wrapper->logFilePath->Data());
    }
    if (wrapper->statsDumpFilePath != nullptr && !wrapper->statsDumpFilePath->IsEmpty())
    {
        config.statsDumpFilePath = wstring(wrapper->statsDumpFilePath->Data());
    }

    controller->SetConfig(config);
}

void VoIPControllerWrapper::SetProxy(ProxyProtocol protocol, Platform::String ^ address, std::uint16_t port, Platform::String ^ username, Platform::String ^ password)
{
    char _address[2000];
    char _username[256];
    char _password[256];

    WideCharToMultiByte(CP_UTF8, 0, address->Data(), -1, _address, sizeof(_address), nullptr, nullptr);
    WideCharToMultiByte(CP_UTF8, 0, username->Data(), -1, _username, sizeof(_username), nullptr, nullptr);
    WideCharToMultiByte(CP_UTF8, 0, password->Data(), -1, _password, sizeof(_password), nullptr, nullptr);

    controller->SetProxy((int)protocol, _address, port, _username, _password);
}

void VoIPControllerWrapper::SetAudioOutputGainControlEnabled(bool enabled)
{
    controller->SetAudioOutputGainControlEnabled(enabled);
}

void VoIPControllerWrapper::SetInputVolume(float level)
{
    controller->SetInputVolume(level);
}

void VoIPControllerWrapper::SetOutputVolume(float level)
{
    controller->SetOutputVolume(level);
}

void VoIPControllerWrapper::UpdateServerConfig(Platform::String ^ json)
{
    std::string config = ToUtf8(json->Data(), json->Length());
    ServerConfig::GetSharedInstance()->Update(config);
}

void VoIPControllerWrapper::SwitchSpeaker(bool external)
{
    auto routingManager = AudioRoutingManager::GetDefault();
    if (external)
    {
        routingManager->SetAudioEndpoint(AudioRoutingEndpoint::Speakerphone);
    }
    else
    {
        if ((routingManager->AvailableAudioEndpoints & AvailableAudioRoutingEndpoints::Bluetooth) == AvailableAudioRoutingEndpoints::Bluetooth)
        {
            routingManager->SetAudioEndpoint(AudioRoutingEndpoint::Bluetooth);
        }
        else if ((routingManager->AvailableAudioEndpoints & AvailableAudioRoutingEndpoints::Earpiece) == AvailableAudioRoutingEndpoints::Earpiece)
        {
            routingManager->SetAudioEndpoint(AudioRoutingEndpoint::Earpiece);
        }
    }
}

void MicrosoftCryptoImpl::AesIgeEncrypt(std::uint8_t* in, std::uint8_t* out, std::size_t len, std::uint8_t* key, std::uint8_t* iv)
{
    IBuffer ^ keybuf = IBufferFromPtr(key, 32);
    CryptographicKey ^ _key = aesKeyProvider->CreateSymmetricKey(keybuf);
    std::uint8_t tmpOut[16];
    std::uint8_t* xPrev = iv + 16;
    std::uint8_t* yPrev = iv;
    std::uint8_t x[16];
    std::uint8_t y[16];
    for (std::size_t offset = 0; offset < len; offset += 16)
    {
        for (std::size_t i = 0; i < 16; i++)
        {
            if (offset + i < len)
            {
                x[i] = in[offset + i];
            }
            else
            {
                x[i] = 0;
            }
        }
        XorInt128(x, yPrev, y);
        IBuffer ^ inbuf = IBufferFromPtr(y, 16);
        IBuffer ^ outbuf = CryptographicEngine::Encrypt(_key, inbuf, nullptr);
        IBufferToPtr(outbuf, 16, tmpOut);
        XorInt128(tmpOut, xPrev, y);
        std::memcpy(xPrev, x, 16);
        std::memcpy(yPrev, y, 16);
        std::memcpy(out + offset, y, 16);
    }
}

void MicrosoftCryptoImpl::AesIgeDecrypt(std::uint8_t* in, std::uint8_t* out, std::size_t len, std::uint8_t* key, std::uint8_t* iv)
{
    IBuffer ^ keybuf = IBufferFromPtr(key, 32);
    CryptographicKey ^ _key = aesKeyProvider->CreateSymmetricKey(keybuf);
    std::uint8_t tmpOut[16];
    std::uint8_t* xPrev = iv;
    std::uint8_t* yPrev = iv + 16;
    std::uint8_t x[16];
    std::uint8_t y[16];
    for (std::size_t offset = 0; offset < len; offset += 16)
    {
        for (std::size_t i = 0; i < 16; i++)
        {
            if (offset + i < len)
            {
                x[i] = in[offset + i];
            }
            else
            {
                x[i] = 0;
            }
        }
        XorInt128(x, yPrev, y);
        IBuffer ^ inbuf = IBufferFromPtr(y, 16);
        IBuffer ^ outbuf = CryptographicEngine::Decrypt(_key, inbuf, nullptr);
        IBufferToPtr(outbuf, 16, tmpOut);
        XorInt128(tmpOut, xPrev, y);
        std::memcpy(xPrev, x, 16);
        std::memcpy(yPrev, y, 16);
        std::memcpy(out + offset, y, 16);
    }
}

#define GETU32(pt) (((std::uint32_t)(pt)[0] << 24) ^ ((std::uint32_t)(pt)[1] << 16) ^ ((std::uint32_t)(pt)[2] << 8) ^ ((std::uint32_t)(pt)[3]))
#define PUTU32(ct, st)              \
    {                               \
        (ct)[0] = (u8)((st) >> 24); \
        (ct)[1] = (u8)((st) >> 16); \
        (ct)[2] = (u8)((st) >> 8);  \
        (ct)[3] = (u8)(st);         \
    }

typedef std::uint8_t u8;

#define L_ENDIAN

/* increment counter (128-bit int) by 2^64 */
static void AES_ctr128_inc(std::uint8_t* counter)
{
    unsigned long c;

    /* Grab 3rd dword of counter and increment */
#ifdef L_ENDIAN
    c = GETU32(counter + 8);
    c++;
    PUTU32(counter + 8, c);
#else
    c = GETU32(counter + 4);
    c++;
    PUTU32(counter + 4, c);
#endif

    /* if no overflow, we're done */
    if (c)
        return;

        /* Grab top dword of counter and increment */
#ifdef L_ENDIAN
    c = GETU32(counter + 12);
    c++;
    PUTU32(counter + 12, c);
#else
    c = GETU32(counter + 0);
    c++;
    PUTU32(counter + 0, c);
#endif
}

void MicrosoftCryptoImpl::AesCtrEncrypt(std::uint8_t* inout, std::size_t len, std::uint8_t* key, std::uint8_t* counter, std::uint8_t* ecount_buf, std::uint32_t* num)
{
    unsigned int n;
    unsigned long l = len;

    //assert(in && out && key && counter && num);
    //assert(*num < AES_BLOCK_SIZE);

    IBuffer ^ keybuf = IBufferFromPtr(key, 32);
    CryptographicKey ^ _key = aesKeyProvider->CreateSymmetricKey(keybuf);

    n = *num;

    while (l--)
    {
        if (n == 0)
        {
            IBuffer ^ inbuf = IBufferFromPtr(counter, 16);
            IBuffer ^ outbuf = CryptographicEngine::Encrypt(_key, inbuf, nullptr);
            IBufferToPtr(outbuf, 16, ecount_buf);
            //AES_encrypt(counter, ecount_buf, key);
            AES_ctr128_inc(counter);
        }
        *inout = *(inout++) ^ ecount_buf[n];
        n = (n + 1) % 16;
    }

    *num = n;
}

void MicrosoftCryptoImpl::SHA1(std::uint8_t* msg, std::size_t len, std::uint8_t* out)
{
    //EnterCriticalSection(&hashMutex);

    IBuffer ^ arr = IBufferFromPtr(msg, len);
    CryptographicHash ^ hash = sha1Provider->CreateHash();
    hash->Append(arr);
    IBuffer ^ res = hash->GetValueAndReset();
    IBufferToPtr(res, 20, out);

    //LeaveCriticalSection(&hashMutex);
}

void MicrosoftCryptoImpl::SHA256(std::uint8_t* msg, std::size_t len, std::uint8_t* out)
{
    //EnterCriticalSection(&hashMutex);

    IBuffer ^ arr = IBufferFromPtr(msg, len);
    CryptographicHash ^ hash = sha256Provider->CreateHash();
    hash->Append(arr);
    IBuffer ^ res = hash->GetValueAndReset();
    IBufferToPtr(res, 32, out);
    //LeaveCriticalSection(&hashMutex);
}

void MicrosoftCryptoImpl::RandBytes(std::uint8_t* buffer, std::size_t len)
{
    IBuffer ^ res = CryptographicBuffer::GenerateRandom(len);
    IBufferToPtr(res, len, buffer);
}

void MicrosoftCryptoImpl::Init()
{
    /*sha1Hash=HashAlgorithmProvider::OpenAlgorithm(HashAlgorithmNames::Sha1)->CreateHash();
	sha256Hash=HashAlgorithmProvider::OpenAlgorithm(HashAlgorithmNames::Sha256)->CreateHash();*/
    sha1Provider = HashAlgorithmProvider::OpenAlgorithm(HashAlgorithmNames::Sha1);
    sha256Provider = HashAlgorithmProvider::OpenAlgorithm(HashAlgorithmNames::Sha256);
    aesKeyProvider = SymmetricKeyAlgorithmProvider::OpenAlgorithm(SymmetricAlgorithmNames::AesEcb);
}

void MicrosoftCryptoImpl::XorInt128(std::uint8_t* a, std::uint8_t* b, std::uint8_t* out)
{
    std::uint64_t* _a = reinterpret_cast<std::uint64_t*>(a);
    std::uint64_t* _b = reinterpret_cast<std::uint64_t*>(b);
    std::uint64_t* _out = reinterpret_cast<std::uint64_t*>(out);
    _out[0] = _a[0] ^ _b[0];
    _out[1] = _a[1] ^ _b[1];
}

void MicrosoftCryptoImpl::IBufferToPtr(IBuffer ^ buffer, std::size_t len, std::uint8_t* out)
{
    ComPtr<IBufferByteAccess> bufferByteAccess;
    reinterpret_cast<IInspectable*>(buffer)->QueryInterface(IID_PPV_ARGS(&bufferByteAccess));

    byte* hashBuffer;
    bufferByteAccess->Buffer(&hashBuffer);
    CopyMemory(out, hashBuffer, len);
}

IBuffer ^ MicrosoftCryptoImpl::IBufferFromPtr(std::uint8_t* msg, std::size_t len)
{
    ComPtr<NativeBuffer> nativeBuffer = Make<NativeBuffer>((byte*)msg, len);
    return reinterpret_cast<IBuffer ^>(nativeBuffer.Get());
}

/*Platform::String^ VoIPControllerWrapper::TestAesIge(){
	MicrosoftCryptoImpl::Init();
	Platform::String^ res="";
	Platform::Array<uint8>^ data=ref new Platform::Array<uint8>(32);
	Platform::Array<uint8>^ out=ref new Platform::Array<uint8>(32);
	Platform::Array<uint8>^ key=ref new Platform::Array<uint8>(16);
	Platform::Array<uint8>^ iv=ref new Platform::Array<uint8>(32);


	CryptographicBuffer::CopyToByteArray(CryptographicBuffer::DecodeFromHexString("0000000000000000000000000000000000000000000000000000000000000000"), &data);
	CryptographicBuffer::CopyToByteArray(CryptographicBuffer::DecodeFromHexString("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"), &iv);
	CryptographicBuffer::CopyToByteArray(CryptographicBuffer::DecodeFromHexString("000102030405060708090a0b0c0d0e0f"), &key);
	MicrosoftCryptoImpl::AesIgeEncrypt(data->Data, out->Data, 32, key->Data, iv->Data);
	res+=CryptographicBuffer::EncodeToHexString(CryptographicBuffer::CreateFromByteArray(out));
	res+="\n";

	CryptographicBuffer::CopyToByteArray(CryptographicBuffer::DecodeFromHexString("1A8519A6557BE652E9DA8E43DA4EF4453CF456B4CA488AA383C79C98B34797CB"), &data);
	CryptographicBuffer::CopyToByteArray(CryptographicBuffer::DecodeFromHexString("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"), &iv);
	CryptographicBuffer::CopyToByteArray(CryptographicBuffer::DecodeFromHexString("000102030405060708090a0b0c0d0e0f"), &key);
	MicrosoftCryptoImpl::AesIgeDecrypt(data->Data, out->Data, 32, key->Data, iv->Data);
	res+=CryptographicBuffer::EncodeToHexString(CryptographicBuffer::CreateFromByteArray(out));
	res+="\n";

	CryptographicBuffer::CopyToByteArray(CryptographicBuffer::DecodeFromHexString("99706487A1CDE613BC6DE0B6F24B1C7AA448C8B9C3403E3467A8CAD89340F53B"), &data);
	CryptographicBuffer::CopyToByteArray(CryptographicBuffer::DecodeFromHexString("6D656E746174696F6E206F6620494745206D6F646520666F72204F70656E5353"), &iv);
	CryptographicBuffer::CopyToByteArray(CryptographicBuffer::DecodeFromHexString("5468697320697320616E20696D706C65"), &key);
	MicrosoftCryptoImpl::AesIgeEncrypt(data->Data, out->Data, 32, key->Data, iv->Data);
	res+=CryptographicBuffer::EncodeToHexString(CryptographicBuffer::CreateFromByteArray(out));
	res+="\n";

	CryptographicBuffer::CopyToByteArray(CryptographicBuffer::DecodeFromHexString("4C2E204C6574277320686F70652042656E20676F74206974207269676874210A"), &data);
	CryptographicBuffer::CopyToByteArray(CryptographicBuffer::DecodeFromHexString("6D656E746174696F6E206F6620494745206D6F646520666F72204F70656E5353"), &iv);
	CryptographicBuffer::CopyToByteArray(CryptographicBuffer::DecodeFromHexString("5468697320697320616E20696D706C65"), &key);
	MicrosoftCryptoImpl::AesIgeDecrypt(data->Data, out->Data, 32, key->Data, iv->Data);
	res+=CryptographicBuffer::EncodeToHexString(CryptographicBuffer::CreateFromByteArray(out));
	return res;
}*/