// Register the stock module
open::OpenServer::RegisterServer<stock::Server>("stock");

// Start two stock modules: stock1 and stock2. This effectively starts two threads, two business pipelines. Of course, more can be created to achieve multi-core processing of the same business logic.
open::OpenServer::StartServer("stock", "stock1", "");
open::OpenServer::StartServer("stock", "stock2", "");

// Import header files for the centor, httpd and stock modules
#include "server/stock/server.h"
#include "server/httpd/httpa.h"
#include "server/httpd/httpd.h"
#include "server/centor/server.h"

//The single application instance 
class App : public open::OpenApp
{
    static App TheApp_;
public:
    static inline App& Instance() { return TheApp_; }
    virtual void start()
    {
        OpenApp::start();
        //Start the timer module
        open::OpenTimerServer::Run();

        //Register custom modules
        //Register the httpa::Server module   
        open::OpenServer::RegisterServer<httpa::Server>("httpa");
        open::OpenServer::RegisterServer<httpd::Server>("httpd");
        open::OpenServer::RegisterServer<stock::Server>("stock");
        open::OpenServer::RegisterServer<centor::Server>("centor");

        //Start 4 httpa::Server objects to handle receiving and sending client network messages
        open::OpenServer::StartServer("httpa", "httpa1", "");
        open::OpenServer::StartServer("httpa", "httpa2", "");
        open::OpenServer::StartServer("httpa", "httpa3", "");
        open::OpenServer::StartServer("httpa", "httpa4", "");

        //Start 1 httpd::Server object to listen for client connections and forward to httpa::Server  
        open::OpenServer::StartServer("httpd", "httpd", "");

        //Start 2 stock::Server objects for load balancing the same business logic over two threads. More can be created to scale over multiple CPU cores.
        open::OpenServer::StartServer("stock", "stock1", "");
        open::OpenServer::StartServer("stock", "stock2", "");

        //Start 1 centor::Server object
        open::OpenServer::StartServer("centor", "centor", "");

        //The above just creates the OpenServers, next we start them to spin up threads and process their logic.
        open::OpenServer::RunServers();
        printf("Start OpenMiniServer complete!\n");
    }
};
//The application instance object
App App::TheApp_;

#include "open.h"
#include "msg/msg.h"

// Use namespace to distinguish modules, this one is called stock 
namespace stock
{
// Inherit open::OpenHttpClient to gain HTTP request ability. open::OpenHttpClient inherits from OpenServer
class Server : public open::OpenHttpClient
{
	typedef std::function<void(open::OpenHttpRequest&, open::OpenHttpResponse&)> HttpHandle;
public:
	Server(const std::string& name, const std::string& args)
		:open::OpenHttpClient(name, args)
	{
		sessionId_ = 0;
	}
	virtual ~Server() {}

	//Each module needs to implement New function, otherwise open::OpenServer::StartServer will fail
	static OpenServer* New(const std::string& serverName, const std::string& args)
	{
		return new Server(serverName, args);
	}

	//After its parent OpenServer starts, it will start its thread. Thread start success calls onStart method 
	virtual void onStart() {}

	//Business logic - Request stock data and return result via callback 
    bool reqStockData(const std::string& code, const HttpHandle& cb)
    {
        auto request = std::shared_ptr<open::OpenHttpRequest>(new open::OpenHttpRequest);
        request->method_ = "GET";
        request->url_ = "http://localhost:8080/api/stock?code=" + code;

        ++sessionId_;
        request->uid_ = sessionId_;
        mapHttpCalls_[sessionId_] = cb;
        sendHttp(request);
        return true;
    }

    //Called when open::OpenHttpClient sends a request and gets response. Map back to callback via sessionId
    virtual void onHttp(open::OpenHttpRequest& req, open::OpenHttpResponse& rep)
    {
        int sessionId = req.uid_;
        auto iter = mapHttpCalls_.find(sessionId);
        if (iter != mapHttpCalls_.end())
        {
            iter->second(req, rep);
            mapHttpCalls_.erase(iter);
        }
    }

    //Messages from other modules 
    virtual void onMsgProto(open::OpenMsgProto& proto)
    {
    	//Handle message from centor module, stock data request   
        if (StockRequestStockMsg::MsgId() == proto.msg_->msgId())
        {
            std::shared_ptr<StockRequestStockMsg> protoMsg = std::dynamic_pointer_cast<StockRequestStockMsg>(proto.msg_);
            if (!protoMsg) {
                assert(false); return;
            }
            //Request stock data, return HTTP result via std::function
            reqStockData(protoMsg->code_, [=](open::OpenHttpRequest& req, open::OpenHttpResponse& rep) {
                auto sendProtoMsg = std::shared_ptr<StockResponseStockMsg>(new StockResponseStockMsg);
                sendProtoMsg->code_ = protoMsg->code_;
                rep.getBody(sendProtoMsg->stockData_);
                sendMsgProto<StockResponseStockMsg>(proto.srcName_, sendProtoMsg);
            });
        }
    }
protected:
	int sessionId_;
	std::unordered_map<int, HttpHandle> mapHttpCalls_;
};

};

#include "open.h"
#include "msg/msg.h"
// Use namespace to distinguish modules, this one is called centor
namespace centor
{
// Inherit open::OpenServer
class Server : public open::OpenServer
{
public:
	Server(const std::string& name, const std::string& args)
		:open::OpenServer(name, args){}

	virtual ~Server() {}

	//Each module needs to implement New function, otherwise open::OpenServer::StartServer will fail
	static OpenServer* New(const std::string& serverName, const std::string& args)
	{
		return new Server(serverName, args);
	}

	// After its parent open::OpenServer starts, it will start its thread. Thread start success calls onStart method
    void onStart()
    {
    	//Create message to request index 399001 data from stock module  
        auto protoMsg = std::shared_ptr<StockRequestStockMsg>(new StockRequestStockMsg);
        protoMsg->code_ = "399001";
        //send message to "stock1" object. Can also send to "stock2" if less busy.
        sendMsgProto<StockRequestStockMsg>("stock1", protoMsg);
    }
    //Receive data returned from stock module
    virtual void onMsgProto(open::OpenMsgProto& proto)
    {
        if (StockResponseStockMsg::MsgId() == proto.msg_->msgId())
        {
            std::shared_ptr<StockResponseStockMsg> protoMsg = std::dynamic_pointer_cast<StockResponseStockMsg>(proto.msg_);
            if (!protoMsg)
            {
                assert(false); return;
            }
            //json parse
            open::OpenJson json;
            json.decode(protoMsg->stockData_);

            auto& nodeCode = json["code"];
            assert(nodeCode.isString());
            auto code = nodeCode.s();

            auto& nodeDatas = json["data"];
            assert(nodeDatas.size() == 2);

            //convert csv
            open::OpenCSV csv = { "code", "time", "price" };
            for (size_t i = 0; i < nodeDatas.size(); i++)
            {
                auto& nodeRow = nodeDatas[i];
                csv = { 
                    code,
                    nodeRow["time"].s(),
                    std::to_string(nodeRow["price"].d())
                };
            }
            std::string output;
            csv >> output;
            printf("\ncsv content:\n");
            printf("%s\n", output.data());
        }
    }
protected:
};
};

#include "open.h"

// Use namespace to distinguish module, this one is called httpd, responsible for listening to client connections
namespace httpd
{
// Inherit open::OpenHttpServer, has ability to listen on network ports
class Server : public open::OpenHttpServer
{
public:
	Server::Server(const std::string& name, const std::string& args)
		:open::OpenHttpServer(name, args){}
	virtual ~Server() {}
	static OpenServer* New(const std::string& serverName, const std::string& args)
	{
		return new Server(serverName, args);
	}
	virtual void onStart()
    {
    	// Create message to start http listening on 0.0.0.0:8080
        auto msg = std::shared_ptr<open::OpenHttpServerMsg>(new open::OpenHttpServerMsg);
        msg->ip_ = "0.0.0.0";
        //Enable HTTPS service in CMakeLists.txt by defining USE_OPEN_SSL, needs OpenSSL library when compiling
        #ifdef USE_OPEN_SSL
            msg->port_ = 443;
            msg->port1_ = 80;
            msg->isHttps_ = 1;
            msg->keyFile_ = "/xx/www.xx.com.key";
            msg->certFile_ = "/xx/www.xx.com.crt";
        #else
            msg->port_ = 8080;
            msg->port1_ = 0;
            msg->isHttps_ = 0;
        #endif
        msg->handle_ = 0;

        //Get all open::OpenServer objects belonging to module "httpa". Do not delete them.
        std::vector<open::OpenServer*> servers;
        open::OpenServer::GetServersByClassName("httpa", servers);
        for (size_t i = 0; i < servers.size(); i++)
        {
            msg->vectAccepts_.push_back(servers[i]->pid());
        }
        open::OpenMsgProto proto;
        proto.msg_ = msg;
        onMsgProto(proto);
    }
protected:
};
};

#include "open.h"
#include "util/http_util.h"

//Use namespace to distinguish modules, this module is called httpa, handles client connections sent from httpd.
namespace httpa
{

typedef open::OpenHttpRequest Req;
typedef open::OpenHttpResponse Rep;
typedef void(*HttpHandle)(Req* req, Rep* rep);

//Handles client http requests.
class Handle
{
    //  /index.html
    void OnIndex(Req* req, Rep* rep)
    {
        auto html = Dom::DomCreate();
        auto& body = html->child("body");
        auto& h1 = body.create("h1");
        h1 = "Welcome OpenServer, Thanks.";
        std::string buffer;
        html->echo(buffer);
        rep->response(200, ".html", buffer);
    }

    //  /api/stock
    void OnApiStock(Req* req, Rep* rep)
    {
        //{
        //    "code": "xxxxx",
        //    "data" : [
        //       {"time": "2023-07-18", "price" : 10}
        //       {"time": "2023-07-19", "price": 20}
        //    ]
        //}
        auto& code = req->params_["code"];

        open::OpenJson json;
        json["code"] = code;
        auto& nodeData = json["data"];

        auto& row0 = nodeData[0];
        row0["time"] = "2023-07-18";
        row0["price"] = 10;

        auto& row1 = nodeData[1];
        row1["time"] = "2023-07-19";
        row1["price"] = 20;

        auto& buffer = json.encode();
        rep->response(200, ".json", buffer);
    }

    typedef void (Handle::* HttpCall)(Req* req, Rep* rep);
    std::unordered_map<std::string, HttpCall> mapRouteHandles;
public:
    Handle()
    {
        mapRouteHandles["/"] = (HttpCall)&Handle::OnIndex;
        mapRouteHandles["/index.html"] = (HttpCall)&Handle::OnIndex;
        mapRouteHandles["/api/stock"] = (HttpCall)&Handle::OnApiStock;
    }

    ~Handle() {}
    void onCallBack(Req* req, Rep* rep)
    {
        printf("HTTP visit:%s:%d %s \n", req->ip().data(), req->port_, req->url_.data());
        if (req->url_ == "robots.txt")
        {
            rep->body_ = "User-agent: *\nDisallow: / \n";
            rep->code_ = 200;
            rep->ctype_ = "text/plain;charset=utf-8";
            return;
        }
        HttpCall handle = 0;
        auto iter = mapRouteHandles.find(req->path_);
        if (mapRouteHandles.end() != iter)
        {
            handle = iter->second;
        }
        if (!handle)
        {
            handle = mapRouteHandles["/"];
        }
        (this->*handle)(req, rep);
    }
};

// Inherit open::OpenHttpAgent, has ability to handle client connections.
class Server : public open::OpenHttpAgent
{
public:
	Server(const std::string& name, const std::string& args)
		:open::OpenHttpAgent(name, args)
	{
	}
	virtual ~Server() {}
	static OpenServer* New(const std::string& serverName, const std::string& args)
	{
		return new Server(serverName, args);
	}

	virtual void onStart() {}

	//Handles client http requests.
	virtual void onHttp(open::OpenHttpRequest& req, open::OpenHttpResponse& rep)
	{
		handle_.onCallBack(&req, &rep);
	}
protected:
	Handle handle_;
};

};

//Dispatch OpenSocket consumption to bound OpenServer
void OpenApp::SocketFunc(const OpenSocketMsg* msg)
{
    if (!msg) return;
    if (msg->uid_ >= 0)
    {
        auto proto = std::shared_ptr<OpenSocketProto>(new OpenSocketProto);
        proto->srcPid_ = -1;
        proto->srcName_ = "OpenSocket";
        proto->data_ = std::shared_ptr<OpenSocketMsg>((OpenSocketMsg*)msg);
        //msg->uid_ the ID of the requesting OpenServer
        if (!OpenThread::Send((int)msg->uid_, proto))
            printf("SocketFunc dispatch faild pid = %d\n", (int)msg->uid_);
    }
    else delete msg;
}

//
void OpenApp::start()
{
    if (isRunning_) return;
    isRunning_ = true;
    //Start network thread, set network handler to OpenApp::SocketFunc
    OpenSocket::Start(OpenApp::SocketFunc);
}