class Transport {
public:   
   /**
    * 初始化Transport对象，输入Config对象配置最大连接数等参数，可以是一个新建的Config对象。
    */   
   virtual int Init(Config* config) = 0;
​
   /**
    * 检查是否有数据可以读取，返回可读的事件数。后续代码应该根据此返回值循环调用Read()提取数据。
    * 参数fds用于返回出现事件的所有fd列表，len表示这个列表的最大长度。如果可用事件大于这个数字，并不影响后续可以Read()的次数。
    * fds的内容，如果出现负数，表示有一个新的终端等待接入。
    */
   virtual int Peek(int* fds, int len) = 0;
​
   /**
    * 读取网络管道中的数据。数据放在输出参数 peer 的缓冲区中。
    * @param peer 参数是产生事件的通信对端对象。
    * @return 返回值为可读数据的长度，如果是 0 表示没有数据可以读，返回 -1 表示连接需要被关闭。
    */
   virtual int Read( Peer* peer) = 0;
​
   /**
    * 写入数据，output_buf, buf_len为想要写入的数据缓冲区，output_peer为目标队端，
    * 返回值表示成功写入了的数据长度。-1表示写入出错。
    */
   virtual int Write(const char* output_buf, int buf_len, const Peer& output_peer) = 0;
​
   /**
    * 关闭一个对端的连接
    */
   virtual void ClosePeer(const Peer& peer) = 0;
​
   /**
    * 关闭Transport对象。
    */
   virtual void Close() = 0;
​
}

///@brief 此类型负责存放连接过来的客户端信息和数据缓冲区
class Peer {
public: 
    int buf_size_;      ///< 缓冲区长度
    char* const buffer_;///< 缓冲区起始地址
    int produced_pos_;  ///< 填入了数据的长度
    int consumed_pos_;  ///< 消耗了数据的长度
​
    int GetFd() const;
    void SetFd(int fd);    /// 获得本地地址
    const struct sockaddr_in& GetLocalAddr() const;
    void SetLocalAddr(const struct sockaddr_in& localAddr);    /// 获得远程地址
​
    const struct sockaddr_in& GetRemoteAddr() const;
    void SetRemoteAddr(const struct sockaddr_in& remoteAddr);
​
private:
    int fd_;                            ///< 收发数据用的fd
    struct sockaddr_in remote_addr_;    ///< 对端地址
    struct sockaddr_in local_addr_;     ///< 本端地址
};

/**
 * @brief 客户端使用的连接器类，代表传输协议，如 TCP 或 UDP
 */
class Connector {
​
public:    virtual ~Connector() {}    
 
    /**
     * @brief 初始化建立连接等
     * @param config 需要的配置
     * @return 0 为成功
     */
    virtual int Init(Config* config) = 0;
​
    /**
     * @brief 关闭
     */
    virtual void Close() = 0;
​
    /**
     * @brief 读取是否有网络数据到来
     * 读取有无数据到来，返回值为可读事件的数量，通常为1
     * 如果为0表示没有数据可以读取。
     * 如果返回 -1 表示出现网络错误，需要关闭此连接。
     * 如果返回 -2 表示此连接成功连上对端。
     * @return 网络数据的情况
     */
    virtual int Peek() = 0;
​
    /**
     * @brief 读取网络数 
     * 读取连接里面的数据，返回读取到的字节数，如果返回0表示没有数据，
     * 如果buffer_length是0, 也会返回0，
     * @return 返回-1表示连接需要关闭（各种出错也返回0）
     */
    virtual int Read(char* ouput_buffer, int buffer_length) = 0;
​
    /**
     * @brief 把input_buffer里的数据写入网络连接，返回写入的字节数。
     * @return 如果返回-1表示写入出错，需要关闭此连接。
     */
   virtual int Write(const char* input_buffer, int buffer_length) = 0;
​
protected:
    Connector(){}
};

enum MessageType {
    TypeError, ///< 错误的协议
    TypeRequest, ///< 请求类型，从客户端发往服务器
    TypeResponse, ///< 响应类型，服务器收到请求后返回
    TypeNotice  ///< 通知类型，服务器主动通知客户端
};
​
///@brief 通信消息体的基类
///基本上是一个 char[] 缓冲区
struct Message {
public:
    static int MAX_MAESSAGE_LENGTH;
    static int MAX_HEADER_LENGTH;
  
    MessageType type;  ///< 此消息体的类型(MessageType)信息
​
    virtual ~Message();    virtual Message& operator=(const Message& right);
​
    /**
     * @brief 把数据拷贝进此包体缓冲区
     */
    void SetData(const char* input_ptr, int input_length);
​
    ///@brief 获得数据指针
    inline char* GetData() const{
        return data_;
    }
​
     ///@brief 获得数据长度
    inline int GetDataLen() const{
        return data_len_;
    }
 
    char* GetHeader() const;
    int GetHeaderLen() const;
​
protected:
    Message();
    Message(const Message& message);
 
private:
    char* data_;                  // 包体内容缓冲区
    int data_len_;                // 包体长度
​
};

class Protocol {
​
public:
    virtual ~Protocol() {
    }
​
    /**
     * @brief 把请求消息编码成二进制数据
     * 编码，把msg编码到buf里面，返回写入了多长的数据，如果超过了 len，则返回-1表示错误。
     * 如果返回 0 ，表示不需要编码，框架会直接从 msg 的缓冲区读取数据发送。
     * @param buf 目标数据缓冲区
     * @param offset 目标偏移量
     * @param len 目标数据长度
     * @param msg 输入消息对象
     * @return 编码完成所用的字节数，如果 < 0 表示出错
     */
    virtual int Encode(char* buf, int offset, int len, const Request& msg) = 0;
​
    /**
     * 编码，把msg编码到buf里面，返回写入了多长的数据，如果超过了 len，则返回-1表示错误。
     * 如果返回 0 ，表示不需要编码，框架会直接从 msg 的缓冲区读取数据发送。
     * @param buf 目标数据缓冲区
     * @param offset 目标偏移量
     * @param len 目标数据长度
     * @param msg 输入消息对象
     * @return 编码完成所用的字节数，如果 < 0 表示出错
     */
    virtual int Encode(char* buf, int offset, int len, const Response& msg) = 0;
​
    /**
     * 编码，把msg编码到buf里面，返回写入了多长的数据，如果超过了 len，则返回-1表示错误。
     * 如果返回 0 ，表示不需要编码，框架会直接从 msg 的缓冲区读取数据发送。
     * @param buf 目标数据缓冲区
     * @param offset 目标偏移量
     * @param len 目标数据长度
     * @param msg 输入消息对象
     * @return 编码完成所用的字节数，如果 < 0 表示出错
     */
    virtual int Encode(char* buf, int offset, int len, const Notice& msg) = 0;
​
    /**
     * 开始编码，会返回即将解码出来的消息类型，以便使用者构造合适的对象。
     * 实际操作是在进行“分包”操作。
     * @param buf 输入缓冲区
     * @param offset 输入偏移量
     * @param len 缓冲区长度
     * @param msg_type 输出参数，表示下一个消息的类型，只在返回值 > 0 的情况下有效，否则都是 TypeError
     * @return 如果返回0表示分包未完成，需要继续分包。如果返回-1表示协议包头解析出错。其他返回值表示这个消息包占用的长度。
     */
    virtual int DecodeBegin(const char* buf, int offset, int len,
                            MessageType* msg_type) = 0;
​
    /**
     * 解码，把之前DecodeBegin()的buf数据解码成具体消息对象。
     * @param request 输出参数，解码对象会写入此指针
     * @return 返回0表示成功，-1表示失败。
     */
    virtual int Decode(Request* request) = 0;
​
    /**
     * 解码，把之前DecodeBegin()的buf数据解码成具体消息对象。
     * @param request 输出参数，解码对象会写入此指针
     * @return 返回0表示成功，-1表示失败。
     */
    virtual int Decode(Response* response) = 0;
​
    /**
     * 解码，把之前DecodeBegin()的buf数据解码成具体消息对象。
     * @param request 输出参数，解码对象会写入此指针
     * @return 返回0表示成功，-1表示失败。
     */
    virtual int Decode(Notice* notice) = 0;protected:
​
    Protocol() {
    }
​
};

///@brief 处理器基类，提供业务逻辑回调接口
​
class Processor {
​
public:
    Processor();
    virtual ~Processor();
 
    /**
     * 初始化一个处理器，参数server为业务逻辑提供了基本的能力接口。
     */
    virtual int Init(Server* server, Config* config = NULL);
​
    /**
     * 处理请求-响应类型包实现此方法，返回值是0表示成功，否则会被记录在错误日志中。
     * 参数peer表示发来请求的对端情况。其中 Server 对象的指针，可以用来调用 Reply(),
     * Inform() 等方法。如果是监听多个服务器，server 参数则会是不同的对象。
     */
    virtual int Process(const Request& request, const Peer& peer,
                        Server* server);
​
    /**
     * 关闭清理处理器所占用的资源
     */
    virtual int Close();
};

TlvProtocol tlv_protocol;   //  Type Length Value 格式分包协议，需要和客户端一致
TcpTransport tcp_transport; // 使用 TCP 的通信协议，默认监听 0.0.0.0:6666
EchoProcessor echo_processor;   // 业务逻辑处理器
Server server;  // DenOS 的网络服务器主对象
server.Init(&tcp_transport, &tlv_protocol, &echo_processor);    // 组装一个游戏服务器对象：TLV 编码、TCP 通信和回音服务

class Server {
​
public:
    Server();
    virtual ~Server();
 
    /**
     * 初始化服务器，需要选择组装你的通信协议链
     */
    int Init(Transport* transport, Protocol* protocol, Processor* processor, Config* config = NULL);
​
    /**
     * 阻塞方法，进入主循环。
     */
    void Start();
​
    /**
     * 需要循环调用驱动的方法。如果返回值是0表示空闲。其他返回值表示处理过的任务数。
     */
    virtual int Update();
    void ClosePeer(Peer* peer, bool is_clear = false); //关闭当个连接，is_clear 表示是否最终整体清理
​
    /**
     * 关闭服务器
     */
    void Close();
​
    /**
     * 对某个客户端发送通知消息，
     * 参数peer代表要通知的对端。
     */
    int Inform(const Notice& notice, const Peer& peer);
​
    /**
     * 对某个  Session ID 对应的客户端发送通知消息，返回 0 表示可以发送，其他值为发送失败。
     * 此接口能支持断线重连，只要客户端已经成功连接，并使用旧的 Session ID，同样有效。
     */
    int Inform(const Notice& notice, const std::string& session_id);
​
    /**
     * 对某个客户端发来的Request发回回应消息。
     * 参数response的成员seqid必须正确填写，才能正确回应。
     * 返回0成功，其它值（-1）表示失败。
     */
    int Reply(Response* response, const Peer& peer);
​
    /**
     * 对某个 Session ID 对应的客户端发送回应消息。
     * 参数 response 的 seqid 成员系统会自动填写会话中记录的数值。
     * 此接口能支持断线重连，只要客户端已经成功连接，并使用旧的 Session ID，同样有效。
     * 返回0成功，其它值（-1）表示失败。
     */
    int Reply(Response* response, const std::string& session_id);
​
    /**
     * 会话功能
     */
    Session* GetSession(const std::string& session_id = "", bool use_this_id = false);
    Session* GetSessionByNumId(int session_id = 0);
    bool IsExist(const std::string& session_id);
   
};

class ClientCallback {
​
public:
  
    ClientCallback() {
    }
    virtual ~ClientCallback() {
         // Do nothing
    }
​
    /**
     *  当连接建立成功时回调此方法。
     * @return 返回 -1 表示不接受这个连接，需要关闭掉此连接。
     */
    virtual int OnConnected() {
        return 0;
    }
​
    /**
     * 当网络连接被关闭的时候，调用此方法
     */
    virtual void OnDisconnected() {        // Do nothing
    }
​
    /**
     * 收到响应，或者请求超时，此方法会被调用。
     * @param response 从服务器发来的回应
     * @return 如果返回非0值，服务器会打印一行错误日志。
     */
    virtual int Callback(const Response& response) {
        return 0;
    }
​
    /**
     * 当请求发生错误，比如超时的时候，返回这个错误
     * @param err_code 错误码
     */
    virtual void OnError(int err_code){
        WARN_LOG("The request is timeout, err_code: %d", err_code);
    }
​
    /**
     * 收到通知消息时，此方法会被调用
     */
    virtual int Callback(const Notice& notice) {
        return 0;
    }
​
    /**
     * 返回此对象是否应该被删除。此方法会被在 Callback() 调用前调用。
     * @return 如果返回 true，则会调用 delete 此对象的指针。
     */
    virtual bool ShouldBeRemoved() {
        return false;
    }
};
​
class Client : public Updateable {
 
public:
    Client();    virtual ~Client();
​
     /**
     * 连接服务器
     * @param connector 传输协议，如 TCP， UDP ...
     * @param protocol 分包协议，如 TLV, Line, TDR ...
     * @param notice_callback 收到通知后触发的回调对象，如果传输协议有“连接概念”（如TCP/TCONND），建立、关闭连接时也会调用。
     * @param config 配置文件对象，将读取以下配置项目：MAX_TRANSACTIONS_OF_CLIENT 客户端最大并发连接数; BUFFER_LENGTH_OF_CLIENT客户端收包缓存；CLIENT_RESPONSE_TIMEOUT 客户端响应等待超时时间。
     * @return 返回 0 表示成功，其他表示失败
     */
    int Init(Connector* connector, Protocol* protocol,
             ClientCallback* notice_callback = NULL, Config* config = NULL);
​
    /**
     * callback 参数可以为 NULL，表示不需要回应，只是单纯的发包即可。
     */
    virtual int SendRequest(Request* request, ClientCallback* callback = NULL);
​
    /**
     * 返回值表示有多少数据需要处理，返回-1为出错，需要关闭连接。返回0表示没有数据需要处理。
     */
    virtual int Update();
    virtual void OnExit();
    void Close();
    Connector* connector() ;
    ClientCallback* notice_callback() ;
    Protocol* protocol() ;
};