// TODO: Break out `run_*` into `*.{c,h}`?
 // TODO: Harmonize all reporting strings and comments.
 // TODO: Harmonize all conditional and loop statements.
 // TODO: Add `listen` and `accept` if the socket has a `STREAM` `socktype`.

 // TODO: Compare to the example in `getaddrinfo(3)`.
 // TODO: Mention `getaddrinfo` and the RFC 3484 sorting order in readme.
 // TODO: Change client store from queue to binary tree?

 // TODO: Create graph of parameter flow.
 // TODO: Use Kaj and Börje in readme example.
 // TODO: Document idioms:
 // - Trim: `buflen -= buflen && buf[buflen - 1] == char;`
 // - Format: `buflen += snprintf(&buf[buflen], BUFLEN_MAX - buflen, format, args...);`
 // TODO: Document "size" for raw bytes and "len" for "logical" data (e.g.
 // excluding string terminating null).
 // TODO: Give each client an `id`.
 // TODO: Also make the server send a timestamp base on join?
 // TODO: `#include <stdbool.h>` and change any relevant `int`s to `bool`s.
 // TODO: Change to `run_*(int * sockfd, int sockfdlen, bool nonblock)`.
 // TODO: Do different things on `initsockfd` depending on `family`.
 // TODO: We can combine IDs and actions: an ID of 0 implies a JOIN action,
 // otherwise a MESSAGE action.

 
 /// Headers
 
 //// POSIX 2004
 #define _XOPEN_SOURCE 600
 
 //// C standard library
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <ctype.h>
 #include <limits.h>
 
 //// POSIX
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/select.h>
 #include <netdb.h>
 #include <search.h>
 #include <termios.h>
 
 // Other

 #include "arg.h"

 #include "report.h"
 
 

 /// Constants
 
 //// Program

 
 #define PROGNAME "sockchat"
 
 //// Arguments
 // TODO
 // #define DEFAULT_FAMILY   "UNSPEC"
 // #define DEFAULT_SOCKTYPE "0"
 #define DEFAULT_FAMILY   "INET"
 #define DEFAULT_SOCKTYPE "DGRAM"
 #define DEFAULT_PROTOCOL "0"
 #define DEFAULT_NODE     ""
 #define DEFAULT_SERVICE  "3200"
 
 //// Command line interface
 #define VERSION \

     PROGNAME " 1.0\n"

 #define USAGE \
     "Usage:\n" \
     "  " PROGNAME " (server|client) [options]\n" \
     "  " PROGNAME " -h|--help\n" \
     "  " PROGNAME " --version\n"

 #define DESCRIPTION \
     "Chat with unlimited number of peers through a variety of sockets.\n"

 #define OPTIONS \
     "Options:\n" \
     "  -f <family>    [default: " DEFAULT_FAMILY   "]\n" \
     "  -t <socktype>  [default: " DEFAULT_SOCKTYPE "]\n" \
     "  -p <protocol>  [default: " DEFAULT_PROTOCOL "]\n" \
     "  -n <node>      [default: " DEFAULT_NODE     "]\n" \
     "  -s <service>   [default: " DEFAULT_SERVICE  "]\n"
 
 //// Implementation

 #define BUFLEN_MAX _POSIX_MAX_CANON

 
 
 /// Forward declarations
 
 //// Implementation

 int initsockfd(
     char const * init_name,
     int (*init)(int sockfd, struct sockaddr const * addr, socklen_t addrlen),

     int flags,
     int family,
     int socktype,
     int protocol,
     char const * node,
     char const * service
 );
 void run_server(int sockfd);
 void run_client(int sockfd);
 
 
 /// Data
 
 //// Arguments

 #define ROLE(ROLE, INIT, FLAGS) { #ROLE, #INIT, INIT, FLAGS, run_##ROLE }

 struct role {
     char const * name;

     char const * init_name;
     int (*init)(int sockfd, struct sockaddr const * addr, socklen_t addrlen);

     int flags;
     void (*run)(int sockfd);
 };
 static struct role roles[] = {
     ROLE(server, bind, AI_PASSIVE),
     ROLE(client, connect, 0),
 };

 
 #define CONST_FAMILY(FAMILY) { #FAMILY, AF_##FAMILY }
 static struct arg_const families[] = {
     CONST_FAMILY(UNSPEC),
     CONST_FAMILY(INET),
     CONST_FAMILY(INET6),
     CONST_FAMILY(UNIX),

 };

 
 #define CONST_SOCKTYPE(SOCKTYPE) { #SOCKTYPE, SOCK_##SOCKTYPE }
 static struct arg_const socktypes[] = {
     // { "0", 0 },
     CONST_SOCKTYPE(DGRAM),
     // CONST_SOCKTYPE(SEQPACKET),
     // CONST_SOCKTYPE(STREAM),
     // CONST_SOCKTYPE(RAW),

 };

 
 #define CONST_PROTOCOL(PROTOCOL) { #PROTOCOL, IPPROTO_##PROTOCOL }
 static struct arg_const protocols[] = {

     { "0", 0 },

     // CONST_PROTOCOL(IP),
     // CONST_PROTOCOL(IPV6),
     // CONST_PROTOCOL(ICMP),
     // CONST_PROTOCOL(TCP),
     // CONST_PROTOCOL(UDP),
     // CONST_PROTOCOL(RAW),

 };
 
 
 /// Command line interface

 void version    (FILE * stream) { fprintf(stream, "%s", VERSION);     }
 void usage      (FILE * stream) { fprintf(stream, "%s", USAGE);       }
 void description(FILE * stream) { fprintf(stream, "%s", DESCRIPTION); }
 void options    (FILE * stream) { fprintf(stream, "%s", OPTIONS);     }
 void args       (FILE * stream) {
     ARG_PRINT(stream, family,   families ); fprintf(stream, "\n");
     ARG_PRINT(stream, socktype, socktypes); fprintf(stream, "\n");
     ARG_PRINT(stream, protocol, protocols);

 }
 void help(FILE * stream) {

     version    (stream); fprintf(stream, "\n");
     usage      (stream); fprintf(stream, "\n");
     description(stream); fprintf(stream, "\n");
     options    (stream); fprintf(stream, "\n");
     args       (stream);

 }
 
 

 /// Main
 

 int main(int argc, char * argv[]) {
     // Command line interface

     ARG_SPECIALS()
     ARG_DECLARE(role,     NULL)
     ARG_DECLARE(family,   DEFAULT_FAMILY)
     ARG_DECLARE(socktype, DEFAULT_SOCKTYPE)
     ARG_DECLARE(protocol, DEFAULT_PROTOCOL)
     ARG_DECLARE(node,     DEFAULT_NODE)
     ARG_DECLARE(service,  DEFAULT_SERVICE)
     ARG_POSITIONAL(role)
     ARG_GETOPT_BEGIN("f:t:p:n:s:")
     ARG_GETOPT_WITH_ARGUMENT('f', family)
     ARG_GETOPT_WITH_ARGUMENT('t', socktype)
     ARG_GETOPT_WITH_ARGUMENT('p', protocol)
     ARG_GETOPT_WITH_ARGUMENT('n', node)
     ARG_GETOPT_WITH_ARGUMENT('s', service)
     ARG_GETOPT_END()
     ARG_CONVERT_FIND(role, role, roles)
     ARG_CONVERT_FIND_CONST(family,   families)
     ARG_CONVERT_FIND_CONST(socktype, socktypes)
     ARG_CONVERT_FIND_CONST(protocol, protocols)
     ARG_CONVERT_NULL(node)
     ARG_CONVERT_NULL(service)
     ARG_CATCH()

 
     // Implementation

     report_info(0, "Using buffer length %d", BUFLEN_MAX);
     role->run(initsockfd(
         role->init_name,
         role->init,

         role->flags,

         family,
         socktype,
         protocol,

         node,
         service
     ));
 }
 
 
 /// Implementation
 

 //// Common
 
 // `NI_MAXHOST` and `NI_MAXSERV` are non-standard.
 static char gai_host[1025];
 static char gai_serv[32];
 static int gai_errno;
 
 #define ACTION_NONE    0
 #define ACTION_LEAVE   1
 #define ACTION_JOIN    2
 #define ACTION_MESSAGE 3
 struct action {
     char const * name;
     int value;
 };
 #define ACTION(ACTION) { #ACTION, ACTION_##ACTION }
 static struct action actions[] = {
     ACTION(NONE),
     ACTION(LEAVE),
     ACTION(JOIN),
     ACTION(MESSAGE),
 };
 
 // TODO: Call and print results of `getsockname` and `getpeername`?
 int initsockfd(
     char const * init_name,
     int (*init)(int sockfd, struct sockaddr const * addr, socklen_t addrlen),

     int flags,
     int family,
     int socktype,
     int protocol,
     char const * node,
     char const * service
 ) {
     int sockfd;

     // Initialize socket.

     {
         struct addrinfo * addrinfos;
         // Get addresses.
         {

             // The assumption of these flags are non-standard.
             flags |= AI_V4MAPPED | AI_ADDRCONFIG;
             struct addrinfo hints = {
                 flags, family, socktype, protocol, 0, 0, 0, 0
             };

             if (0 != (gai_errno = getaddrinfo(
                 node, service, &hints, &addrinfos
             )))

                 report_fatal(
                     gai_errno == EAI_SYSTEM ? errno : 0,
                     "Failed to get %s addresses for '%s:%s': %s",
                     init_name,
                     node    ? node    : "",
                     service ? service : "",
                     gai_strerror(gai_errno)

                 );
         }

         // Try init on addresses until one works.

         struct addrinfo * addrinfo;
         for (
             addrinfo = addrinfos;
             addrinfo != NULL;
             addrinfo = addrinfo->ai_next
         ) {

             // Get address name.
             if (0 != (gai_errno = getnameinfo(
                 addrinfo->ai_addr,
                 addrinfo->ai_addrlen,
                 gai_host,
                 sizeof(gai_host),
                 gai_serv,
                 sizeof(gai_serv),
                 NI_NUMERICHOST | NI_NUMERICSERV
             ))) {
                 report_error(
                     gai_errno == EAI_SYSTEM ? errno : 0,
                     "Failed to get %s address name: %s",
                     init_name,
                     gai_strerror(gai_errno)
                 );
                 continue;
             }
             report_info(0, "Trying to %s to '%s:%s'...",
                 init_name, gai_host, gai_serv
             );

             // Create socket.
             if (-1 == (sockfd = socket(
                 addrinfo->ai_family,
                 addrinfo->ai_socktype,
                 addrinfo->ai_protocol
             ))) {

                 report_error(errno, "Failed to create %s socket", init_name);

                 continue;
             }

             // Perform init.
             if (-1 == init(

                 sockfd,
                 addrinfo->ai_addr,
                 addrinfo->ai_addrlen
             )) {

                 report_error(errno, "Failed to %s to '%s:%s'",
                     init_name, gai_host, gai_serv
                 );

                 close(sockfd);
                 continue;
             }
             // Succeeded.

             report_info(0, "Succeeded to %s to '%s:%s'",
                 init_name, gai_host, gai_serv
             );

             break;
         }

         // Fail.

         if (NULL == addrinfo)

             report_fatal(0, "Failed to %s", init_name);

         // Clean up.
         freeaddrinfo(addrinfos);
     }
     return sockfd;
 }
 
 

 //// Server

 // TODO: Also store `addlen` in `client` (and use in `memcmp`)?
 void run_server(int sockfd) {

     // Client data.
     struct client_data {

         char * user_name;

     };
 
     // Client accounting.
     struct client {
         struct client * next;
         struct client * prev;
         struct sockaddr_storage addr;

         void * data;

     };
     struct client * clients = NULL;
 

     // Allocate socket buffer.
     ssize_t sockbuflen;
     char * sockbuf = malloc(BUFLEN_MAX + 1);
     if (!sockbuf)
         report_fatal(errno, "Failed to allocate %s of size %d",
             "input buffer", BUFLEN_MAX + 1
         );

 
     // Talk to clients.
     while (1) {

         // Get client and action.
         // `NI_MAXHOST` and `NI_MAXSERV` are non-standard.

         struct sockaddr_storage addr;
         struct client * client;

         struct action action;
         {
             // Peek receive.
             ssize_t recvlen;
             socklen_t addrlen = sizeof(addr);
             if (-1 == (recvlen = recvfrom(
                 sockfd,
                 // TODO
                 sockbuf,
                 BUFLEN_MAX,
                 // NULL,
                 // 0,
                 MSG_PEEK, // TODO: Also specify `MSG_TRUNC` so that we don't have to give the buffer?

                 (struct sockaddr *)&addr,

                 &addrlen

             )))

                 report_fatal(errno, "Failed to peek receive");
             // Check for too large addresses (guaranteed not to happen).
             if (addrlen > sizeof(addr))
                 report_fatal(0,
                     "Failed to store address of size %d, max size is %d",
                     addrlen, sizeof(addr)

                 );

             // Get client address name.

             if (0 != (gai_errno = getnameinfo(
                 (struct sockaddr *)&addr,
                 addrlen,

                 gai_host,
                 sizeof(gai_host),
                 gai_serv,
                 sizeof(gai_serv),
                 NI_NUMERICHOST | NI_NUMERICSERV

             )))

                 report_fatal(
                     gai_errno == EAI_SYSTEM ? errno : 0,
                     "Failed to get client address name: %s",

                     gai_strerror(gai_errno)
                 );

             // Look up client.
             for (
                 client = clients;
                 client != NULL;
                 client = client->next
             )
                 if (0 == memcmp(&client->addr, &addr, sizeof(addr)))
                     break;
             // Look up action.
             action = actions[!!recvlen<<1 | !!client<<0];
             // Report.
             report_info(0, "Received %d byte%s from '%s:%s' %s",
                 recvlen,
                 recvlen == 1 ? "" : "s",
                 gai_host,
                 gai_serv,
                 action.name
             );
         }
         // No action.
         if (action.value == ACTION_NONE) {
             // Receive none.
             if (-1 == recv(sockfd, NULL, 0, 0))
                 report_fatal(errno, "Failed to receive %s", action.name);
             continue;
         }
         // Client left.
         else if (action.value == ACTION_LEAVE) {
             // Receive leave.
             if (-1 == recv(sockfd, NULL, 0, 0))
                 report_fatal(errno, "Failed to receive %s", action.name);
             // Client data.
             struct client_data * client_data = client->data;
             free(client_data->user_name);
             free(client_data);
             // Client accounting.
             remque(client);
             free(client);
             // Done.
             continue;
         }
         // Client joined.
         else if (action.value == ACTION_JOIN) {
             sockbuflen = 0;
             // Receive.
             {
                 ssize_t recvlen;
                 if (-1 == (recvlen = recv(
                     sockfd, sockbuf, BUFLEN_MAX - sockbuflen, 0
                 )))
                     report_fatal(errno, "Failed to receive %s", action.name);
                 sockbuflen += recvlen;
             }
             // Validate.
             if (!sockbuflen || sockbuf[sockbuflen - 1] != '\0') {
                 report_error(0, "Malformed %s", action.name);
             }
             // Client data.
             struct client_data * client_data;
             if (NULL == (client_data = malloc(sizeof(*client_data))))
                 report_fatal(errno, "Failed to allocate %s of size %d",
                     "client data", sizeof(*client_data)
                 );
             if (NULL == (client_data->user_name = strdup(sockbuf)))
                 report_fatal(errno, "Failed to allocate %s",
                     "client user name"
                 );
             // Client accounting.
             if (NULL == (client = calloc(1, sizeof(*client))))
                 report_fatal(errno, "Failed allocate %s of size %d",
                     "client", sizeof(*client)
                 );
             insque(client, &clients);
             client->addr = addr;
             client->data = client_data;
             // Done.

             continue;
         }
         // Client sent message.

         else if (action.value == ACTION_MESSAGE) {
             sockbuflen = 0;
             // Client data.
             struct client_data * client_data = client->data;
             // TODO: `snprintf` returns how many bytes *would* have been
             // written! Use `strlen`?
             sockbuflen += snprintf(
                 &sockbuf[sockbuflen], BUFLEN_MAX - sockbuflen, "[%s:%s] %s: ",
                 gai_host, gai_serv, client_data->user_name
             );
             // Receive message.
             {
                 ssize_t recvlen;
                 if (-1 == (recvlen = recv(
                     sockfd, &sockbuf[sockbuflen], BUFLEN_MAX - sockbuflen, 0
                 )))
                     report_fatal(errno, "Failed to receive %s", action.name);
                 sockbuflen += recvlen;
             }
             sockbuflen -= sockbuflen && sockbuf[sockbuflen - 1] == '\0';
             // Finalize buffer.
             sockbuf[sockbuflen++] = '\0';
             // Send message.
             for (
                 client = clients;
                 client != NULL;
                 client = client->next
             ) {
                 if (-1 == sendto(
                     sockfd,
                     sockbuf,
                     sockbuflen,
                     0,
                     (struct sockaddr *)&client->addr,
                     sizeof(client->addr)
                 ))
                     report_fatal(errno, "Failed to send %s", action.name);
             }
         } else {
             report_fatal(0, "Unexpected action %d", action.value);

         }
     }
 }
 
 

 //// Client
 
 static struct termios termios_stdin;
 static void termios_restore() {
     if (-1 == tcsetattr(STDIN_FILENO, TCSANOW, &termios_stdin))
         report_fatal(errno, "Failed to restore terminal settings");
 }
 static void termios_setup() {
     if (-1 == tcgetattr(STDIN_FILENO, &termios_stdin))
         report_fatal(errno, "Failed to get terminal settings");
     {
         struct termios termios = termios_stdin;
         termios.c_lflag &= ~(ICANON | ECHO);
         if (-1 == tcsetattr(STDIN_FILENO, TCSANOW, &termios))
             report_fatal(errno, "Failed to set terminal settings");
     }
     atexit(termios_restore);
 }
 

 void run_client(int sockfd) {
     // Allocate socket buffer.

     ssize_t sockbuflen;
     char * sockbuf = malloc(BUFLEN_MAX + 1);

     if (!sockbuf)

         report_fatal(errno, "Failed to allocate %s of size %d",
             "input buffer", BUFLEN_MAX + 1

         );
 
     // Allocate input buffer.

     ssize_t inputbuflen;
     char * inputbuf = malloc(BUFLEN_MAX + 1);

     if (!inputbuf)

         report_fatal(errno, "Failed to allocate %s of size %d",
             "socket buffer", BUFLEN_MAX + 1

         );
 
     // Join.
     {

         struct action action = actions[ACTION_JOIN];
         // Get user name.
         printf("User name: ");
         fflush(stdout);
         if (-1 == (inputbuflen = read(STDIN_FILENO, inputbuf, BUFLEN_MAX)))
             report_fatal(errno, "Failed to read user name");
         inputbuflen -= inputbuflen && inputbuf[inputbuflen - 1] == '\n';
         // Send join.
         inputbuf[inputbuflen++] = '\0';
         if (-1 == send(sockfd, inputbuf, inputbuflen, 0))
             report_fatal(errno, "Failed to send %s", action.name);

         // if (-1 == recv(sockfd, sockbuf, BUFLEN_MAX, MSG_PEEK))
         //     report_fatal(errno, "Failed to receive %s", action.name);

     }
 

     // Setup terminal.
     termios_setup();
 

     // Talk to user and server.
     inputbuflen = 0;
     while (1) {
         // Wait for data to be available from input or socket.
         fd_set rfds;
         FD_ZERO(&rfds);
         FD_SET(STDIN_FILENO, &rfds);
         FD_SET(sockfd, &rfds);
         if (-1 == select(sockfd+1, &rfds, NULL, NULL, NULL)) {
             printf("\n");
             report_fatal(errno, "Failed to wait for data");
         }
         // Clear input line.

         printf("\r%*s\r", (int)inputbuflen, "");

         // Socket data available.
         if (FD_ISSET(sockfd, &rfds)) {
             // Receive.

             if (-1 == (sockbuflen = recv(sockfd, sockbuf, BUFLEN_MAX, 0)))

                 report_fatal(errno, "Failed to receive");
             sockbuf[sockbuflen++] = '\0';
             // Print socket line.
             printf("%s\n", sockbuf);
         }
         // Input data available.
         if (FD_ISSET(STDIN_FILENO, &rfds)) {
             // Read.
             char c;
             if (-1 == read(STDIN_FILENO, &c, 1))

                 report_fatal(errno, "Failed to read");

             // Printable with non-full buffer.

             if (isprint(c) && inputbuflen < BUFLEN_MAX) {

                 // Add.
                 inputbuf[inputbuflen++] = c;
             // Backspace.
             } else if (c == '\b' || c == 127) {
                 // Remove last character from buffer.
                 if (inputbuflen)
                     --inputbuflen;
             // Enter.
             } else if (c == '\n' || c == '\r') {
                 // Send.

                 inputbuf[inputbuflen] = '\0';

                 if (-1 == send(sockfd, inputbuf, inputbuflen, 0))
                     report_fatal(errno, "Failed to send");
                 // Quit if input line empty.
                 if (!inputbuflen)
                     break;
                 // Reset input line.
                 inputbuflen = 0;
             }
         }
         // Print input line.

         // TODO: Have we not "finalized" the buffer here?
         printf("%.*s", (int)inputbuflen, inputbuf);

         fflush(stdout);
     }
 }