#ifndef MEMCACHE_REQ_H
#define MEMCACHE_REQ_H

#include <sys/queue.h>

#include "../memcache.h"
#include "connection.h"

struct memcache_req {
    // the memcache context that we belong to
    struct memcache *mc;

    // the command to execute
    enum memcache_command cmd_type;

    // the reply we have received, or MEMCACHE_REPLY_INVALID
    enum memcache_reply reply_type;

    // our key/obj
    struct memcache_key key;
    struct memcache_obj obj;
    struct memcache_buf buf;

    // flags to indicate if we have valid obj/buf data
    char have_obj, have_buf;

    // our state
    enum memcache_req_state state;

    // our user callback argument
    void *cb_arg;

    // the conn 
    struct memcache_connection *conn;
    
    // we are a member of struct memcache_server.req_queue
    TAILQ_ENTRY(memcache_req) reqqueue_node;
};

/*
 * Allocate and return a new req, or NULL if unsuccesfull.
 */
struct memcache_req *memcache_req_alloc (struct memcache *mc, enum memcache_command cmd_type, const struct memcache_key *key, const struct memcache_obj *obj, const struct memcache_buf *buf, void *cb_arg);

/*
 * The request has been queued.
 */
void memcache_req_queued (struct memcache_req *req);

/*
 * The request is being sent.
 */
void memcache_req_send (struct memcache_req *req);

/*
 * The reply has been received, although if the respones also contains data, that will be notified separately.
 *
 * If the response doesn't contain any data, req_done will be called after this is. Otherwise, this will be called
 * first, followed by zero or more calls to req_data, followed by req_reply/RPL_END + req_done.
 *
 * Note that no req data will not be available when this is first called, only once req_data/req_done is called.
 */
void memcache_req_recv (struct memcache_req *req, enum memcache_reply reply_type);

/*
 * Some amount of reply data has been received. This may be called between the req_reply/MEMCACHE_RPL_VALUE and
 * req_reply/MEMCACHE_RPL_END + req_done notifications.
 *
 * Note that this is not always called, it is possible that one might have:
 *      memcache_req_reply(req, MEMCACHE_RPL_VALUE)
 *      memcache_req_reply(req, MEMCACHE_RPL_END)
 *      memcache_req_done(req)
 *
 * This will happen if both the value and the end replies are received in the same chunk.
 *
 * Note also that replies may have zero-length entries, in which case req_data will never be called either.
 */
void memcache_req_data (struct memcache_req *req);

/*
 * The request was sent and is now done, and is not associated with the connection anymore.
 *
 * This will be called before req_reply/req_data, but not before/after req_error.
 */
void memcache_req_done (struct memcache_req *req);

/*
 * An error occurred, and the request must be abandoned. This will assume that the req is not active or enqueued
 * anymore, and the req should not be accessed by memcache_* code after this.
 */
void memcache_req_error (struct memcache_req *req);

/*
 * Free an unused req. Should always be called by the user, not via internal means.
 */
void memcache_req_free (struct memcache_req *req);

#endif /* MEMCACHE_REQ_H */