

#include "internal/quic_fifd.h"
#include "internal/quic_wire.h"
#include "internal/qlog_event_helpers.h"

DEFINE_LIST_OF(tx_history, OSSL_ACKM_TX_PKT);

int ossl_quic_fifd_init(QUIC_FIFD *fifd,
                        QUIC_CFQ *cfq,
                        OSSL_ACKM *ackm,
                        QUIC_TXPIM *txpim,
                        
                        QUIC_SSTREAM *(*get_sstream_by_id)(uint64_t stream_id,
                                                           uint32_t pn_space,
                                                           void *arg),
                        void *get_sstream_by_id_arg,
                        
                        void (*regen_frame)(uint64_t frame_type,
                                            uint64_t stream_id,
                                            QUIC_TXPIM_PKT *pkt,
                                            void *arg),
                        void *regen_frame_arg,
                        void (*confirm_frame)(uint64_t frame_type,
                                              uint64_t stream_id,
                                              QUIC_TXPIM_PKT *pkt,
                                              void *arg),
                        void *confirm_frame_arg,
                        void (*sstream_updated)(uint64_t stream_id,
                                                void *arg),
                        void *sstream_updated_arg,
                        QLOG *(*get_qlog_cb)(void *arg),
                        void *get_qlog_cb_arg)
{
    if (cfq == NULL || ackm == NULL || txpim == NULL
        || get_sstream_by_id == NULL || regen_frame == NULL)
        return 0;

    fifd->cfq                   = cfq;
    fifd->ackm                  = ackm;
    fifd->txpim                 = txpim;
    fifd->get_sstream_by_id     = get_sstream_by_id;
    fifd->get_sstream_by_id_arg = get_sstream_by_id_arg;
    fifd->regen_frame           = regen_frame;
    fifd->regen_frame_arg       = regen_frame_arg;
    fifd->confirm_frame         = confirm_frame;
    fifd->confirm_frame_arg     = confirm_frame_arg;
    fifd->sstream_updated       = sstream_updated;
    fifd->sstream_updated_arg   = sstream_updated_arg;
    fifd->get_qlog_cb           = get_qlog_cb;
    fifd->get_qlog_cb_arg       = get_qlog_cb_arg;
    return 1;
}

void ossl_quic_fifd_cleanup(QUIC_FIFD *fifd)
{
    
}

static void on_acked(void *arg)
{
    QUIC_TXPIM_PKT *pkt = arg;
    QUIC_FIFD *fifd = pkt->fifd;
    const QUIC_TXPIM_CHUNK *chunks = ossl_quic_txpim_pkt_get_chunks(pkt);
    size_t i, num_chunks = ossl_quic_txpim_pkt_get_num_chunks(pkt);
    QUIC_SSTREAM *sstream;
    QUIC_CFQ_ITEM *cfq_item, *cfq_item_next;

    
    for (i = 0; i < num_chunks; ++i) {
        sstream = fifd->get_sstream_by_id(chunks[i].stream_id,
                                          pkt->ackm_pkt.pkt_space,
                                          fifd->get_sstream_by_id_arg);
        if (sstream == NULL)
            continue;

        if (chunks[i].end >= chunks[i].start)
            
            ossl_quic_sstream_mark_acked(sstream,
                                         chunks[i].start, chunks[i].end);

        if (chunks[i].has_fin && chunks[i].stream_id != UINT64_MAX)
            ossl_quic_sstream_mark_acked_fin(sstream);

        if (chunks[i].has_stop_sending && chunks[i].stream_id != UINT64_MAX)
            fifd->confirm_frame(OSSL_QUIC_FRAME_TYPE_STOP_SENDING,
                                chunks[i].stream_id, pkt,
                                fifd->confirm_frame_arg);

        if (chunks[i].has_reset_stream && chunks[i].stream_id != UINT64_MAX)
            fifd->confirm_frame(OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
                                chunks[i].stream_id, pkt,
                                fifd->confirm_frame_arg);

        if (ossl_quic_sstream_is_totally_acked(sstream))
            fifd->sstream_updated(chunks[i].stream_id, fifd->sstream_updated_arg);
    }

    
    for (cfq_item = pkt->retx_head; cfq_item != NULL; cfq_item = cfq_item_next) {
        cfq_item_next = cfq_item->pkt_next;
        ossl_quic_cfq_release(fifd->cfq, cfq_item);
    }

    ossl_quic_txpim_pkt_release(fifd->txpim, pkt);
}

static QLOG *fifd_get_qlog(QUIC_FIFD *fifd)
{
    if (fifd->get_qlog_cb == NULL)
        return NULL;

    return fifd->get_qlog_cb(fifd->get_qlog_cb_arg);
}

static void on_lost(void *arg)
{
    QUIC_TXPIM_PKT *pkt = arg;
    QUIC_FIFD *fifd = pkt->fifd;
    const QUIC_TXPIM_CHUNK *chunks = ossl_quic_txpim_pkt_get_chunks(pkt);
    size_t i, num_chunks = ossl_quic_txpim_pkt_get_num_chunks(pkt);
    QUIC_SSTREAM *sstream;
    QUIC_CFQ_ITEM *cfq_item, *cfq_item_next;
    int sstream_updated;

    ossl_qlog_event_recovery_packet_lost(fifd_get_qlog(fifd), pkt);

    
    for (i = 0; i < num_chunks; ++i) {
        sstream = fifd->get_sstream_by_id(chunks[i].stream_id,
                                          pkt->ackm_pkt.pkt_space,
                                          fifd->get_sstream_by_id_arg);
        if (sstream == NULL)
            continue;

        sstream_updated = 0;

        if (chunks[i].end >= chunks[i].start) {
            
            ossl_quic_sstream_mark_lost(sstream,
                                        chunks[i].start, chunks[i].end);
            sstream_updated = 1;
        }

        if (chunks[i].has_fin && chunks[i].stream_id != UINT64_MAX) {
            ossl_quic_sstream_mark_lost_fin(sstream);
            sstream_updated = 1;
        }

        if (chunks[i].has_stop_sending && chunks[i].stream_id != UINT64_MAX)
            fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_STOP_SENDING,
                              chunks[i].stream_id, pkt,
                              fifd->regen_frame_arg);

        if (chunks[i].has_reset_stream && chunks[i].stream_id != UINT64_MAX)
            fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
                              chunks[i].stream_id, pkt,
                              fifd->regen_frame_arg);

        
        fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA,
                          chunks[i].stream_id,
                          pkt,
                          fifd->regen_frame_arg);

        if (sstream_updated && chunks[i].stream_id != UINT64_MAX)
            fifd->sstream_updated(chunks[i].stream_id,
                                  fifd->sstream_updated_arg);
    }

    
    for (cfq_item = pkt->retx_head; cfq_item != NULL; cfq_item = cfq_item_next) {
        cfq_item_next = cfq_item->pkt_next;
        ossl_quic_cfq_mark_lost(fifd->cfq, cfq_item, UINT32_MAX);
    }

    
    if (pkt->had_handshake_done_frame)
        fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE,
                          UINT64_MAX, pkt,
                          fifd->regen_frame_arg);

    if (pkt->had_max_data_frame)
        fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_DATA,
                          UINT64_MAX, pkt,
                          fifd->regen_frame_arg);

    if (pkt->had_max_streams_bidi_frame)
        fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI,
                          UINT64_MAX, pkt,
                          fifd->regen_frame_arg);

    if (pkt->had_max_streams_uni_frame)
        fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI,
                          UINT64_MAX, pkt,
                          fifd->regen_frame_arg);

    if (pkt->had_ack_frame)
        
        fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN,
                          UINT64_MAX, pkt,
                          fifd->regen_frame_arg);

    ossl_quic_txpim_pkt_release(fifd->txpim, pkt);
}

static void on_discarded(void *arg)
{
    QUIC_TXPIM_PKT *pkt = arg;
    QUIC_FIFD *fifd = pkt->fifd;
    QUIC_CFQ_ITEM *cfq_item, *cfq_item_next;

    

    
    for (cfq_item = pkt->retx_head; cfq_item != NULL; cfq_item = cfq_item_next) {
        cfq_item_next = cfq_item->pkt_next;
        ossl_quic_cfq_release(fifd->cfq, cfq_item);
    }

    ossl_quic_txpim_pkt_release(fifd->txpim, pkt);
}

int ossl_quic_fifd_pkt_commit(QUIC_FIFD *fifd, QUIC_TXPIM_PKT *pkt)
{
    QUIC_CFQ_ITEM *cfq_item;
    const QUIC_TXPIM_CHUNK *chunks;
    size_t i, num_chunks;
    QUIC_SSTREAM *sstream;

    pkt->fifd                   = fifd;

    pkt->ackm_pkt.on_lost       = on_lost;
    pkt->ackm_pkt.on_acked      = on_acked;
    pkt->ackm_pkt.on_discarded  = on_discarded;
    pkt->ackm_pkt.cb_arg        = pkt;

    ossl_list_tx_history_init_elem(&pkt->ackm_pkt);
    pkt->ackm_pkt.anext = pkt->ackm_pkt.lnext = NULL;

    
    for (cfq_item = pkt->retx_head;
         cfq_item != NULL;
         cfq_item = cfq_item->pkt_next)
        ossl_quic_cfq_mark_tx(fifd->cfq, cfq_item);

    
    chunks = ossl_quic_txpim_pkt_get_chunks(pkt);
    num_chunks = ossl_quic_txpim_pkt_get_num_chunks(pkt);
    for (i = 0; i < num_chunks; ++i) {
        sstream = fifd->get_sstream_by_id(chunks[i].stream_id,
                                          pkt->ackm_pkt.pkt_space,
                                          fifd->get_sstream_by_id_arg);
        if (sstream == NULL)
            continue;

        if (chunks[i].end >= chunks[i].start
            && !ossl_quic_sstream_mark_transmitted(sstream,
                                                   chunks[i].start,
                                                   chunks[i].end))
            return 0;

        if (chunks[i].has_fin
            && !ossl_quic_sstream_mark_transmitted_fin(sstream,
                                                       chunks[i].end + 1))
                return 0;
    }

    
    return ossl_ackm_on_tx_packet(fifd->ackm, &pkt->ackm_pkt);
}

void ossl_quic_fifd_set_qlog_cb(QUIC_FIFD *fifd, QLOG *(*get_qlog_cb)(void *arg),
                                void *get_qlog_cb_arg)
{
    fifd->get_qlog_cb       = get_qlog_cb;
    fifd->get_qlog_cb_arg   = get_qlog_cb_arg;
}
