/*
 *  JsonRpc-Cpp - JSON-RPC implementation.
 *  Copyright (C) 2008-2011 Sebastien Vincent <sebastien.vincent@cppextrem.com>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation, either version 3 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 Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * \file jsonrpc_httpclient.cpp
 * \brief JSON-RPC HTTP client.
 * \author Brian Panneton
 */

#include <sstream>

#include "jsonrpc_httpclient.h"
#include "netstring.h"

namespace Json
{
  namespace Rpc
  {
    HttpClient::HttpClient()
    {
      this->Initialize();
    }

    HttpClient::HttpClient(const std::string& address) 
    { 
      this->Initialize();
      this->ChangeAddress(address); 
    }

    HttpClient::HttpClient(const std::string& address, uint16_t port)
    { 
      this->Initialize();
      this->ChangeAddress(address);
      this->ChangePort(port); 
    }

    void HttpClient::Initialize()
    {
      /* Init all necessary curl stuff (in windows it will do winsock) */
      curl_global_init(CURL_GLOBAL_ALL);
      m_curlHandle = curl_easy_init();

      /* Set up curl to catch the servers response */
      curl_easy_setopt(m_curlHandle, CURLOPT_WRITEFUNCTION,
          HttpClient::StaticRecv);
      curl_easy_setopt(m_curlHandle, CURLOPT_WRITEDATA, this);

      /* Set up JSON specific HTTP Headers */
      size_t error = 0;
      m_headers = NULL;
      m_headers = curl_slist_append(m_headers,
          "Content-Type: application/json-rpc");
      m_headers = curl_slist_append(m_headers,"Accept: application/json-rpc");
      if((error = (size_t)curl_easy_setopt(m_curlHandle, CURLOPT_HTTPHEADER, 
              m_headers))!=0)
      {
        std::cerr << curl_easy_strerror((CURLcode)error);
        // TODO maybe throw exception here
        return;
      }

      /* Force curl to use POST */
      if((error = (size_t)curl_easy_setopt(m_curlHandle, CURLOPT_POST, 
              1)) != 0)
      {
        std::cerr << curl_easy_strerror((CURLcode)error);
        // TODO maybe throw exception here
        return;
      }

      // test if mutex is valid
      if(m_mutex.Lock())
      {
        std::cerr << "Can't create mutex for receive list.\n";
        // TODO maybe throw exception here
        return;
      }
      m_mutex.Unlock();

      this->SetRecvListSize(-1); 
      this->SetAddress("");
      this->SetPort(0);
      this->SetEncapsulatedFormat(Json::Rpc::RAW);
    }

    HttpClient::~HttpClient()
    {
      /* Clean up after we are done */
      curl_slist_free_all(m_headers);
      curl_global_cleanup();
    }

    void HttpClient::ChangeAddress(const std::string& address)
    {
      this->SetAddress(address);
    }

    void HttpClient::ChangePort(uint16_t port)
    {
      this->SetPort(port);

      size_t error = 0;
      if((error = (size_t)curl_easy_setopt(m_curlHandle, CURLOPT_PORT, 
              (long)port)) != 0)
      {
        std::cerr << curl_easy_strerror((CURLcode)error);
        // TODO maybe throw exception here
        return;
      }
    }

    ssize_t HttpClient::Send(const std::string& data)
    {
      if(this->GetAddress() == "")
      {
        return -1;
      }

      std::string rep = data;

      /* encoding if any */
      if(GetEncapsulatedFormat() == Json::Rpc::NETSTRING)
      {
        rep = netstring::encode(rep);
      }
#ifdef DEBUG
      curl_easy_setopt(m_curlHandle, CURLOPT_VERBOSE);
#endif

      size_t error = 0;
      /* Tell curl which address to use */
      if((error = (size_t)curl_easy_setopt(m_curlHandle, CURLOPT_URL, 
              this->GetAddress().c_str())) != 0)
      {
        std::cerr << curl_easy_strerror((CURLcode)error);
        return error;
      }

      /* Tell curl what data to send */
      if((error = (size_t)curl_easy_setopt(m_curlHandle, CURLOPT_POSTFIELDS, 
              data.c_str())) != 0)
      {
        std::cerr << curl_easy_strerror((CURLcode)error);
        return error;
      }
      if((error = (size_t)curl_easy_setopt(m_curlHandle, 
              CURLOPT_POSTFIELDSIZE,
              data.length())) != 0)
      {
        std::cerr << curl_easy_strerror((CURLcode)error);
        return error;
      }

      /* Send the data */
      if((error = (size_t)curl_easy_perform(m_curlHandle)) != 0)
      { 
        std::cerr << curl_easy_strerror((CURLcode)error);
        return error;
      }
      return 0;
    }

    size_t HttpClient::StaticRecv(void *buffer, size_t size, size_t nmemb, 
        void*f)
    {
      /* Get the data without the null term char */
      std::string data;
      data.assign((char*)buffer, (size_t)0, size*nmemb);

      /* Send our data to the current class instance */
      static_cast<HttpClient*>(f)->StoreRecv(data);

      /* return the size of data received */
      return size*nmemb;
    }

    void HttpClient::StoreRecv(const std::string &data)
    {
      m_mutex.Lock();
      this->m_lastReceivedList.push_back(data);
      if(m_lastReceivedListSize == -1)
      {
        m_mutex.Unlock();
        return;
      }

      if(m_lastReceivedList.size() > (unsigned int)m_lastReceivedListSize)
      {
        m_lastReceivedList.pop_front();
      }
      m_mutex.Unlock();
    }

    ssize_t HttpClient::Recv(std::string &data)
    {
      if(m_lastReceivedList.empty())
      {
        return 0;
      }

      m_mutex.Lock();
      data = this->m_lastReceivedList.front();
      ssize_t length = this->m_lastReceivedList.front().length();
      this->m_lastReceivedList.pop_front();
      m_mutex.Unlock();

      return length;
    }

    ssize_t HttpClient::WaitRecv(std::string &data)
    {
      while(data.size() == 0)
      {
        this->Recv(data);
      }
      return data.size();
    }

    ssize_t HttpClient::WaitRecv(std::string &data, unsigned int timeout)
    {
      time_t cur_time = time(NULL);
      while(data.size() == 0 && 
          static_cast<time_t>(cur_time + timeout) > time(NULL))
      {
        this->Recv(data);
      }
      return data.size();
    }

    void HttpClient::SetRecvListSize(int size)
    {
      if(size < -1)
      {
        size = -1;
      }
      this->m_lastReceivedListSize = size;
    }

    int HttpClient::GetRecvListSize()
    {
      return this->m_lastReceivedListSize;
    }

    /* We don't need these functions */
    bool HttpClient::Connect()
    {
      return false;
    }

    void HttpClient::Close()
    {
    }

    int HttpClient::GetSocket() const
    {
      return -1; 
    }
  } /* namespace Rpc */
} /* namespace Json */