/* Require bison minimal version */
%require "3.2"

/* write out a header file containing the token defines */
%header

// Code for the header file generated by bison
%code requires {
    #include <stdbool.h>

    typedef void* yyscan_t;

    struct parser_state {
        // for storing the most recently read 4 chars
        char buffer[4];
        // location tracker
        unsigned long loc;
        bool found_start;

        bool check_matrix[26];
    };
}

// Code for the c file
%{
    #include <stdio.h>
    #include <stdlib.h>
    #include <stdbool.h>
    #include "parser.h"
    #include "lexer.h"

    void yyerror(struct parser_state* state, yyscan_t scanner, const char* msg) {
        (void)state;
        (void)scanner;
        fprintf(stderr, "\033[93mSyntax Error: %s\033[0m\n", msg);
    }
%}

// define a reentrant parser
%define api.pure

// enable parser tracing and detailed error messages (plus Lookahead Correction)
%define parse.trace
%define parse.error detailed
%define parse.lac full

%lex-param   { yyscan_t scanner }
%parse-param { struct parser_state* state }
%parse-param { yyscan_t scanner }

%union {
    char cval;
}


%start input
%token NEWLINE
%token <cval> CHAR
%term END_OF_FILE

%%

input
    : msg blanks END_OF_FILE   { return 0; }
    ;

blanks
    : NEWLINE blanks
    | NEWLINE
    ;

msg
    : bit msg
    | bit
    ;

bit
    : CHAR              {
                            if (!state->found_start) {
                                state->loc++;

                                // left shift existing data
                                for (int i = 0; i < 3; i++) {
                                    state->buffer[i] = state->buffer[i+1];
                                }

                                state->buffer[3] = $1;

                                // check whether condition is met
                                // offset array indices by the base -- 'a'
                                char offset = 'a';

                                state->found_start = true;
                                for (int i = 0; i < 4; i++) {
                                    if (!state->check_matrix[state->buffer[i] - offset]) {
                                        state->check_matrix[state->buffer[i] - offset] = true;
                                    } else {
                                        state->found_start = false;
                                        break;
                                    }
                                }

                                // housekeeping; reset the fields to false
                                for (int i = 0; i < 4; i++) {
                                    state->check_matrix[state->buffer[i] - offset] = false;
                                }
                            }
                        }
    ;


%%

int main(void) {
    struct parser_state parser_state;
    for (int i = 0; i < 4; i++) {
        parser_state.buffer[i] = 'a';
    }
    parser_state.loc = 0;
    parser_state.found_start = false;

    yyscan_t scanner;
    if (yylex_init(&scanner)) {
        fprintf(stderr, "\033[91m[error] Could not initialize lexer\033[0m\n");
        return EXIT_FAILURE;
    }

    if (yyparse(&parser_state, scanner)) {
		// TODO: Error handling https://www.gnu.org/software/bison/manual/html_node/Parser-Function.html
		// error during parse occured
		return EXIT_FAILURE;
	}

    yylex_destroy(scanner);

    printf("First start-of-packet marker detected at: %lu\n", parser_state.loc);

    return 0;
}