src/main.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 Mike Becker. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

#define PROGRAM_VERSION "1.0 alpha"

#include <curses.h>
#include <string.h>
#include <time.h>
#include <locale.h>
#include <sys/stat.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
#include <getopt.h>

#include "chess/rules.h"
#include "chess/pgn.h"
#include "input.h"
#include "network.h"
#include "colors.h"

typedef struct {
    /**
     * Server host address.
     * TCP: server address or \c NULL when we are the server
     * Domain Socket: the path to the domain socket
     */
    char* serverhost;
    char* continuepgn;
    unsigned short time;
    unsigned short addtime;
    unsigned short delay;
    short port;
    uint8_t servercolor;
    bool timecontrol;
    bool ishost;
    bool usedomainsocket;
    bool singlemachine;
    bool disableflip;
    bool unicode;
} Settings;

static Settings settings;

static void init_settings(void) {
    memset(&settings, 0, sizeof(settings));
    settings.servercolor = WHITE;
    settings.port = 27015;
#ifndef DISABLE_UNICODE
    settings.unicode = !!setlocale(LC_CTYPE, "C.UTF-8");
#endif
}

static void cleanup() {
    endwin();
    if (settings.usedomainsocket && settings.ishost) {
        remove(settings.serverhost);
    }
}

static void settings_apply(GameState *gamestate) {
    gamestate->info.servercolor = settings.servercolor;
    gamestate->info.timecontrol = settings.timecontrol;
    gamestate->info.time = settings.time;
    gamestate->info.addtime = settings.addtime;
    gamestate->info.delay = settings.delay;
}

static int get_settings(int argc, char **argv) {
    char *valid;
    unsigned long int time, port;
    uint8_t timeunit = 60;
    size_t len;
    bool port_set = false;
    
    for (int opt ; (opt = getopt(argc, argv, "a:bc:d:Fhp:rsS:t:uUv")) != -1 ;) {
        switch (opt) {
        case 'c':
            settings.continuepgn = optarg;
            break;
        case 'b':
            settings.servercolor = BLACK;
            break;
        case 'r':
            settings.servercolor = rand() & 1 ? WHITE : BLACK;
            break;
        case 's':
            settings.singlemachine = true;
            break;
        case 'F':
            settings.disableflip = true;
            break;
        case 'u':
            if (port_set) {
                fprintf(stderr, "Cannot use Unix domain sockets "
                        "when a TCP port was specified.\n");
                return 1;
            }
            settings.usedomainsocket = true;
            break;
        case 'U':
            settings.unicode = false;
            break;
        case 't':
        case 'a':
        case 'd':
            len = strlen(optarg);
            if (optarg[len-1] == 's') {
                optarg[len-1] = '\0';
                timeunit = 1;
            }
            
            if ((time = strtoul(optarg, &valid, 10))*timeunit > UINT16_MAX
                || *valid != '\0') {
                fprintf(stderr, "Specified time is invalid (%s)"
                    "- Maximum: 65535 seconds (1092 minutes)\n", optarg);
                return 1;
            } else {
                settings.timecontrol = 1;
                if (opt=='t') {
                    settings.time = timeunit * time;
                } else if (opt=='a') {
                    settings.addtime = time;
                } else {
                    settings.delay = time;
                }
            }
            break;
        case 'p':
            if (port_set) {
                fprintf(stderr, "Cannot use -p twice.\n");
                return 1;
            }
            if (settings.usedomainsocket) {
                fprintf(stderr, "Cannot specify TCP port "
                        "when using Unix domain sockets.\n");
                return 1;
            }
            port = strtol(optarg, &valid, 10);
            if (port < 1025 || port > 65535 || *valid != '\0') {
                fprintf(stderr,
                    "Invalid port number (%s) - choose a number between "
                    "1025 and 65535\n",
                    optarg);
                return 1;
            } else {
                settings.port = (short) port;
                port_set = true;
            }
            break;
        case 'v':
            printf("terminal-chess : Version %s (Netcode Version %d)\n",
                PROGRAM_VERSION, NETCODE_VERSION);
            exit(0);
        case 'h':
        case '?':
            printf(
"Usage: terminal-chess [OPTION]... [HOST]\n"
"Starts/joins a network chess game\n"
"\nGeneral options\n"
"  -c <PGN file> Continue the specified game\n"
"  -h            This help page\n"
"  -p            TCP port to use (default: 27015)\n"
"  -u            Use Unix domain socket instead of TCP\n"
#ifndef DISABLE_UNICODE
"  -U            Disables unicode pieces\n"
#endif
"  -v            Print version information and exits\n"
"\nTime control (default: disabled)\n"
"  -t <time>     Time limit in minutes (or seconds when used with 's' suffix)\n"
"  -a <time>     The time in seconds to add after each move\n"
"  -d <time>     A delay in seconds before the clock starts ticking each move\n"
"\nServer options\n"
"  -b            Server plays black pieces (default: white)\n"
"  -r            Distribute color randomly\n"
"\nHot seat\n"
"  -s            Play a hot seat game (network options are ignored)\n"
"  -F            Do not automatically flip the board in hot seat games\n"
"\nNotes\n"
"Use '-' for PGN files to read PGN data from standard input\n\n"
"When playing over Unix domain socket, the HOST denotes the socket path.\n"
"When the path doest not exist, a game is created. Otherwise, the program\n"
"joins the existing game. When HOST is omitted, /tmp/chess.sock is used.\n"
            );
            exit(0);
        }
    }
    
    if (optind == argc - 1) {
        settings.serverhost = argv[optind];
    } else if (optind < argc - 1) {
        fprintf(stderr, "Too many arguments\n");
        return 1;
    }
    
        
    if (settings.continuepgn) {
        if (settings.serverhost) {
            fprintf(stderr, "Can't continue a game when joining a server.\n");
            return 1;
        }
    }

    if (settings.usedomainsocket) {
        if (!settings.serverhost) {
            settings.serverhost = "/tmp/chess.sock";
        }
        struct stat st;
        if (stat(settings.serverhost, &st) == 0) {
            if (S_ISSOCK(st.st_mode)) {
                settings.ishost = false;
            } else {
                fprintf(stderr, "%s is not a Unix domain socket.\n",
                    settings.serverhost);
                return 1;
            }
        } else {
            settings.ishost = true;
        }
    } else {
        settings.ishost = !settings.serverhost;
    }
    
    return 0;
}

static const uint8_t boardx = 4, boardy = 10;
static int inputy = 21; /* should be overridden on game startup */

static int timecontrol(GameState *gamestate) {
    if (gamestate->info.timecontrol) {
        uint16_t white = remaining_movetime(gamestate, WHITE);
        uint16_t black = remaining_movetime(gamestate, BLACK);
        char clkstr[16];
        bool always_hours = gamestate->info.time >= 3600;
        print_clk(white, clkstr, always_hours);
        mvaddstr(boardy+4, boardx-1, "White time: ");
        addstr(clkstr);
        print_clk(black, clkstr, always_hours);
        mvaddstr(boardy+5, boardx-1, "Black time: ");
        addstr(clkstr);

        if (white == 0) {
            move(inputy, 0);
            addstr("Time is over - Black wins!");
            clrtobot();
            refresh();
            return 1;
        }
        if (black == 0) {
            move(inputy, 0);
            addstr("Time is over - White wins!");
            clrtobot();
            refresh();
            return 1;
        }
    }

    return 0;
}

static void draw_board(GameState *gamestate, Color perspective) {
    if (gamestate->movecount == 0) {
        mvaddstr(0, 0, gamestate->fen_start);
    } else {
        mvaddstr(0, 0, gamestate->fen[gamestate->movecount - 1]);
    }

    for (Rank y = 0 ; y < 8 ; y++) {
        for (File x = 0 ; x < 8 ; x++) {
            Piece piece = piece_at(gamestate, x, y);
            Color col = piece_color(piece);

            char piecestr[5];
            if (piece) {
                if (settings.unicode) {
                    char* uc = getpieceunicode(piece);
                    strncpy(piecestr, uc, 5);
                } else {
                    piecestr[0] = (piece & PIECE_MASK) == PAWN
                                      ? 'P' : getpiecechr(piece);
                    piecestr[1] = '\0';
                }
            } else {
                piecestr[0] = ' ';
                piecestr[1] = '\0';
            }

            bool boardblack = (y&1)==(x&1);
            attrset((col==WHITE ? A_BOLD : A_DIM)|
                COLOR_PAIR(col == WHITE ?
                    (boardblack ? COL_WB : COL_WW) :
                    (boardblack ? COL_BB : COL_BW)
                )
            );

            int cy = perspective == WHITE ? boardy-y : boardy-7+y;
            int cx = perspective == WHITE ? boardx+x*3 : boardx+21-x*3;
            mvaddch(cy, cx, ' ');
            addstr(piecestr);
            addch(' ');
        }
    }

    attrset(A_NORMAL);
    for (uint8_t i = 0 ; i < 8 ; i++) {
        int x = perspective == WHITE ? boardx+i*3+1 : boardx+22-i*3;
        int y = perspective == WHITE ? boardy-i : boardy-7+i;
        mvaddch(boardy+1, x, 'a'+i);
        mvaddch(y, boardx-2, '1'+i);
    }

    /* move log */
    uint8_t logy = 2;
    const uint8_t logx = boardx + 28;
    move(logy, logx);

    /* count full moves */
    unsigned int logi = 0;

    /* wrap log after 45 moves */
    while (gamestate->movecount/6-logi/3 >= 15) {
        logi++;
    }

    for (unsigned mi = logi*2 ; mi < gamestate->movecount ; mi++) {
        bool iswhite = mi % 2 == 0;
        if (iswhite) {
            logi++;
            printw("%d. ", logi);
        }

        addstr(gamestate->moves[mi].string);
        if (!iswhite && logi%3 == 0) {
            move(++logy, logx);
        } else {
            addch(' ');
        }
    }
}

static void eval_move_failed_msg(int code) {
    switch (code) {
    case AMBIGUOUS_MOVE:
        addstr("Ambiguous move - please specify the piece to move.");
        break;
    case PIECE_NOT_FOUND:
        addstr("No piece can be moved this way.");
        break;
    case NEED_PROMOTION:
        addstr("You need to promote the pawn (append \"=Q\" e.g.)!");
        break;
    case KING_IN_CHECK:
        addstr("Your king is in check!");
        break;
    case PIECE_PINNED:
        addstr("This piece is pinned!");
        break;
    case INVALID_MOVE_SYNTAX:
        addstr("Can't interpret move - please use algebraic notation.");
        break;
    case RULES_VIOLATED:
        addstr("Move does not comply with chess rules.");
        break;
    case KING_MOVES_INTO_CHECK:
        addstr("Can't move the king into a check position.");
        break;
    case MISSING_CHECK:
        addstr("Move does not indicate check.");
        break;
    case MISSING_CHECKMATE:
        addstr("Move does not indicate checkmate.");
        break;
    case INVALID_CHECK:
        addstr("Move incorrectly indicates check.");
        break;
    case INVALID_CHECKMATE:
        addstr("Move incorrectly indicates checkmate.");
        break;
    default:
        addstr("Unknown move parser error.");
    }
}

static void save_pgn(GameState *gamestate) {
    int y;
    {
        int x;
        getyx(stdscr, y, x);
        (void)x; /* we want to be POSIX curses compliant */
    }

    /* ask for player names */
    {
        char pname[PLAYER_NAME_BUFLEN];
        printw("\rWhite's name (%s): ", pgn_player_name(gamestate, WHITE));
        clrtoeol();
        if (getnstr(pname, PLAYER_NAME_BUFLEN) == OK && pname[0] != '\0') {
            strncpy(gamestate->wname, pname, PLAYER_NAME_BUFLEN);
        }
        move(y, 0);
        printw("\rBlack's name (%s): ", pgn_player_name(gamestate, BLACK));
        clrtoeol();
        if (getnstr(pname, PLAYER_NAME_BUFLEN) == OK && pname[0] != '\0') {
            strncpy(gamestate->bname, pname, PLAYER_NAME_BUFLEN);
        }
        move(y, 0);
    }

    bool export_comments = prompt_yesno("Export with comments");

    addstr("\rFilename: ");
    clrtoeol();

    char filename[64];
    if (getnstr(filename, 64) == OK && filename[0] != '\0') {
        move(y, 0);
        FILE *file = fopen(filename, "w");
        if (file) {
            write_pgn(file, gamestate, export_comments);
            fclose(file);
            addstr("File saved.");
        } else {
            printw("Can't write to file (%s).", strerror(errno));
        }
        clrtoeol();
    }
}

#define MOVESTR_BUFLEN 10
static int domove_singlemachine(GameState *gamestate, Color curcolor) {
    size_t bufpos = 0;
    char movestr[MOVESTR_BUFLEN];

    flushinp();
    while (1) {
        const char *curcolorstr = curcolor == WHITE ? "White" : "Black";
        if (timecontrol(gamestate)) {
            return 1;
        }
        move(inputy, 0);
        printw(
            "Use chess notation to enter your move.\n"
            "Or use a command: remis, resign, savepgn\n\n"
            "%s to move: ", curcolorstr);
        clrtoeol();

        if (asyncgetnstr(movestr, &bufpos, MOVESTR_BUFLEN)) {
            if (strncmp(movestr, "resign", MOVESTR_BUFLEN) == 0) {
                if (curcolor == WHITE) {
                    gamestate->wresign = true;
                } else {
                    gamestate->bresign = true;
                }
                return 1;
            } else if (strncmp(movestr, "remis", MOVESTR_BUFLEN) == 0) {
                gamestate->remis = true;
                return 1;
            } else if (strncmp(movestr, "savepgn", MOVESTR_BUFLEN) == 0) {
                save_pgn(gamestate);
            } else if (movestr[0] == 0) {
                /* ignore empty move strings and ask again */
            } else {
                Move move;
                int result = eval_move(gamestate,
                    movestr, curcolor, &move);
                if (result == VALID_MOVE_SYNTAX) {
                    result = validate_move(gamestate, &move);
                    if (result == VALID_MOVE_SEMANTICS) {
                        format_move(gamestate, &move);
                        apply_move(gamestate, &move);
                        if (is_game_running(gamestate)) {
                            return 0;
                        } else {
                            return 1;
                        }
                    } else {
                        eval_move_failed_msg(result);
                    }
                } else {
                    eval_move_failed_msg(result);
                }
                clrtoeol();
            }
        }
    }
}

#define NETMOVE_LEN 16
#define NETGI_LEN 8

static NetGameInfo hton_gi(GameInfo gi) {
    return (NetGameInfo) {
        .servercolor = gi.servercolor,
        .timecontrol = gi.timecontrol,
        .time = net_htons(gi.time),
        .addtime = net_htons(gi.addtime),
        .delay = net_htons(gi.delay)
    };
}

static GameInfo ntoh_gi(NetGameInfo gi) {
    return (GameInfo) {
        .servercolor = gi.servercolor,
        .timecontrol = gi.timecontrol,
        .time = net_ntohs(gi.time),
        .addtime = net_ntohs(gi.addtime),
        .delay = net_ntohs(gi.delay)
    };
}

static NetMove hton_move(Move move) {
    return (NetMove) {
        .mtime_sec = net_htonl(move.movetime / 1000000ull),
        .mtime_usec = net_htonl(move.movetime % 1000000ull),
        .piece = move.piece,
        .fromfile = move.fromfile, .fromrank = move.fromrank,
        .tofile = move.tofile, .torank = move.torank,
        .capture = move.capture,
        .check_or_mate = move.checkmate + move.check,
        .promotion = move.promotion,
    };
}

static Move ntoh_move(NetMove move) {
    return (Move) {
        .string = {0}, /* calculated before applying the move */
        .timestamp = {0}, /* planned to be removed */
        .movetime = (uint64_t)net_ntohl(move.mtime_sec)
                    * 1000000ull + net_ntohl(move.mtime_usec),
        .piece = move.piece,
        .fromfile = move.fromfile, .fromrank = move.fromrank,
        .tofile = move.tofile, .torank = move.torank,
        .promotion = move.promotion,
        .check = move.check_or_mate,
        .checkmate = move.check_or_mate >> 1,
        .capture = move.capture
    };
}

static int sendmove(GameState *gamestate, int opponent, Color mycolor) {

    size_t bufpos = 0;
    char movestr[MOVESTR_BUFLEN];
    bool remis_offered = false;
    bool remis_rejected = false;
    bool remis_suggested = false;
    bool resign_suggested = false;
    bool use_premove = false;
    uint8_t code;

    if (*gamestate->premove) {
        use_premove = true;
        const unsigned mlen = sizeof(gamestate->premove);
        strncpy(movestr, gamestate->premove, mlen);
        movestr[mlen] = '\0';
        memset(gamestate->premove, 0, mlen);
    }

    flushinp();
    while (1) {
        if (timecontrol(gamestate)) {
            net_send_code(opponent, NETCODE_TIMEOVER);
            return 1;
        }

        move(inputy, 0);
        addstr("Use chess notation to enter your move.\n");
        if (resign_suggested) {
            if (remis_suggested) {
                addstr("The opponent asks you to resign or accept remis. \n\n");
            } else {
                addstr("The opponent asks you to resign.                 \n\n");
            }
        } else if (remis_suggested) {
            addstr("The opponent offers remis. Type remis to accept. \n\n");
        } else if (remis_rejected) {
            addstr("Remis offer rejected.                            \n\n");
        } else if (remis_offered) {
            addstr("Remis offer sent.                                \n\n");
        } else {
            addstr("Or use a command: remis, resign, savepgn         \n\n");
        }
        addstr("Type your move: ");
        clrtoeol();

        /* check if the opponent sent us something */
        code = net_recieve_code_async(opponent);
        switch (code) {
            case NETCODE_REMIS:
                if (remis_offered) {
                    gamestate->remis = true;
                    return 1;
                }
                remis_suggested = true;
                break;
            case NETCODE_TAUNT:
                resign_suggested = true;
                break;
            case NETCODE_RESIGN:
                if (mycolor == WHITE) {
                    gamestate->bresign = true;
                } else {
                    gamestate->wresign = true;
                }
                return 1;
            case NETCODE_CONNLOST:
                gamestate->ragequit = true;
                return 1;
            case NETCODE_ERROR:
                addstr("\rCannot perform asynchronous network IO");
                cbreak(); getch();
                exit(EXIT_FAILURE);
            case NETCODE_AGAIN:
                /* try again */
                break;
            default:
                addstr("\nThe opponent sent an invalid network pacakge.");
        }

        /* read move */
        if (use_premove || asyncgetnstr(movestr, &bufpos, MOVESTR_BUFLEN)) {
            bool was_premove = use_premove;
            use_premove = false;
            if (strncmp(movestr, "resign", MOVESTR_BUFLEN) == 0) {
                if (mycolor == WHITE) {
                    gamestate->wresign = true;
                } else {
                    gamestate->bresign = true;
                }
                net_send_code(opponent, NETCODE_RESIGN);
                return 1;
            } else if (strncmp(movestr, "savepgn", MOVESTR_BUFLEN) == 0) {
                save_pgn(gamestate);
            } else if (strncmp(movestr, "remis", MOVESTR_BUFLEN) == 0) {
                if (remis_suggested) {
                    net_send_code(opponent, NETCODE_REMIS);
                    gamestate->remis = true;
                    return 1;
                } if (!remis_rejected) {
                    net_send_code(opponent, NETCODE_REMIS);
                    remis_offered = true;
                }
                /* prevent spamming the remis message */
            } else if (movestr[0] == 0) {
                /* ignore empty move strings and ask again */
            } else {
                Move move;
                int eval_result = eval_move(gamestate,
                    movestr, mycolor, &move);
                if (eval_result == VALID_MOVE_SYNTAX) {
                    NetMove nmove = hton_move(move);
                    net_send_data(opponent, NETCODE_MOVE, &nmove, NETMOVE_LEN);
                    code = net_recieve_code(opponent);
                    if (code == NETCODE_DECLINE_MOVE) {
                        uint8_t reason;
                        net_recieve_data(opponent, &reason, 1);
                        eval_move_failed_msg(reason);
                    } else if (code == NETCODE_ACCEPT_MOVE) {
                        format_move(gamestate, &move);
                        apply_move(gamestate, &move);
                        /* switch to waiting, even when the game ended.
                         * we want to receive the "game end" code from the
                         * other party.
                         */
                        return 0;
                    } else if (code == NETCODE_CONNLOST) {
                        addstr("Your opponent left the game.");
                        return 1;
                    } else {
                        addstr("Invalid network response.");
                    }
                } else {
                    if (was_premove) {
                        addstr("\nThe prepared move could not be executed.");
                    } else {
                        eval_move_failed_msg(eval_result);
                    }
                }
                clrtoeol();
            }
        }
    }
}

static int recvmove(GameState *gamestate, int opponent, Color mycolor) {
    memset(gamestate->premove, 0, sizeof(gamestate->premove));

    size_t bufpos = 0;
    char movestr[MOVESTR_BUFLEN];
    bool remis_suggested = false, remis_offered = false;
    bool resign_suggested = false;
    while (1) {
        timecontrol(gamestate);

        move(inputy, 0);
        addstr("Waiting for opponent. Use chess notation to prepare a move.\n");
        if (*gamestate->premove) {
            printw("Current pre-move: %s                             \n",
                gamestate->premove);
        } else if (remis_suggested && !resign_suggested) {
            addstr("Suggested remis.                                 \n");
        } else if (resign_suggested) {
            if (remis_suggested) {
                addstr("Suggested to resign or at least to accept remis. \n");
            } else {
                addstr("Suggested to resign.                             \n");
            }
        } else {
            addstr("Or use a command: remis, resign, taunt, savepgn  \n");
        }
        if (remis_offered) {
            addstr("Opponent offered remis. Type 'remis' to accept.\n");
        } else {
            addch('\n');
        }
        addstr("Prepare your next move: ");
        clrtoeol();
        refresh();

        /* allow the player to prepare a move */
        if (asyncgetnstr(movestr, &bufpos, MOVESTR_BUFLEN)) {
            if (strncmp(movestr, "resign", MOVESTR_BUFLEN) == 0) {
                if (mycolor == WHITE) {
                    gamestate->wresign = true;
                } else {
                    gamestate->bresign = true;
                }
                net_send_code(opponent, NETCODE_RESIGN);
                return 1;
            } else if (strncmp(movestr, "taunt", MOVESTR_BUFLEN) == 0) {
                resign_suggested = true;
                net_send_code(opponent, NETCODE_TAUNT);
            } else if (strncmp(movestr, "remis", MOVESTR_BUFLEN) == 0) {
                net_send_code(opponent, NETCODE_REMIS);
                if (remis_offered) {
                    gamestate->remis = true;
                    return 1;
                } else {
                    remis_suggested = true;
                }
            } else if (strncmp(movestr, "savepgn", MOVESTR_BUFLEN) == 0) {
                save_pgn(gamestate);
            } else if (movestr[0] == 0) {
                memset(gamestate->premove, 0, sizeof(gamestate->premove));
            } else {
                int res = check_move(movestr, mycolor);
                if (res == VALID_MOVE_SYNTAX) {
                    strncpy(gamestate->premove, movestr, 8);
                    memset(movestr, 0, MOVESTR_BUFLEN);
                    bufpos = 0;
                    clrtobot();
                } else {
                    eval_move_failed_msg(res);
                }
            }
        }

        /* read opponent's move */
        uint8_t code = net_recieve_code_async(opponent);
        switch (code) {
        case NETCODE_TIMEOVER:
            /* redraw the time control */
            timecontrol(gamestate);
            return 1;
        case NETCODE_RESIGN:
            if (mycolor == WHITE) {
                gamestate->bresign = true;
            } else {
                gamestate->wresign = true;
            }
            return 1;
        case NETCODE_CONNLOST:
            gamestate->ragequit = true;
            return 1;
        case NETCODE_REMIS:
            if (remis_suggested) {
                gamestate->remis = true;
                return 1;
            } else {
                remis_offered = true;
            }
            break;
        /* validate "the game has ended" claims */
        case NETCODE_CHECKMATE:
            return 1; /* no need to accept, they say they're toast, OK for us */
        case NETCODE_THREEFOLD:
        case NETCODE_NOMATERIAL:
        case NETCODE_STALEMATE:
            if ((code == NETCODE_THREEFOLD && gamestate->threefold) ||
                (code == NETCODE_NOMATERIAL && gamestate->nomaterial) ||
                (code == NETCODE_STALEMATE && gamestate->stalemate)) {
                /* auto-accept the claim */
                net_send_code(opponent, NETCODE_ACCEPT);
                return 1;
            } else {
                /* silently decline, do not add message to UI */
                net_send_code(opponent, NETCODE_DECLINE);
            }
            break;
        case NETCODE_MOVE: {
            NetMove nmove;
            net_recieve_data(opponent, &nmove, NETMOVE_LEN);
            Move move = ntoh_move(nmove);
            code = validate_move(gamestate, &move);
            if (code == VALID_MOVE_SEMANTICS) {
                format_move(gamestate, &move);
                apply_move(gamestate, &move);
                net_send_code(opponent, NETCODE_ACCEPT_MOVE);

                /* send a code for ending the game, if required */
                bool endgame = true;
                if (gamestate->checkmate) {
                    net_send_code(opponent, NETCODE_CHECKMATE);
                    /* checkmate does not need to be accepted */
                    return 1;
                } else if (gamestate->stalemate) {
                    net_send_code(opponent, NETCODE_STALEMATE);
                } else if (gamestate->nomaterial) {
                    net_send_code(opponent, NETCODE_NOMATERIAL);
                } else if (gamestate->threefold) {
                    /* Note: in our implementation it is an auto-draw claimed
                     * by the player confronted with the position. By standard
                     * chess rules, also the player who creates the position may
                     * claim the draw. But since we do it automatically, it
                     * makes no practical difference.
                     */
                    net_send_code(opponent, NETCODE_THREEFOLD);
                } else {
                    endgame = false;
                }
                /* await a response to the "end game" code */
                if (endgame) {
                    uint8_t resp = net_recieve_code(opponent);
                    if (resp == NETCODE_ACCEPT) {
                        return 1;
                    } else {
                        /* does not happen in our implementation */
                        // TODO: but what do we do if some other client declines?
                        //       currently, we simply continue playing,
                        //       but that does not make any sense
                        return 0;
                    }
                }
                /* now it's our turn */
                return 0;
            } else {
                net_send_data(opponent, NETCODE_DECLINE_MOVE, &code, 1);
            }
            break;
        }
        case NETCODE_ERROR:
            addstr("\rCannot perform asynchronous network IO");
            cbreak(); getch();
            exit(EXIT_FAILURE);
        case NETCODE_AGAIN:
            /* try again */
            break;
        default:
            addstr("\nInvalid network request.");
        }
    }
}

static void game_review(GameState *gamestate) {
    const unsigned page_moves = 10;
    GameState viewedstate = {0};
    unsigned viewedmove = gamestate->movecount;
    bool redraw = true;

    noecho();
    int c;
    do {
        if (redraw) {
            gamestate_cleanup(&viewedstate);
            gamestate_at_move(gamestate, viewedmove, &viewedstate);

            erase(); /* don't use clear() to avoid flickering */
            draw_board(&viewedstate, WHITE);
            timecontrol(&viewedstate);

            move(input_getmaxy()-5, 0);
            if (gamestate->wresign) {
                addstr("White resigned.\n");
            } else if (gamestate->bresign) {
                addstr("Black resigned.\n");
            } else if (gamestate->remis) {
                addstr("The game ended remis.\n");
            } else if (gamestate->stalemate) {
                addstr("The game ended in a stalemate.\n");
            } else if (gamestate->threefold) {
                addstr("The game was drawn after threefold repetition.\n");
            } else if (gamestate->nomaterial) {
                addstr("The game is drawn due to insufficient material.\n");
            } else if (gamestate->checkmate) {
                addstr(gamestate->movecount % 2 == 0 ? "White" : "Black");
                addstr(" was checkmated.\n");
            } else if (gamestate->ragequit) {
                addstr("Your opponent disconnected.\n");
            }
            addstr("\nPress 'q' to quit, 's' to save the position as PGN, or\n"
                "arrow keys, home/end, page up/down to review the game.\n");
            flushinp();
            redraw = false;
        }
        c = getch();
        if (c == 's') {
            addch('\r');
            echo();
            save_pgn(&viewedstate);
            noecho();
            redraw = true;
        } else if (c == KEY_UP || c == KEY_LEFT) {
            if (viewedmove > 0) {
                viewedmove--;
                redraw = true;
            }
        } else if (c == KEY_DOWN || c == KEY_RIGHT) {
            if (viewedmove < gamestate->movecount) {
                viewedmove++;
                redraw = true;
            }
        } else if (c == KEY_HOME) {
            viewedmove = 0;
            redraw = true;
        } else if (c == KEY_END) {
            viewedmove = gamestate->movecount;
            redraw = true;
        } else if (c == KEY_PPAGE) {
            if (viewedmove > page_moves) {
                viewedmove -= page_moves;
            } else {
                viewedmove = 0;
            }
            redraw = true;
        } else if (c == KEY_NPAGE) {
            viewedmove += page_moves;
            if (viewedmove > gamestate->movecount) {
                viewedmove = gamestate->movecount;
            }
            redraw = true;
        }
    } while (c != 'q');
    echo();
    gamestate_cleanup(&viewedstate);
}

static void game_play_singlemachine(GameState *gamestate) {
    inputy = input_getmaxy() - 6;

    Color curcol = current_color(gamestate);
    bool running = is_game_running(gamestate);
    while (running) {
        clear();
        Color perspective = settings.disableflip ? WHITE : curcol;
        draw_board(gamestate, perspective);
        running = !domove_singlemachine(gamestate, curcol);
        curcol = opponent_color(curcol);
    }
    game_review(gamestate);
}

static void game_play(GameState *gamestate, int opponent, bool as_client) {
    inputy = input_getmaxy() - 6;

    Color mycolor = gamestate->info.servercolor;
    if (as_client) {
        mycolor = opponent_color(mycolor);
    }

    bool myturn = current_color(gamestate) == mycolor;

    bool running;
    do {
        clear();
        draw_board(gamestate, mycolor);
        if (myturn) {
            running = !sendmove(gamestate, opponent, mycolor);
        } else {
            running = !recvmove(gamestate, opponent, mycolor);
        }
        myturn ^= true;
    }  while (running);
}

static void dump_gameinfo(GameState *gamestate) {
    GameInfo *gameinfo = &gamestate->info;
    int serverwhite = gameinfo->servercolor == WHITE;
    attron(A_UNDERLINE);
    addstr("Game details\n");
    attroff(A_UNDERLINE);
    printw("  Server:     %s\n  Client:     %s\n",
        serverwhite?"White":"Black", serverwhite?"Black":"White"
    );
    if (gameinfo->timecontrol) {
        if (gameinfo->time % 60) {
            printw("  Time limit: %us + %us",
                gameinfo->time, gameinfo->addtime);
        } else {
            printw("  Time limit: %um + %us",
                gameinfo->time/60, gameinfo->addtime);
        }
        if (gameinfo->delay) {
            printw(" (with %us delay)", gameinfo->delay);
        }
        addch('\n');
    } else {
        addstr("  No time limit\n");
    }
    addch('\n');
    for (unsigned i = 0 ; i < gamestate->movecount ; i++) {
        if (i % 2 == 0) {
            printw("%d. %s", 1+i/2, gamestate->moves[i].string);
        } else {
            printw("%s", gamestate->moves[i].string);
        }
        // only five moves reliably fit into one screen rank
        if ((i+1) % 10)  {
            addch(' ');
        } else {
            addch('\n');
        }
    }
    refresh();
}

static int server_fd = -1;
static void interrupt_listen(int sig) {
    (void)sig; /* unused */
    if (server_fd > -1) {
        // this interrupts
        close(server_fd);
    }
}

static int server_open(Server *server) {
    addstr("\nListening for client...\n");
    refresh();
    if (settings.usedomainsocket
            ? net_create_sock(server, settings.serverhost)
            : net_create_tcp(server, settings.port)) {
        addstr("Server creation failed");
        return 1;
    }

    // allow Ctrl+C to interrupt the listening process
    server_fd = server->fd;
    signal(SIGINT, interrupt_listen);

    if (net_listen(server)) {
        addstr("Listening for client failed or interrupted");
        return 1;
    }

    // restore default action
    signal(SIGINT, SIG_DFL);

    return 0;
}

static int server_handshake(Client *client) {
    net_send_code(client->fd, NETCODE_VERSION);
    if (net_recieve_code(client->fd) != NETCODE_VERSION) {
        addstr("Client uses an incompatible software version.");
        return 1;
    }

    addstr("Client connected - transmitting gameinfo...");
    refresh();

    return 0;
}

static int server_run(GameState *gamestate) {
    Server server;

    dump_gameinfo(gamestate);

    if (server_open(&server)) {
        net_destroy(&server);
        return 1;
    }

    if (server_handshake(server.client)) {
        net_destroy(&server);
        return 1;
    }

    int fd = server.client->fd;
    NetGameInfo gi = hton_gi(gamestate->info);
    if (settings.continuepgn) {
        /* Continue game, send PGN data */
        uint16_t mc = gamestate->movecount;
        size_t pgndata_size = NETGI_LEN + 2 + mc * NETMOVE_LEN;
        char *pgndata = malloc(pgndata_size);
        memcpy(pgndata, &gi, NETGI_LEN);
        unsigned offset = NETGI_LEN;
        uint16_t mcn = net_htons(mc);
        memcpy(pgndata+offset, &mcn, 2);
        offset += 2;
        for (unsigned i = 0 ; i < mc ; i++) {
            NetMove nmove = hton_move(gamestate->moves[i]);
            memcpy(pgndata+offset, &nmove, NETMOVE_LEN);
            offset += NETMOVE_LEN;
        }
        net_send_data(fd, NETCODE_PGNDATA, pgndata, pgndata_size);
        free(pgndata);
    } else {
        /* Start new game */
        net_send_data(fd, NETCODE_GAMEINFO, &gi, NETGI_LEN);
    }
    addstr("\rClient connected - awaiting challenge acceptance...");
    refresh();
    int code = net_recieve_code(fd);
    if (code == NETCODE_ACCEPT) {
        addstr("\rClient connected - challenge accepted.");
        clrtoeol();
        game_play(gamestate, fd, false);
        net_destroy(&server);
        game_review(gamestate);
    } else if (code == NETCODE_DECLINE) {
        addstr("\rClient connected - challenge declined.");
        clrtoeol();
        net_destroy(&server);
    } else if (code == NETCODE_CONNLOST) {
        addstr("\rClient connected - but gave no response.");
        clrtoeol();
        net_destroy(&server);
    } else {
        addstr("\rInvalid client response");
        clrtoeol();
        net_destroy(&server);
        return 1;
    }
    return 0;
}


static int client_connect(Server *server) {
    if (settings.usedomainsocket
            ? net_find_sock(server, settings.serverhost)
            : net_find_tcp(server, settings.serverhost, settings.port)) {
        addstr("Can't find server");
        return 1;
    }

    if (net_connect(server)) {
        addstr("Can't connect to server");
        return 1;
    }

    return 0;
}

static int client_handshake(Server *server) {
    uint8_t server_version = net_recieve_code(server->fd);
    net_send_code(server->fd, NETCODE_VERSION);
    if (server_version != NETCODE_VERSION) {
        addstr("Server uses an incompatible software version.");
        return 1;
    }

    addstr("Connection established!\n\n");
    refresh();

    return 0;
}

static int client_run(GameState *gamestate) {
    Server server;

    if (client_connect(&server)) {
        net_destroy(&server);
        return 1;
    }

    if (client_handshake(&server)) {
        net_destroy(&server);
        return 1;
    }

    uint8_t code = net_recieve_code(server.fd);
    bool played = false;
    if (code == NETCODE_GAMEINFO) {
        /* Start new game */
        NetGameInfo gi;
        net_recieve_data(server.fd, &gi, NETGI_LEN);
        gamestate->info = ntoh_gi(gi);
        dump_gameinfo(gamestate);
        if (prompt_yesno("Accept challenge")) {
            net_send_code(server.fd, NETCODE_ACCEPT);
            game_play(gamestate, server.fd, true);
            played = true;
        } else {
            net_send_code(server.fd, NETCODE_DECLINE);
        }
    } else if (code == NETCODE_PGNDATA) {
        NetGameInfo gi;
        net_recieve_data(server.fd, &gi, NETGI_LEN);
        gamestate->info = ntoh_gi(gi);
        uint16_t mc;
        net_recieve_data(server.fd, &mc, 2);
        mc = net_ntohs(mc);
        char *movedata = malloc(mc * NETMOVE_LEN);
        net_recieve_data(server.fd, movedata, mc*NETMOVE_LEN);
        unsigned offset = 0;
        for (size_t i = 0 ; i < mc ; i++) {
            NetMove nmove;
            memcpy(&nmove, movedata+offset, NETMOVE_LEN);
            offset += NETMOVE_LEN;
            Move move = ntoh_move(nmove);
            format_move(gamestate, &move);
            apply_move(gamestate, &move);
        }
        free(movedata);
        dump_gameinfo(gamestate);
        if (prompt_yesno(
                "\n\nServer wants to continue a game. Accept challenge")) {
            net_send_code(server.fd, NETCODE_ACCEPT);
            game_play(gamestate, server.fd, true);
            played = true;
        } else {
            net_send_code(server.fd, NETCODE_DECLINE);
        }
    } else {
        addstr("Server sent invalid gameinfo.");
        net_destroy(&server);
        return 1;
    }

    if (played) {
        game_review(gamestate);
    }

    net_destroy(&server);
    return 0;
}

int main(int argc, char **argv) {
    srand(time(NULL));

    init_settings();
    if (get_settings(argc, argv)) {
        return 1;
    }

    initscr();
    halfdelay(1);
    keypad(stdscr, true);
    if (has_colors()) {
        start_color();
        init_colorpairs();
        bkgd(COLOR_PAIR(COL_APP));
    } else {
        endwin();
        fprintf(stderr, "Non-colored terminals are not supported yet.\n");
        return EXIT_FAILURE;
    }
    atexit(cleanup);

    GameState gamestate;
    gamestate_init(&gamestate);
    settings_apply(&gamestate);

    int exitcode = EXIT_SUCCESS;

    if (settings.continuepgn) {
        FILE *pgnfile = fopen(settings.continuepgn, "r");
        if (pgnfile) {
            pgn_result result = read_pgn(pgnfile, &gamestate);
            fclose(pgnfile);
            if (result.code) {
                printw("Invalid PGN content at position %zu", result.position);
                if (result.move_half_number) {
                    unsigned hm = result.move_half_number - 1;
                    printw(" (move %u, %s)", 1+hm/2, hm%2 ? "black":"white");
                }
                printw(":\n%s", pgn_error_str(result.code));
                if (result.code == pgn_error_move) {
                    addch(' ');
                    eval_move_failed_msg(result.move_error);
                }
                addch('\n');
                exitcode = EXIT_FAILURE;
            }
            /* clear resignation and remis flags to allow game continuation */
            gamestate.wresign = gamestate.bresign = gamestate.remis = false;
        } else {
            printw("Can't read PGN file (%s)\n", strerror(errno));
            exitcode = EXIT_FAILURE;
        }
    }

    if (exitcode == EXIT_SUCCESS) {
        if (settings.singlemachine || !is_game_running(&gamestate)) {
            game_play_singlemachine(&gamestate);
        } else if (settings.ishost) {
            exitcode = server_run(&gamestate);
        } else {
            exitcode = client_run(&gamestate);
        }
    }

    gamestate_cleanup(&gamestate);
    
    mvaddstr(input_getmaxy()-1, 0,
        "Game has ended. Press any key to leave...");
    clrtoeol();
    refresh();
    cbreak();
    flushinp();
    getch();
    
    return exitcode;
}