/* 
 * Copyright (C) 2007-2012 Dmytro Bogovych <dmytro.bogovych@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 */
#ifdef _WIN32
# include <winsock2.h>
# include <windows.h>
#endif

#include <algorithm>

#include "EP_ReliableTunnel.h"
#include "EP_Engine.h"
#include "Log.h"

#include "../ICE/ICECRC32.h"

enum
{
  CONFIRMATION_PT = 1,
  DATA_PT = 2
};

#define CONFIRMATION_TIMEOUT 500
#define LOG_SUBSYSTEM "RT"

ReliableTunnel::ReliableTunnel(const char* streamname)
{
  mStack.setEncryption(this);
  mStreamName = streamname;
  mBandwidth = 0;
  mExitSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
  mDataSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
  
}

ReliableTunnel::~ReliableTunnel()
{
  ::CloseHandle(mDataSignal);
  ::CloseHandle(mExitSignal);
}

std::string ReliableTunnel::streamName()
{
  return mStreamName;
}

std::string ReliableTunnel::streamProfile()
{
  return "RTP/DP";
}

void ReliableTunnel::setDestinationAddress(InternetAddress& addr)
{
  mDestination = addr;
}


void ReliableTunnel::queueData(const void* bufferptr, int buffersize)
{
  assert(bufferptr != NULL);
  assert(buffersize != 0);

  resip::Lock l(mNewQueuedGuard);
  mNewQueued.push_back(std::string((const char*)bufferptr, buffersize));
  
  ::SetEvent(mDataSignal);
}

// This method is called by user agent to send ICE packet from mediasocket
void ReliableTunnel::sendData(InternetAddress& addr, const void* dataBuffer, unsigned int datasize)
{
  switch (addr.type())
  {
  case AF_INET:
    mSocket4.sendDatagram(addr, dataBuffer, datasize);
    return;

  case AF_INET6:
    mSocket4.sendDatagram(addr, dataBuffer, datasize);
    return;
  }
}

void ReliableTunnel::sessionEstablished(int conntype)
{
  // Start worker thread
  if (conntype == EV_ICE)
    run();
}

void ReliableTunnel::sessionTerminated()
{
  // Stop worker thread
  ::SetEvent(mExitSignal);
  shutdown();
  join();
}

void ReliableTunnel::updateSdpOffer(resip::SdpContents::Session::Medium& sdp)
{
  // Get new destination port
  mDestination.setPort((unsigned short)sdp.port());
  
  sdp.addCodec(resip::SdpContents::Session::Codec("rt", 104));
}

void ReliableTunnel::setSocket(DatagramSocket& socket4, DatagramSocket& socket6)
{
  mSocket4 = socket4;
  mSocket6 = socket6;
}
  
DatagramSocket& ReliableTunnel::socket(int family)
{
  switch (family)
  {
  case AF_INET:
    return mSocket4;

  case AF_INET6:
    return mSocket4;

  default:
    assert(0);
  }
}

bool ReliableTunnel::processSdpOffer(const resip::SdpContents::Session::Medium& media)
{
  //check for default port number
  mDestination.setPort(media.port());
  
  return true;
}

void ReliableTunnel::thread()
{
  // Construct event array
  while (true)
  {
    HANDLE eventarray[2] = { mDataSignal, mExitSignal };

    DWORD rescode = ::WaitForMultipleObjects(2, eventarray, FALSE, INFINITE);
    if (rescode == WAIT_OBJECT_0)
    {
      resip::Lock l(mNewQueuedGuard);
      for (unsigned i = 0; i<mNewQueued.size(); i++)
        mStack.queueOutgoing(mNewQueued[i].c_str(), mNewQueued[i].size());
      mNewQueued.clear();
      
      sendOutgoing();
    }
    else
      break;
  }
}

void ReliableTunnel::setBandwidth(unsigned int bytesPerSecond)
{
  mBandwidth = bytesPerSecond;
}

unsigned int ReliableTunnel::bandwidth()
{
  return mBandwidth;
}

void ReliableTunnel::processData(const void* dataptr, int datasize)
{
  resip::Lock l(mStackGuard);
  mStack.processIncoming(dataptr, datasize);
}

bool ReliableTunnel::hasData()
{
  resip::Lock l(mStackGuard);
  
  return mIncomingData.size() || mStack.hasAppData();
}

unsigned ReliableTunnel::getData(void* ptr, unsigned capacity)
{
  resip::Lock l(mStackGuard);
   
  char* dataOut = (char*)ptr;
  
  while (capacity && hasData())
  {
    // Check if mIncomingData is empty
    if (!mIncomingData.size())
    {
      unsigned available = mStack.appData(NULL);
      if (!available)
        return 0;

      mIncomingData.resize(available);
      mIncomingData.rewind();
      mStack.appData(mIncomingData.mutableData());
    }

    if (mIncomingData.size())
    {
      unsigned toCopy = min(capacity, mIncomingData.size());
      mIncomingData.dequeueBuffer(dataOut, toCopy);
      dataOut += toCopy;
      capacity -= toCopy;
    }
  }

  return dataOut - (char*)ptr;
}

// Returns block size for encryption algorythm
int ReliableTunnel::blockSize()
{
  return 8;
}
      
// Encrypts dataPtr buffer inplace. dataSize must be odd to GetBlockSize() returned value.
void ReliableTunnel::encrypt(void* dataPtr, int dataSize)
{
  if (mEncryptionKey.empty())
    return;

#ifdef USE_OPENSSL
  for (unsigned i=0; i<dataSize / blockSize(); i++)
    BF_ecb_encrypt((unsigned char*)dataPtr + i * blockSize(), (unsigned char*)dataPtr + i * blockSize(), &mCipher, BF_ENCRYPT);
#endif

#ifdef USE_CRYPTOPP
  for (unsigned i=0; i<dataSize / blockSize(); i++)
    mEncryptor.ProcessBlock((unsigned char*)dataPtr + i * blockSize());
#endif
}

// Decrypts dataPtr buffer inplace. dataSize must be odd to GetBlockSize() returned value.
void ReliableTunnel::decrypt(void* dataPtr, int dataSize)
{
  if (mEncryptionKey.empty())
    return;
#ifdef USE_OPENSSL
  for (unsigned i=0; i<dataSize / blockSize(); i++)
    BF_ecb_encrypt((unsigned char*)dataPtr + i * blockSize(), (unsigned char*)dataPtr + i * blockSize(), &mCipher, BF_DECRYPT);
#endif
  
#ifdef USE_CRYPTOPP
  for (unsigned i=0; i<dataSize / blockSize(); i++)
    mDecryptor.ProcessBlock((unsigned char*)dataPtr + i * blockSize());
#endif
}

// Calculates CRC
unsigned ReliableTunnel::crc(const void* dataptr, int datasize)
{
  unsigned long result;
  ICEImpl::CRC32 crc;
  crc.fullCrc((const unsigned char*)dataptr, datasize, &result);
  
  return result;
}

void ReliableTunnel::sendOutgoing()
{
  // Check if stack has to send smth
  if (mStack.hasPacketToSend())
  {
    // Get data to send
    char buffer[2048];
    int length = sizeof(buffer);
    mStack.getPacketToSend(buffer, length);
    
    // Send it over UDP
    sendData(this->mDestination, buffer, length);
  }
}

void ReliableTunnel::setEncryptionKey(void* ptr, unsigned length)
{
#ifdef USE_OPENSSL
  BF_set_key(&mCipher, length, (const unsigned char*)ptr);
#endif

#ifdef USE_CRYPTOPP
  mEncryptor.SetKey((unsigned char*)ptr, length);
  mDecryptor.SetKey((unsigned char*)ptr, length);
#endif

  // Save key
  mEncryptionKey = std::string((const char*)ptr, length);
}