#ifndef TREE_SITTER_PARSER_H_
#define TREE_SITTER_PARSER_H_

#ifdef __cplusplus
extern "C"
{
#endif

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

#define ts_builtin_sym_error ((TSSymbol)-1)
#define ts_builtin_sym_end 0
#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024

#ifndef TREE_SITTER_API_H_
	typedef uint16_t		  TSStateId;
	typedef uint16_t		  TSSymbol;
	typedef uint16_t		  TSFieldId;
	typedef struct TSLanguage TSLanguage;
#endif

	typedef struct TSFieldMapEntry
	{
		TSFieldId field_id;
		uint8_t	  child_index;
		bool	  inherited;
	} TSFieldMapEntry;

	typedef struct TSFieldMapSlice
	{
		uint16_t index;
		uint16_t length;
	} TSFieldMapSlice;

	typedef struct TSSymbolMetadata
	{
		bool visible;
		bool named;
		bool supertype;
	} TSSymbolMetadata;

	typedef struct TSLexer TSLexer;

	struct TSLexer
	{
		int32_t	 lookahead;
		TSSymbol result_symbol;
		void (*advance)(TSLexer *, bool);
		void (*mark_end)(TSLexer *);
		uint32_t (*get_column)(TSLexer *);
		bool (*is_at_included_range_start)(const TSLexer *);
		bool (*eof)(const TSLexer *);
	};

	typedef enum TSParseActionType
	{
		TSParseActionTypeShift,
		TSParseActionTypeReduce,
		TSParseActionTypeAccept,
		TSParseActionTypeRecover,
	} TSParseActionType;

	typedef union TSParseAction {
		struct TSParseActionShift
		{
			uint8_t	  type;
			TSStateId state;
			bool	  extra;
			bool	  repetition;
		} shift;
		struct TSParseActionReduce
		{
			uint8_t	 type;
			uint8_t	 child_count;
			TSSymbol symbol;
			int16_t	 dynamic_precedence;
			uint16_t production_id;
		} reduce;
		uint8_t type;
	} TSParseAction;

	typedef struct TSLexMode
	{
		uint16_t lex_state;
		uint16_t external_lex_state;
	} TSLexMode;

	typedef union TSParseActionEntry {
		TSParseAction action;
		struct TSParseActionEntryData
		{
			uint8_t count;
			bool	reusable;
		} entry;
	} TSParseActionEntry;

	typedef struct TSCharacterRange
	{
		int32_t start;
		int32_t end;
	} TSCharacterRange;

	struct TSLanguage
	{
		uint32_t				  version;
		uint32_t				  symbol_count;
		uint32_t				  alias_count;
		uint32_t				  token_count;
		uint32_t				  external_token_count;
		uint32_t				  state_count;
		uint32_t				  large_state_count;
		uint32_t				  production_id_count;
		uint32_t				  field_count;
		uint16_t				  max_alias_sequence_length;
		const uint16_t			 *parse_table;
		const uint16_t			 *small_parse_table;
		const uint32_t			 *small_parse_table_map;
		const TSParseActionEntry *parse_actions;
		const char *const		 *symbol_names;
		const char *const		 *field_names;
		const TSFieldMapSlice	 *field_map_slices;
		const TSFieldMapEntry	 *field_map_entries;
		const TSSymbolMetadata	 *symbol_metadata;
		const TSSymbol			 *public_symbol_map;
		const uint16_t			 *alias_map;
		const TSSymbol			 *alias_sequences;
		const TSLexMode			 *lex_modes;
		bool (*lex_fn)(TSLexer *, TSStateId);
		bool (*keyword_lex_fn)(TSLexer *, TSStateId);
		TSSymbol keyword_capture_token;
		struct ExternalScannerDefinition
		{
			const bool	   *states;
			const TSSymbol *symbol_map;
			void *(*create)(void);
			void (*destroy)(void *);
			bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist);
			unsigned (*serialize)(void *, char *);
			void (*deserialize)(void *, const char *, unsigned);
		} external_scanner;
		const TSStateId *primary_state_ids;
	};

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

	/*
	 *  Lexer Macros
	 */

#ifdef _MSC_VER
# define UNUSED __pragma(warning(suppress : 4101))
#else
# define UNUSED __attribute__((unused))
#endif

#define START_LEXER()                                                                                                                      \
	bool result = false;                                                                                                                   \
	bool skip = false;                                                                                                                     \
	UNUSED                                                                                                                                 \
	bool	eof = false;                                                                                                                   \
	int32_t lookahead;                                                                                                                     \
	goto start;                                                                                                                            \
next_state:                                                                                                                                \
	lexer->advance(lexer, skip);                                                                                                           \
start:                                                                                                                                     \
	skip = false;                                                                                                                          \
	lookahead = lexer->lookahead;

#define ADVANCE(state_value)                                                                                                               \
	{                                                                                                                                      \
		state = state_value;                                                                                                               \
		goto next_state;                                                                                                                   \
	}

#define ADVANCE_MAP(...)                                                                                                                   \
	{                                                                                                                                      \
		static const uint16_t map[] = {__VA_ARGS__};                                                                                       \
		for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2)                                                                     \
		{                                                                                                                                  \
			if (map[i] == lookahead)                                                                                                       \
			{                                                                                                                              \
				state = map[i + 1];                                                                                                        \
				goto next_state;                                                                                                           \
			}                                                                                                                              \
		}                                                                                                                                  \
	}

#define SKIP(state_value)                                                                                                                  \
	{                                                                                                                                      \
		skip = true;                                                                                                                       \
		state = state_value;                                                                                                               \
		goto next_state;                                                                                                                   \
	}

#define ACCEPT_TOKEN(symbol_value)                                                                                                         \
	result = true;                                                                                                                         \
	lexer->result_symbol = symbol_value;                                                                                                   \
	lexer->mark_end(lexer);

#define END_STATE() return result;

	/*
	 *  Parse Table Macros
	 */

#define SMALL_STATE(id) ((id)-LARGE_STATE_COUNT)

#define STATE(id) id

#define ACTIONS(id) id

#define SHIFT(state_value)                                                                                                                 \
	{                                                                                                                                      \
		{                                                                                                                                  \
			.shift = {.type = TSParseActionTypeShift, .state = (state_value) }                                                             \
		}                                                                                                                                  \
	}

#define SHIFT_REPEAT(state_value)                                                                                                          \
	{                                                                                                                                      \
		{                                                                                                                                  \
			.shift = {.type = TSParseActionTypeShift, .state = (state_value), .repetition = true }                                         \
		}                                                                                                                                  \
	}

#define SHIFT_EXTRA()                                                                                                                      \
	{                                                                                                                                      \
		{                                                                                                                                  \
			.shift = {.type = TSParseActionTypeShift, .extra = true }                                                                      \
		}                                                                                                                                  \
	}

#define REDUCE(symbol_name, children, precedence, prod_id)                                                                                 \
	{                                                                                                                                      \
		{                                                                                                                                  \
			.reduce = {.type = TSParseActionTypeReduce,                                                                                    \
					   .symbol = symbol_name,                                                                                              \
					   .child_count = children,                                                                                            \
					   .dynamic_precedence = precedence,                                                                                   \
					   .production_id = prod_id},                                                                                          \
		}                                                                                                                                  \
	}

#define RECOVER()                                                                                                                          \
	{                                                                                                                                      \
		{                                                                                                                                  \
			.type = TSParseActionTypeRecover                                                                                               \
		}                                                                                                                                  \
	}

#define ACCEPT_INPUT()                                                                                                                     \
	{                                                                                                                                      \
		{                                                                                                                                  \
			.type = TSParseActionTypeAccept                                                                                                \
		}                                                                                                                                  \
	}

#ifdef __cplusplus
}
#endif

#endif // TREE_SITTER_PARSER_H_