#include <ivy/lang/lex.h>
#include <ivy/lang/operator.h>
#include <stddef.h>

#define SYM_OP(id, t, p, a)                                                    \
	[IVY_SYM_##t] = {                                                      \
		.op_id = (IVY_OP_##id),                                        \
		.op_token = (IVY_SYM_##t),                                     \
		.op_precedence = (IVY_PRECEDENCE_##p),                         \
		.op_associativity = (IVY_ASSOCIATIVITY_##a),                   \
	}
#define KW_OP(id, t, p, a)                                                     \
	[IVY_KW_##t] = {                                                       \
		.op_id = (IVY_OP_##id),                                        \
		.op_token = (IVY_KW_##t),                                      \
		.op_precedence = (IVY_PRECEDENCE_##p),                         \
		.op_associativity = (IVY_ASSOCIATIVITY_##a),                   \
	}

/* clang-format off */
static const struct ivy_operator operators[] = {
	SYM_OP(ASSIGN,			EQUAL,				ASSIGN,		RIGHT),
	SYM_OP(ADD,			PLUS,				ADDITION,	LEFT),
	SYM_OP(SUBTRACT,		HYPHEN,				ADDITION,	LEFT),
	SYM_OP(MULTIPLY,		ASTERISK,			MULTIPLICATION,	LEFT),
	SYM_OP(DIVIDE,			FORWARD_SLASH,			MULTIPLICATION,	LEFT),
	SYM_OP(MODULO,			PERCENT,			MULTIPLICATION,	LEFT),
	SYM_OP(LEFT_SHIFT,		DOUBLE_LEFT_ANGLE,		BITSHIFT,	LEFT),
	SYM_OP(RIGHT_SHIFT,		DOUBLE_RIGHT_ANGLE,		BITSHIFT,	LEFT),
	SYM_OP(BINARY_AND,		AMPERSAND,			BITWISE_AND,	LEFT),
	SYM_OP(BINARY_OR,		PIPE,				BITWISE_OR,	LEFT),
	SYM_OP(BINARY_XOR,		CARET,				BITWISE_XOR,	LEFT),
	SYM_OP(LESS_THAN,		LEFT_ANGLE,			COMPARISON,	LEFT),
	SYM_OP(GREATER_THAN,		RIGHT_ANGLE,			COMPARISON,	LEFT),
	SYM_OP(CASCADE,			SEMICOLON,			CASCADE,	LEFT),
	SYM_OP(EQUAL,			DOUBLE_EQUAL,			EQUALITY,	LEFT),
	SYM_OP(NOT_EQUAL,		BANG_EQUAL,			EQUALITY,	LEFT),
	SYM_OP(LESS_EQUAL,		LEFT_ANGLE_EQUAL,		COMPARISON,	LEFT),
	SYM_OP(GREATER_EQUAL,		RIGHT_ANGLE_EQUAL,		COMPARISON,	LEFT),
	SYM_OP(ADD_ASSIGN,		PLUS_EQUAL,			ASSIGN,		RIGHT),
	SYM_OP(SUBTRACT_ASSIGN,		HYPHEN_EQUAL,			ASSIGN,		RIGHT),
	SYM_OP(MULTIPLY_ASSIGN,		ASTERISK_EQUAL,			ASSIGN,		RIGHT),
	SYM_OP(DIVIDE_ASSIGN,		FORWARD_SLASH_EQUAL,		ASSIGN,		RIGHT),
	SYM_OP(MODULO_ASSIGN,		PERCENT_EQUAL,			ASSIGN,		RIGHT),
	SYM_OP(LEFT_SHIFT_ASSIGN,	DOUBLE_LEFT_ANGLE_EQUAL,	ASSIGN,		RIGHT),
	SYM_OP(RIGHT_SHIFT_ASSIGN,	DOUBLE_RIGHT_ANGLE_EQUAL,	ASSIGN,		RIGHT),
	SYM_OP(BINARY_AND_ASSIGN,	AMPERSAND_EQUAL,		ASSIGN,		RIGHT),
	SYM_OP(BINARY_OR_ASSIGN,	PIPE_EQUAL,			ASSIGN,		RIGHT),
	SYM_OP(BINARY_XOR_ASSIGN,	CARET_EQUAL,			ASSIGN,		RIGHT),
	KW_OP(AND,			AND,				LOGICAL_AND,	LEFT),
	KW_OP(OR,			OR,				LOGICAL_OR,	LEFT),
	KW_OP(IS,			IS,				IS,		LEFT),
	KW_OP(NOT,			NOT,				NOT,		LEFT),
	KW_OP(UNDERSTANDS,		UNDERSTANDS,			IS,		LEFT),
	SYM_OP(SELF_ACCESS,		DOUBLE_COLON,			SUBSCRIPT,	LEFT),
	SYM_OP(PKG_ACCESS,		HYPHEN_RIGHT_ANGLE,		SUBSCRIPT,	LEFT),
};
static const size_t nr_operators = sizeof operators / sizeof operators[0];
/* clang-format on */

const struct ivy_operator *ivy_operator_get(unsigned int token)
{
	if (token >= nr_operators) {
		return NULL;
	}

	const struct ivy_operator *op = &operators[token];
	if (op->op_token != token) {
		return NULL;
	}

	return op;
}