/**************************************************************************
* 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 <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 std::string Version() const
  {
    return this->get_override("version")();
  }
  virtual bool AllowMethod() const
  {
    return this->get_override("allow_method")();
  }
  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
		{
			DmpServiceWrap::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 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 *server_interface)
        : DmpServerFilter(server_interface)
  {
  }

  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 DmpServiceRegistry *ServiceRegistry()
  {
    return this->get_override("service_registry")();
  }
};

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

  class_<DmpServiceRegistry>("DmpServiceRegistry")
      .def("register_service", &DmpServiceRegistry::RegisterService);

  class_<DmpServiceWrap, boost::noncopyable>("DmpService")
      .def("name", pure_virtual(&DmpService::Name))
      .def("version", pure_virtual(&DmpService::Version))
      .def("allow_method", pure_virtual(&DmpService::AllowMethod))
      .def("execute_request", pure_virtual(&DmpService::ExecuteRequest));

  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_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::server_interface, 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<>())
      .def("service_registry", pure_virtual(&DmpServerInterface::ServiceRegistry), return_internal_reference<>());
}