/**************************************************************************
* file:              dmpserverwrapper.cpp

* Author:            wanzhongping
* Date:              2021-04-01 14:54:55
* Email:             zhongpingw@chinadci.com
* copyright:         广州城市信息研究所有限公司
***************************************************************************/
#define BOOST_BIND_GLOBAL_PLACEHOLDERS
#include <boost/python.hpp>
#include "../dmpserverfilter.h"
#include "../dmpserverinterface.h"
#include "../dmprequesthandler.h"
#include "../dmpserverrequest.h"
#include "../dmpserverresponse.h"
#include "../dmpservice.h"
#include "../dmpservermanager.h"
#include "../dmpservercontext.h"
#include <boost/python/suite/indexing/map_indexing_suite.hpp>
#include <boost/python/reference_existing_object.hpp>

using namespace boost::python;


struct DmpServiceWrap : DmpService, wrapper<DmpService>
{
  virtual std::string name() const
  {
    return this->get_override("name")();
  }

  virtual  unsigned int id() const
  {
    return this->get_override("id")();
  }

  virtual std::string version() const
  {
    return this->get_override("version")();
  }

  virtual std::string description() const
  {
    return this->get_override("description")();
  }
  virtual bool accept(const std::string &url)
  {
    return this->get_override("accept")();
  }
  virtual bool allowMethod() const
  {
    return this->get_override("allow_method")();
  }
  virtual void executeRequest(const DmpServerContext &context) 
  {

  }
  // virtual void executeRequest(const DmpServerRequest &request, DmpServerResponse &response)
  // {
  //   if(override function=this->get_override("execute_request"))
	// 	{
  //     try
  //     {
  //       reference_existing_object::apply<DmpServerRequest&>::type converter1;
  //       reference_existing_object::apply<DmpServerResponse&>::type converter2;
  //       PyObject* obj_req = converter1(request);
  //       PyObject* obj_res = converter2(response);
  //       object real_obj1 = object(handle<>(obj_req));
  //       object real_obj2 = object(handle<>(obj_res));
  //       function(real_obj1,real_obj2);
  //     }
  //     catch (boost::python::error_already_set &e)
  //     {
  //       PyErr_PrintEx(0);
  //     }
	// 	}
	// 	else
	// 	{
	// 		DmpServerWrap::ExecuteRequest(request,response);
	// 	}
  // }
};

struct DmpServerResponseWrap : DmpServerResponse, wrapper<DmpServerResponse>
{
  virtual void setStatusCode(int code) 
  {
    this->get_override("set_status_code")();
  }
  virtual int statusCode() const
  {
    return this->get_override("status_code")();
  }
  virtual std::string header( const std::string &key) const
  {
    return this->get_override("Header")();
  }
  virtual void setHeader( const std::string &key, const std::string &value ) 
  {
    this->get_override("setHeader")();
  }
  virtual void removeHeader( const std::string &key ) 
  {
    this->get_override("removeHeader")();
  }
  virtual ParameterMap headers() const
  {
    return this->get_override("headers")();
  }

  virtual void sendError( int code,  const std::string &message ) 
  {
    this->get_override("sendError")();
  }

  virtual void write(const std::string data) 
  {
    this->get_override("write")();
  }

  virtual void writeJson(const std::string data) 
  {
    this->get_override("write_json")();
  }

  virtual void writeHtml(const std::string data) 
  {
    this->get_override("write_html")();
  }

  virtual void writeContent(const void * content, int length) 
  {
    this->get_override("write_content")();
  }

  virtual void clear()
  {
    this->get_override("clear")();
  }
};

struct DmpServerFilterWrap : DmpServerFilter, wrapper<DmpServerFilter>
{
  DmpServerFilterWrap(DmpServerInterface *serverInterface)
        : DmpServerFilter(serverInterface)
  {
  }

  void requestReady()
  {
    this->get_override("request_ready")();
  }

  void requestReadyDefault()
  {
    return this->DmpServerFilter::requestReady();
  }

  void responseComplete()
  {
    this->get_override("response_complete")();
  }

  void sendResponse()
  {
    this->get_override("send_response")();
  }
};

struct DmpServerInterfaceWrap : DmpServerInterface, wrapper<DmpServerInterface>
{
  virtual DmpRequestHandler *requestHandler()
  {
    return this->get_override("request_handler")();
  }
  virtual void registerFilter(DmpServerFilter *filter, int priority = 0)
  {
     this->get_override("register_filter")();
  }
  // virtual DmpServerManager *ServerManager()
  // {
  //   return this->get_override("server_manager")();
  // }
};

BOOST_PYTHON_MODULE(dmap_server)
{
  class_<ParameterMap>("ParameterMap")
        .def(map_indexing_suite<ParameterMap,true>());

  // class_<DmpServerManager>("DmpServerManager",init<std::string&>())
  //     .def("register_server", &DmpServerManager::RegisterServer);

  class_<DmpServiceWrap, boost::noncopyable>("DmpService")
      .def("name", pure_virtual(&DmpService::name))
      .def("version", pure_virtual(&DmpService::version))
      .def("description", pure_virtual(&DmpService::description))
      .def("allow_method", pure_virtual(&DmpService::allowMethod))
      .def("execute_request", pure_virtual(&DmpService::executeRequest));

  // class_<DmpServerContext>("DmpServerContext",init<DmpServerRequest*, DmpServerResponse*, DmpProject*>());

  class_<DmpServerRequest>("DmpServerRequest",init<std::string&>()); 

  class_<DmpServerResponseWrap, boost::noncopyable>("DmpServerResponse")
      .add_property("status_code", &DmpServerResponse::statusCode, &DmpServerResponse::setStatusCode)
      .def("header", pure_virtual(&DmpServerResponse::header))
      .def("write", pure_virtual(&DmpServerResponse::write))
      .def("write_json", pure_virtual(&DmpServerResponse::writeJson))
      .def("write_html", pure_virtual(&DmpServerResponse::writeHtml))
      .def("write_content", pure_virtual(&DmpServerResponse::writeContent))
      .def("set_header", pure_virtual(&DmpServerResponse::setHeader));

  class_<DmpRequestHandler>("DmpRequestHandler",init<DmpServerRequest&, DmpServerResponse&>())
      .def("parameters", &DmpRequestHandler::Parameters)
      .def("set_parameter", &DmpRequestHandler::SetParameter)
      .def("request_headers", &DmpRequestHandler::RequestHeaders)
      .def("clear", &DmpRequestHandler::Clear)
      .def("set_response_header", &DmpRequestHandler::set_response_header)
      .def("append_body", &DmpRequestHandler::AppendBody);

  class_<DmpServerFilterWrap, boost::noncopyable>("DmpServerFilter",init<DmpServerInterface*>())
      .def("request_ready", &DmpServerFilterWrap::requestReady, &DmpServerFilterWrap::requestReadyDefault)
      .def("response_complete", &DmpServerFilterWrap::responseComplete)
      .def("send_response", &DmpServerFilterWrap::sendResponse)
      .def("server_interface", &DmpServerFilterWrap::serverInterface, return_internal_reference<>());

  class_<DmpServerInterfaceWrap, boost::noncopyable>("DmpServerInterface")
      .def("register_filter", pure_virtual(&DmpServerInterface::registerFilter))
      .def("request_handler", pure_virtual(&DmpServerInterface::requestHandler), return_internal_reference<>());
}