// Una regla or_rule → atom ("or" atom)* que olvida liberar cuando falla la derecha.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "lexer.h"

typedef struct node {
    struct node *left;
    struct node *right;
} Node;

typedef struct {
    Lexer *lexer;
    Token current;
} Parser;

static void advance(Parser *p) {
    p->current = lexer_next(p->lexer);
}

static void node_free(Node *node) {
    if (node != NULL) {
        node_free(node->left);
        node_free(node->right);
        free(node);
    }
}

static Node *node_new(Node *left, Node *right) {
    Node *node = malloc(sizeof *node);
    if (node == NULL) {
        node_free(left);
        node_free(right);
        return NULL;
    }
    node->left = left;
    node->right = right;
    return node;
}

static Node *parse_atom(Parser *p) {
    if (p->current.kind != TOKEN_NAME) {
        return NULL;
    }
    advance(p);
    return node_new(NULL, NULL);
}

static Node *parse_or(Parser *p) {
    Node *left = parse_atom(p);
    while (left != NULL && p->current.kind == TOKEN_NAME && strcmp(p->current.text, "or") == 0) {
        advance(p);
        Node *right = parse_atom(p);
        if (right == NULL) {
            return NULL;                // ¿y left?
        }
        left = node_new(left, right);
    }
    return left;
}

int main(void) {
    Parser parser = {.lexer = lexer_new("true or")};
    if (parser.lexer == NULL) {
        return 1;
    }
    advance(&parser);
    Node *tree = parse_or(&parser);
    printf("%s\n", tree == NULL ? "error de sintaxis" : "bien");
    node_free(tree);
    lexer_free(parser.lexer);
    return 0;
}