/*
Copyright (C) 1996-1997 Id Software, Inc.

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

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// net.h -- quake's interface to the networking layer

#define PORT_ANY  -1

typedef struct
{
  byte  ip[4];
  unsigned short  port;
  unsigned short  pad;
} netadr_t;

extern  netadr_t  net_local_adr;
extern  netadr_t  net_from;   // address of who sent the packet
extern  sizebuf_t net_message;

extern  cvar_t  hostname;

extern  int   net_socket;

void    NET_Init (int port);
void    NET_Shutdown (void);
qboolean  NET_GetPacket (void);
void    NET_SendPacket (int length, void *data, netadr_t to);

qboolean  NET_CompareAdr (netadr_t a, netadr_t b);
qboolean  NET_CompareBaseAdr (netadr_t a, netadr_t b);
char    *NET_AdrToString (netadr_t a);
char    *NET_BaseAdrToString (netadr_t a);
qboolean  NET_StringToAdr (char *s, netadr_t *a);
qboolean NET_IsClientLegal(netadr_t *adr);

//============================================================================

#define OLD_AVG   0.99    // total = oldtotal*OLD_AVG + new*(1-OLD_AVG)

#define MAX_LATENT  32

typedef struct
{
  qboolean  fatal_error;

  float   last_received;    // for timeouts

// the statistics are cleared at each client begin, because
// the server connecting process gives a bogus picture of the data
  float   frame_latency;    // rolling average
  float   frame_rate;

  int     drop_count;     // dropped packets, cleared each level
  int     good_count;     // cleared each level

  netadr_t  remote_address;
  int     qport;

// bandwidth estimator
  double    cleartime;      // if realtime > nc->cleartime, free to go
  double    rate;       // seconds / byte

// sequencing variables
  int     incoming_sequence;
  int     incoming_acknowledged;
  int     incoming_reliable_acknowledged; // single bit

  int     incoming_reliable_sequence;   // single bit, maintained local

  int     outgoing_sequence;
  int     reliable_sequence;      // single bit
  int     last_reliable_sequence;   // sequence number of last send

// reliable staging and holding areas
  sizebuf_t message;    // writing buffer to send to server
  byte    message_buf[MAX_MSGLEN];

  int     reliable_length;
  byte    reliable_buf[MAX_MSGLEN]; // unacked reliable message

// time and size data to calculate bandwidth
  int     outgoing_size[MAX_LATENT];
  double    outgoing_time[MAX_LATENT];
} netchan_t;

extern  int net_drop;   // packets dropped before this one

void Netchan_Init (void);
void Netchan_Transmit (netchan_t *chan, int length, byte *data);
void Netchan_OutOfBand (netadr_t adr, int length, byte *data);
void Netchan_OutOfBandPrint (netadr_t adr, char *format, ...);
qboolean Netchan_Process (netchan_t *chan);
void Netchan_Setup (netchan_t *chan, netadr_t adr, int qport);

qboolean Netchan_CanPacket (netchan_t *chan);
qboolean Netchan_CanReliable (netchan_t *chan);