/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   parse_types.h                                      :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2024/04/24 23:01:45 by maiboyer          #+#    #+#             */
/*   Updated: 2024/04/29 15:26:51 by maiboyer         ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#ifndef PARSETYPES_H
#define PARSETYPES_H

#include <stdbool.h>
#include <stdint.h>

#define ts_builtin_sym_end 0
#define ts_builtin_sym_error -1

#include "me/types.h"
#include "parser/types/types_field_id.h"
#include "parser/types/types_field_map_entry.h"
#include "parser/types/types_field_map_slice.h"
#include "parser/types/types_language.h"
#include "parser/types/types_lex_modes.h"
#include "parser/types/types_lexer.h"
#include "parser/types/types_lexer_state.h"
#include "parser/types/types_parse_action_entry.h"
#include "parser/types/types_parse_action_type.h"
#include "parser/types/types_parse_actions.h"
#include "parser/types/types_parser_range.h"
#include "parser/types/types_point.h"
#include "parser/types/types_scanner.h"
#include "parser/types/types_state_id.h"
#include "parser/types/types_symbol.h"
#include "parser/types/types_symbol_metadata.h"
#include "parser/types/types_char_range.h"

static inline bool lex_skip(t_state_id state_value, t_lexer *lexer,
							t_lexer_state *s)
{
	(void)(lexer);
	s->skip = true;
	s->state = state_value;
	return (true);
};

static inline bool lex_advance(t_state_id state_value, t_lexer *lexer,
							   t_lexer_state *s)
{
	(void)(lexer);
	s->state = state_value;
	return (true);
};

static inline bool lex_accept_token(t_symbol symbol_value, t_lexer *lexer,
									t_lexer_state *s)
{
	s->result = true;
	lexer->result_symbol = symbol_value;
	lexer->mark_end(lexer);
	return (true);
};

static inline bool lex_end_state(t_lexer *lexer, t_lexer_state *s)
{
	(void)(lexer);
	(void)(s);
	return (false);
};

static inline t_field_map_entry fmap_entry(t_field_id field_id,
										   uint8_t child_index, bool inherited)
{
	return ((t_field_map_entry){
		.field_id = field_id,
		.child_index = child_index,
		.inherited = inherited,
	});
};

static inline t_field_map_slice fmap_slice(t_u16 index, t_u16 length)
{
	return ((t_field_map_slice){
		.index = index,
		.length = length,
	});
};

static inline t_symbol_metadata sym_metadata(bool visible, bool named,
											 bool supertype)
{
	return ((t_symbol_metadata){
		.visible = visible,
		.named = named,
		.supertype = supertype,
	});
};

static inline t_parse_action_entry entry(uint8_t count, bool reusable)
{
	return ((t_parse_action_entry){
		.entry = {.count = count, .reusable = reusable}});
};

static inline t_parse_action_entry shift(t_state_id state_value)
{
	return ((t_parse_action_entry){{.shift = {
										.type = ActionTypeShift,
										.state = (state_value),
									}}});
};

static inline t_parse_action_entry shift_repeat(t_state_id state_value)
{
	return ((t_parse_action_entry){{.shift = {.type = ActionTypeShift,
											  .state = (state_value),
											  .repetition = true}}});
};

static inline t_parse_action_entry shift_extra(void)
{
	return ((t_parse_action_entry){
		{.shift = {.type = ActionTypeShift, .extra = true}}});
};

static inline t_parse_action_entry reduce(

	t_symbol symbol, uint8_t child_count, int16_t dynamic_precedence,
	t_u16 production_id)
{
	return (
		(t_parse_action_entry){{.reduce = {
									.type = ActionTypeReduce,
									.child_count = child_count,
									.symbol = symbol,
									.dynamic_precedence = dynamic_precedence,
									.production_id = production_id,
								}}});
};

static inline t_parse_action_entry recover(void)
{
	return ((t_parse_action_entry){{.type = ActionTypeRecover}});
};

static inline t_parse_action_entry accept(void)
{
	return ((t_parse_action_entry){{.type = ActionTypeAccept}});
};

static inline bool set_contains(t_char_range *ranges, t_u32 len,
								int32_t lookahead)
{
	t_u32 index = 0;
	t_u32 size = len - index;
	while (size > 1)
	{
		t_u32		  half_size = size / 2;
		t_u32		  mid_index = index + half_size;
		t_char_range *range = &ranges[mid_index];
		if (lookahead >= range->start && lookahead <= range->end)
		{
			return true;
		}
		else if (lookahead > range->end)
		{
			index = mid_index;
		}
		size -= half_size;
	}
	t_char_range *range = &ranges[index];
	return (lookahead >= range->start && lookahead <= range->end);
};

static inline bool advance_map_inner(t_u32 *map, t_u32 elems, t_lexer *l,
									 t_lexer_state *s)
{
	t_u32 i;

	(void)(l);
	i = 0;
	while (i < elems)
	{
		if (map[i] == (t_u32)s->lookahead)
		{
			s->state = map[i + 1];
			return true;
		}
		i += 2;
	}
	return (false);
};

static inline t_lex_modes lex_mode_external(t_u16 lex_state,
											t_u16 ext_lex_state)
{
	return ((t_lex_modes){
		.lex_state = lex_state,
		.external_lex_state = ext_lex_state,
	});
};

static inline t_lex_modes lex_mode_normal(t_u16 lex_state)
{
	return ((t_lex_modes){
		.lex_state = lex_state,
	});
};

static inline t_u16 actions(t_u16 val)
{
	return (val);
};

static inline t_u16 state(t_u16 val)
{
	return (val);
};

#endif /* PARSETYPES_H */