/*
  Copyright 2010 Nathan Phillip Brink

  This file is a part of DistRen.

  DistRen is free software: you can redistribute it and/or modify
  it under the terms of the GNU Affero General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  DistRen is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Affero General Public License for more details.

  You should have received a copy of the GNU Affero General Public License
  along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
*/

struct distrend_clientset;
struct distrend_listen;
struct distrend_client;

#ifndef _DISTREN_LISTEN_H
#define _DISTREN_LISTEN_H

#include "distrend.h"
#include "common/protocol.h"

#include <queue.h>
#include <time.h>

/**
   How long a client has after connecting to send
   authentication information before his connection is cleaned
   up.
 */
#define DISTREND_LISTEN_AUTHTIME 32

/**
   How long a client has when in DISTREND_CLIENT_BAD before
   his connection is dropped. This grace time is intended so that
   the client will actually see his disconnect message instead of
   just having his connection reset.
 */
#define DISTREND_LISTEN_DISCONNECT_GRACE 8

enum distrend_client_state
  {
    /**
       We don't yet know the client. It may only use authentication
       commands.
     */
    DISTREND_CLIENT_PREAUTH,
    /**
       The client is authenticated, etc.
     */
    DISTREND_CLIENT_GOOD,
    /**
       The client is queued to be disconnected. (This state exists
       so that the client at least has a chance to recieve its
       disconnect message/error before being dumped).
     */
    DISTREND_CLIENT_BAD,
    /**
       The socket used to communicate with the client is closed. Its entry
       in the client list should be removed on the next garbage clean-up round.
     */
    DISTREND_CLIENT_DEAD
  };

struct distrend_listen
{
  int port;
  int sock;
};

struct distrend_client
{
  int sock;
  enum distrend_client_state state;

  /**
     The absolute time at which this client's entry in the client list will be
     expired, closed, and marked as dead so that it may be cleaned up. This is
     used to implement ping timeouts (if state == DISTREND_CLIENT_GOOD) and 
     disconnect message grace time (if state == DISTREND_CLIENT_BAD).
   */
  time_t cleanup_time;

  size_t inlen; /*< number of bytes waiting to be processed */
  size_t expectlen; /*< number of bytes that inlen has to be for a complete request to be had, 0 when waiting on header */
  QUEUE *inmsgs;
  QUEUE *outmsgs;
};



typedef int(*distrend_handle_request_t)(struct distrend_client *client, struct distren_request *req, void *reqdata, void *data);


/**
   initializes the listens and clientset
   @param config the configuration from distrend
   @param clients a pointer to a struct distrend_clientset pointer which will be set to memory allocated for the clientset
 */
int distrend_listen(struct distrend_config *config, struct distrend_clientset **clients);

/**
   checks states of the sockets I'm managing. If there are any new connections,
   or activity on any sockets, I'll call the appropriate function.
   I will block until there is some sort of activity, including
   signals. If you want to cleanly shut down, it's best to register
   signal handlers somewhere
 */
int distrend_accept(struct distrend_config *config, struct distrend_clientset *clients, distrend_handle_request_t handlereq, void *handlereqdata);

/**
   cleans listening socket. Unnecessary for a working server, currently a stub.
 */
int distrend_unlisten(struct distrend_listen *listens, struct distrend_clientset *clients);

/**
   writes message to client.
   @param towrite the caller is expected to free this string. This function will
   strdup() it, in essence.
 */
int distrend_client_write(struct distrend_client *client, char *towrite, size_t msglen);

/**
   writes request to client.
   @param client client to write to
   @param req the request struct. caller must free this.
   @param data the data of the request which is req->len bytes long. caller must free this.
 */
int distrend_client_write_request(struct distrend_client *client, struct distren_request *req, void *data);

/**
   This is probably just NOT a placeholder for remotio
*/
void remotio_send_to_client();

/**
   Queue a DISTREN_REQUEST_DISCONNECT and prepare a client
   to be disconnected.
 */
int distrend_send_disconnect(struct distrend_client *client, char *quit_msg);


#endif