// Packetized serial transport with HDLC-style framing and sliding window
//
// Frame format (before byte stuffing):
//   [0x7E] [SEQ] [TYPE] [LEN] [PAYLOAD...] [CRC_LO] [CRC_HI]
//
// The leading 0x7E is the frame flag. A trailing 0x7E closes the frame and
// also serves as the flag for the next frame (back-to-back). SEQ is an 8-bit
// sequence number that wraps naturally. TYPE identifies DATA/ACK/NAK/RST.
// LEN is the payload byte count (0-255). CRC covers SEQ through PAYLOAD.
//
// Byte stuffing (transparency):
//   0x7E -> 0x7D 0x5E   (flag byte escaped)
//   0x7D -> 0x7D 0x5D   (escape byte itself escaped)
// XOR with 0x20 is the standard HDLC transparency method.
//
// CRC-16-CCITT (polynomial 0x1021) over SEQ+TYPE+LEN+PAYLOAD.
// Initial value 0xFFFF. Stored little-endian in the frame.

#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <pc.h>
#include "packet.h"
#include "../rs232/rs232.h"


// ========================================================================
// Internal defines
// ========================================================================

#define FLAG_BYTE               0x7E
#define ESC_BYTE                0x7D
#define ESC_XOR                 0x20

// Frame types
#define FRAME_DATA              0x00
#define FRAME_ACK               0x01
#define FRAME_NAK               0x02
#define FRAME_RST               0x03

// Header size: SEQ + TYPE + LEN
#define HEADER_SIZE             3
// CRC size
#define CRC_SIZE                2
// Minimum frame size (header + CRC, no payload)
#define MIN_FRAME_SIZE          (HEADER_SIZE + CRC_SIZE)
// Maximum raw frame size (header + max payload + CRC)
#define MAX_FRAME_SIZE          (HEADER_SIZE + PKT_MAX_PAYLOAD + CRC_SIZE)
// Maximum stuffed frame size (worst case: every byte stuffed + flag)
#define MAX_STUFFED_SIZE        (1 + MAX_FRAME_SIZE * 2)

// Receive buffer must hold at least one max-size stuffed frame
#define RX_BUF_SIZE             (MAX_STUFFED_SIZE + 64)

// Retransmit timeout. 500ms is conservative for a local serial link (RTT
// is < 1ms) but accounts for the remote side being busy. On a real BBS
// connection through the proxy, the round-trip includes TCP latency.
#define RETRANSMIT_TIMEOUT_MS   500

// Receive state machine: three states for HDLC deframing.
// HUNT: discarding bytes until a flag (0x7E) is seen — sync acquisition.
// ACTIVE: accumulating frame bytes, watching for flag (end of frame) or
//         escape (next byte is XOR'd).
// ESCAPE: the previous byte was 0x7D; XOR this byte with 0x20 to recover
//         the original value.
#define RX_STATE_HUNT           0
#define RX_STATE_ACTIVE         1
#define RX_STATE_ESCAPE         2


// ========================================================================
// Types
// ========================================================================

// Transmit window slot: retains a copy of sent data so we can retransmit
// on NAK or timeout without the caller keeping its buffer alive. The timer
// tracks when this slot was last (re)transmitted for timeout detection.
typedef struct {
    uint8_t  data[PKT_MAX_PAYLOAD];
    int      len;
    uint8_t  seq;
    clock_t  timer;
} TxSlotT;

// Connection state. txSlots is a circular window indexed by [0..txCount-1],
// where slot 0 is the oldest unacked frame (sequence txAckSeq) and
// slot txCount-1 is the newest. When an ACK advances txAckSeq, we shift
// slots down (implicitly, by incrementing txAckSeq and decrementing txCount).
struct PktConnS {
    int              com;
    int              windowSize;
    PktRecvCallbackT callback;
    void            *callbackCtx;

    // Transmit state (Go-Back-N sender)
    uint8_t          txNextSeq;    // next sequence number to assign
    uint8_t          txAckSeq;     // oldest unacknowledged sequence
    TxSlotT          txSlots[PKT_MAX_WINDOW];
    int              txCount;      // number of slots in use

    // Receive state (Go-Back-N receiver: only accepts in-order frames)
    uint8_t          rxExpectSeq;  // next expected sequence number
    uint8_t          rxState;      // RX_STATE_*
    uint8_t          rxFrame[MAX_FRAME_SIZE];
    int              rxFrameLen;

};


// ========================================================================
// CRC-16-CCITT lookup table
// ========================================================================

static const uint16_t sCrcTable[256] = {
    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
    0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
    0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
    0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
    0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x54A5,
    0xA54A, 0xB56B, 0x8508, 0x9529, 0xE5CE, 0xF5EF, 0xC58C, 0xD5AD,
    0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
    0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
    0x4864, 0x5845, 0x6826, 0x7807, 0x08E0, 0x18C1, 0x28A2, 0x38A3,
    0xC94C, 0xD96D, 0xE90E, 0xF92F, 0x89C8, 0x99E9, 0xA98A, 0xB9AB,
    0x5A55, 0x4A74, 0x7A17, 0x6A36, 0x1AD1, 0x0AF0, 0x3A93, 0x2AB2,
    0xDB5D, 0xCB7C, 0xFB1F, 0xEB3E, 0x9BD9, 0x8BF8, 0xBB9B, 0xAB9A,
    0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
    0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
    0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
    0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
    0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
    0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
    0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
    0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
    0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
    0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
    0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
    0x26D3, 0x36F2, 0x06B1, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
    0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
    0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
    0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
    0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
    0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
    0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
    0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
    0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
};


// ========================================================================
// Static prototypes (alphabetical)
// ========================================================================

static uint16_t crcCalc(const uint8_t *data, int len);
static void     processFrame(PktConnT *conn, const uint8_t *frame, int len);
static void     retransmitCheck(PktConnT *conn);
static void     rxProcessByte(PktConnT *conn, uint8_t byte);
static void     sendAck(PktConnT *conn, uint8_t seq);
static void     sendFrame(PktConnT *conn, uint8_t seq, uint8_t type, const uint8_t *payload, int len);
static void     sendNak(PktConnT *conn, uint8_t seq);
static void     sendRst(PktConnT *conn);
static int      seqInWindow(uint8_t seq, uint8_t base, int size);
static int      txSlotIndex(PktConnT *conn, uint8_t seq);


// ========================================================================
// CRC computation
// ========================================================================

// Table-driven CRC-16-CCITT. Processing one byte per iteration with a
// 256-entry table is ~10x faster than bit-by-bit on a 486. The table
// costs 512 bytes of .rodata — a worthwhile trade for a function called
// on every frame received and transmitted.
static uint16_t crcCalc(const uint8_t *data, int len) {
    uint16_t crc = 0xFFFF;

    for (int i = 0; i < len; i++) {
        crc = (crc << 8) ^ sCrcTable[(crc >> 8) ^ data[i]];
    }

    return crc;
}


// ========================================================================
// Frame transmission
// ========================================================================

// Build a raw frame, compute CRC, byte-stuff it, and transmit.
// The stuffed buffer can be up to 2x the raw size (every byte might need
// escaping) plus the flags. This is stack-allocated because frames are small
// and we're not in a deeply recursive call path.
static void sendFrame(PktConnT *conn, uint8_t seq, uint8_t type, const uint8_t *payload, int len) {
    uint8_t  raw[MAX_FRAME_SIZE];
    uint8_t  stuffed[MAX_STUFFED_SIZE];
    int      rawLen;
    uint16_t crc;
    int      out;

    // Build raw frame: SEQ + TYPE + LEN + PAYLOAD
    raw[0] = seq;
    raw[1] = type;
    raw[2] = (uint8_t)len;
    if (payload && len > 0) {
        memcpy(&raw[3], payload, len);
    }
    rawLen = HEADER_SIZE + len;

    // Append CRC
    crc = crcCalc(raw, rawLen);
    raw[rawLen]     = (uint8_t)(crc & 0xFF);
    raw[rawLen + 1] = (uint8_t)((crc >> 8) & 0xFF);
    rawLen += CRC_SIZE;

    // Byte-stuff into output buffer with leading flag
    out = 0;
    stuffed[out++] = FLAG_BYTE;
    for (int i = 0; i < rawLen; i++) {
        if (raw[i] == FLAG_BYTE) {
            stuffed[out++] = ESC_BYTE;
            stuffed[out++] = FLAG_BYTE ^ ESC_XOR;
        } else if (raw[i] == ESC_BYTE) {
            stuffed[out++] = ESC_BYTE;
            stuffed[out++] = ESC_BYTE ^ ESC_XOR;
        } else {
            stuffed[out++] = raw[i];
        }
    }

    // Trailing flag to close the frame immediately
    stuffed[out++] = FLAG_BYTE;

    // Send via serial port (blocking write)
    rs232Write(conn->com, (const char *)stuffed, out);
}


static void sendAck(PktConnT *conn, uint8_t seq) {
    sendFrame(conn, seq, FRAME_ACK, 0, 0);
}


static void sendNak(PktConnT *conn, uint8_t seq) {
    sendFrame(conn, seq, FRAME_NAK, 0, 0);
}


static void sendRst(PktConnT *conn) {
    sendFrame(conn, 0, FRAME_RST, 0, 0);
}


// ========================================================================
// Sequence number helpers
// ========================================================================

// Check if a sequence number falls within a window starting at base.
// Works correctly with 8-bit wrap-around because unsigned subtraction
// wraps mod 256 — if seq is "ahead" of base by less than size, diff
// will be a small positive number.
static int seqInWindow(uint8_t seq, uint8_t base, int size) {
    uint8_t diff = seq - base;
    return diff < (uint8_t)size;
}


static int txSlotIndex(PktConnT *conn, uint8_t seq) {
    uint8_t diff = seq - conn->txAckSeq;
    if (diff >= (uint8_t)conn->txCount) {
        return -1;
    }
    return diff;
}


// ========================================================================
// Frame processing
// ========================================================================

// Handle a complete, de-stuffed frame. CRC is verified first; on failure,
// we NAK to request retransmission of the frame we actually expected.
//
// For DATA frames: Go-Back-N receiver logic — only accept if seq matches
// rxExpectSeq (strictly in-order). Out-of-order frames within the window
// trigger a NAK; duplicates and out-of-window frames are silently dropped.
//
// For ACK frames: cumulative acknowledgement. The ACK carries the next
// expected sequence number, so we free all slots up to that point.
//
// For NAK frames: the receiver wants us to retransmit from a specific
// sequence. Go-Back-N retransmits that frame AND all subsequent ones.
static void processFrame(PktConnT *conn, const uint8_t *frame, int len) {
    uint8_t  seq;
    uint8_t  type;
    int      payloadLen;
    uint16_t rxCrc;
    uint16_t calcCrc;

    if (len < MIN_FRAME_SIZE) {
        return;
    }

    // Verify CRC
    calcCrc = crcCalc(frame, len - CRC_SIZE);
    rxCrc   = frame[len - 2] | ((uint16_t)frame[len - 1] << 8);
    if (calcCrc != rxCrc) {
        // CRC mismatch — request retransmit of what we expect
        sendNak(conn, conn->rxExpectSeq);
        return;
    }

    seq        = frame[0];
    type       = frame[1];
    payloadLen = frame[2];

    // Validate payload length against actual frame size
    if (payloadLen + MIN_FRAME_SIZE != len) {
        return;
    }

    switch (type) {
        case FRAME_DATA:
            if (seq == conn->rxExpectSeq) {
                // In-order delivery
                if (conn->callback) {
                    conn->callback(conn->callbackCtx, &frame[HEADER_SIZE], payloadLen);
                }
                conn->rxExpectSeq++;
                sendAck(conn, conn->rxExpectSeq);
            } else if (seqInWindow(seq, conn->rxExpectSeq, conn->windowSize)) {
                // Out of order but in window — NAK the one we want
                sendNak(conn, conn->rxExpectSeq);
            }
            // else: duplicate or out of window, silently discard
            break;

        case FRAME_ACK: {
            // ACK carries the next expected sequence number (cumulative)
            // Advance txAckSeq and free all slots up to seq
            while (conn->txCount > 0 && conn->txAckSeq != seq) {
                conn->txAckSeq++;
                conn->txCount--;
            }
            break;
        }

        case FRAME_NAK: {
            // Retransmit from the requested sequence
            int idx = txSlotIndex(conn, seq);
            if (idx >= 0) {
                // Retransmit this slot and all after it (go-back-N)
                for (int i = idx; i < conn->txCount; i++) {
                    TxSlotT *slot = &conn->txSlots[i];
                    sendFrame(conn, slot->seq, FRAME_DATA, slot->data, slot->len);
                    slot->timer = clock();
                }
            }
            break;
        }

        case FRAME_RST:
            // Remote requested reset — clear state and respond with RST
            conn->txNextSeq   = 0;
            conn->txAckSeq    = 0;
            conn->txCount     = 0;
            conn->rxExpectSeq = 0;
            sendRst(conn);
            break;
    }
}


// ========================================================================
// Receive byte processing (state machine)
// ========================================================================

// Feed one byte from the serial port into the HDLC deframing state machine.
// The flag byte (0x7E) serves double duty: it ends the current frame AND
// starts the next one. This means back-to-back frames share a single flag
// byte, saving bandwidth. A frame is only processed if it meets the minimum
// size requirement (header + CRC), so spurious flags between frames are
// harmless (they just produce zero-length "frames" that are discarded).
static void rxProcessByte(PktConnT *conn, uint8_t byte) {
    switch (conn->rxState) {
        case RX_STATE_HUNT:
            if (byte == FLAG_BYTE) {
                conn->rxState    = RX_STATE_ACTIVE;
                conn->rxFrameLen = 0;
            }
            break;

        case RX_STATE_ACTIVE:
            if (byte == FLAG_BYTE) {
                // End of frame (or start of next)
                if (conn->rxFrameLen >= MIN_FRAME_SIZE) {
                    processFrame(conn, conn->rxFrame, conn->rxFrameLen);
                }
                // Reset for next frame
                conn->rxFrameLen = 0;
            } else if (byte == ESC_BYTE) {
                conn->rxState = RX_STATE_ESCAPE;
            } else {
                if (conn->rxFrameLen < MAX_FRAME_SIZE) {
                    conn->rxFrame[conn->rxFrameLen++] = byte;
                } else {
                    // Frame too large, discard and hunt for next flag
                    conn->rxState = RX_STATE_HUNT;
                }
            }
            break;

        case RX_STATE_ESCAPE:
            conn->rxState = RX_STATE_ACTIVE;
            byte ^= ESC_XOR;
            if (conn->rxFrameLen < MAX_FRAME_SIZE) {
                conn->rxFrame[conn->rxFrameLen++] = byte;
            } else {
                conn->rxState = RX_STATE_HUNT;
            }
            break;
    }
}


// ========================================================================
// Retransmit check
// ========================================================================

// Timer-based retransmission for slots that haven't been ACK'd within the
// timeout. This handles the case where an ACK or NAK was lost — without
// this, the connection would stall forever. Each slot is retransmitted
// independently and its timer is reset, creating exponential backoff
// behavior naturally (each retransmit resets the timer).
static void retransmitCheck(PktConnT *conn) {
    clock_t now     = clock();
    clock_t timeout = (clock_t)RETRANSMIT_TIMEOUT_MS * CLOCKS_PER_SEC / 1000;

    for (int i = 0; i < conn->txCount; i++) {
        TxSlotT *slot = &conn->txSlots[i];
        if (now - slot->timer >= timeout) {
            sendFrame(conn, slot->seq, FRAME_DATA, slot->data, slot->len);
            slot->timer = now;
        }
    }
}


// ========================================================================
// Public functions (alphabetical)
// ========================================================================

void pktClose(PktConnT *conn) {
    if (conn) {
        free(conn);
    }
}


bool pktCanSend(PktConnT *conn) {
    if (!conn) {
        return false;
    }
    return conn->txCount < conn->windowSize;
}


int pktGetPending(PktConnT *conn) {
    if (!conn) {
        return PKT_ERR_INVALID_PARAM;
    }
    return conn->txCount;
}


PktConnT *pktOpen(int com, int windowSize, PktRecvCallbackT callback, void *callbackCtx) {
    PktConnT *conn;

    if (windowSize <= 0) {
        windowSize = PKT_DEFAULT_WINDOW;
    }
    if (windowSize > PKT_MAX_WINDOW) {
        windowSize = PKT_MAX_WINDOW;
    }

    conn = (PktConnT *)calloc(1, sizeof(PktConnT));
    if (!conn) {
        return 0;
    }

    conn->com         = com;
    conn->windowSize  = windowSize;
    conn->callback    = callback;
    conn->callbackCtx = callbackCtx;
    conn->txNextSeq   = 0;
    conn->txAckSeq    = 0;
    conn->txCount     = 0;
    conn->rxExpectSeq = 0;
    conn->rxState     = RX_STATE_HUNT;
    conn->rxFrameLen  = 0;

    return conn;
}


// Main polling function — must be called frequently (each iteration of the
// app's main loop or event loop). It drains the serial port's RX buffer,
// feeds bytes through the deframing state machine, and checks for
// retransmit timeouts. The callback is invoked synchronously for each
// complete, verified, in-order data frame, so the caller should be prepared
// for re-entrant calls to pktSend from within the callback.
int pktPoll(PktConnT *conn) {
    char    buf[128];
    int     nRead;
    int     delivered = 0;

    if (!conn) {
        return PKT_ERR_INVALID_PARAM;
    }

    // Read available serial data and feed to state machine
    while ((nRead = rs232Read(conn->com, buf, sizeof(buf))) > 0) {
        for (int i = 0; i < nRead; i++) {
            uint8_t prevExpect = conn->rxExpectSeq;
            rxProcessByte(conn, (uint8_t)buf[i]);
            if (conn->rxExpectSeq != prevExpect) {
                delivered++;
            }
        }
    }

    // Detect disconnected socket/port
    if (nRead < 0) {
        return PKT_ERR_DISCONNECTED;
    }

    // Check for retransmit timeouts
    retransmitCheck(conn);

    return delivered;
}


int pktReset(PktConnT *conn) {
    if (!conn) {
        return PKT_ERR_INVALID_PARAM;
    }

    conn->txNextSeq   = 0;
    conn->txAckSeq    = 0;
    conn->txCount     = 0;
    conn->rxExpectSeq = 0;
    conn->rxState     = RX_STATE_HUNT;
    conn->rxFrameLen  = 0;

    sendRst(conn);

    return PKT_SUCCESS;
}


// Send a data packet. If block=true and the window is full, polls in a
// tight loop until space opens up (an ACK arrives). The data is copied
// into a retransmit slot before sending so the caller can reuse its buffer
// immediately. The window slot tracks the sequence number and timestamp
// for retransmission.
int pktSend(PktConnT *conn, const uint8_t *data, int len, bool block) {
    TxSlotT *slot;

    if (!conn) {
        return PKT_ERR_INVALID_PARAM;
    }
    if (!data || len <= 0 || len > PKT_MAX_PAYLOAD) {
        return PKT_ERR_INVALID_PARAM;
    }

    // Wait for window space if blocking
    if (block) {
        while (conn->txCount >= conn->windowSize) {
            if (pktPoll(conn) == PKT_ERR_DISCONNECTED) {
                return PKT_ERR_DISCONNECTED;
            }
        }
    } else {
        if (conn->txCount >= conn->windowSize) {
            return PKT_ERR_TX_FULL;
        }
    }

    // Store in retransmit buffer
    slot = &conn->txSlots[conn->txCount];
    memcpy(slot->data, data, len);
    slot->len   = len;
    slot->seq   = conn->txNextSeq;
    slot->timer = clock();
    conn->txCount++;
    conn->txNextSeq++;

    // Transmit
    sendFrame(conn, slot->seq, FRAME_DATA, slot->data, slot->len);

    return PKT_SUCCESS;
}