#ifndef __SCC_PARSER_UTILS_H__
#define __SCC_PARSER_UTILS_H__

#include "scc_parser.h"

static inline const scc_lexer_tok_t *scc_parser_peek(scc_parser_t *parser) {
    cbool ok = false;
    const scc_lexer_tok_t *tok = null;
    scc_ring_unsafe_peek_ref(*parser->ring, tok, ok);
    if (ok == false) {
        return null;
    }
    return tok;
}

static inline const scc_lexer_tok_t *scc_parser_next(scc_parser_t *parser) {
    cbool ok = false;
    const scc_lexer_tok_t *tok = null;
    scc_ring_unsafe_next_ref(*parser->ring, tok, ok);
    if (ok == false) {
        return null;
    }
    return tok;
}

static inline cbool scc_parser_consume_if(scc_parser_t *parser,
                                          scc_tok_type_t type) {
    cbool ok = false;
    scc_lexer_tok_t *tok = null;
    scc_ring_unsafe_peek_ref(*parser->ring, tok, ok);
    if (ok == false) {
        return null;
    }
    if (tok->type == type) {
        scc_lexer_tok_drop(tok);
        scc_ring_unsafe_pure_next_consume(*parser->ring);
        return true;
    } else {
        return false;
    }
}

static inline void scc_parser_store(scc_parser_t *parser) {
    parser->checkpoint = _scc_ring_probe(*parser->ring);
}

static inline void scc_parser_restore(scc_parser_t *parser) {
    _scc_ring_probe(*parser->ring) = parser->checkpoint;
}

// tok can null it will be safty free
static inline cbool scc_parser_next_consume(scc_parser_t *parser,
                                            scc_lexer_tok_t *tok) {
    cbool ok = false;
    scc_lexer_tok_t *raw_tok_ref = null;
    scc_ring_unsafe_next_ref_consume(*parser->ring, raw_tok_ref, ok);
    if (tok == null) {
        scc_lexer_tok_drop(raw_tok_ref);
    } else {
        scc_lexer_tok_move(tok, raw_tok_ref);
    }
    return ok;
}

static inline void scc_parser_commit(scc_parser_t *parser) {
    // Memory leak
    scc_ring_consume(*parser->ring);
}

static inline void scc_parser_reset(scc_parser_t *parser) {
    scc_ring_reset(*parser->ring);
}

#include <scc_pos_log.h>
static inline scc_pos_t scc_parser_got_current_pos(scc_parser_t *parser) {
    const scc_lexer_tok_t *tok = scc_parser_peek(parser);
    scc_pos_t pos = scc_pos_create();
    if (tok != null)
        pos = tok->loc;
    return pos;
}

#endif /* __SCC_PARSER_UTILS_H__ */