/*
 * Copyright (C) 2023 Johnny Richard
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
#ifndef AST_H
#define AST_H
#include "lexer.h"
#include "string_view.h"
#include "vector.h"
#include <stdint.h>

typedef enum
{
  TYPE_I32,
  TYPE_BOOL,
  TYPE_VOID,
} type_t;

typedef struct ast_node_t ast_node_t;

typedef struct ast_namespace_t
{
  vector_t *nodes;
} ast_namespace_t;

typedef struct ast_block_t
{
  vector_t *body;
} ast_block_t;

typedef struct ast_return_stmt_t
{
  ast_node_t *argument;
} ast_return_stmt_t;

typedef struct ast_identifier_t
{
  string_view_t name;
} ast_identifier_t;

typedef struct ast_variable_t
{
  ast_identifier_t *identifier;
} ast_variable_t;

typedef struct ast_function_call_t
{
  ast_identifier_t *identifier;
  vector_t *arguments;
} ast_function_call_t;

typedef struct ast_function_parameter_t
{
  ast_identifier_t identifier;
  type_t type;
} ast_function_parameter_t;

typedef struct ast_function_prototype_t
{
  ast_identifier_t identifier;
  type_t return_type;
  vector_t *parameters;
} ast_function_prototype_t;

typedef struct ast_function_declaration_t
{
  ast_function_prototype_t prototype;
  ast_node_t *body;
} ast_function_declaration_t;

typedef enum ast_binary_operation_kind_t
{
  AST_BINOP_ADITION,
  AST_BINOP_SUBTRACTION,
  AST_BINOP_MULTIPLICATION,
  AST_BINOP_DIVISION,
  AST_BINOP_EQUAL,
  AST_BINOP_NOT_EQUAL,
  AST_BINOP_AND,
  AST_BINOP_OR,
  AST_BINOP_GT,
  AST_BINOP_LT,
  AST_BINOP_LT_EQUAL,
  AST_BINOP_GT_EQUAL,
  AST_BINOP_N
} ast_binary_operation_kind_t;

typedef struct ast_binary_operation_t
{
  ast_binary_operation_kind_t kind;
  ast_node_t *left;
  ast_node_t *right;
} ast_binary_operation_t;

typedef enum
{
  AST_LITERAL_INTEGER,
  AST_LITERAL_BOOL
} ast_literal_kind_t;

typedef union
{
  uint32_t integer;
  bool boolean;
} ast_literal_value_t;

typedef struct ast_literal_t
{
  ast_literal_kind_t kind;
  ast_literal_value_t value;
} ast_literal_t;

typedef struct ast_variable_declaration_t
{
  ast_identifier_t identifier;
  type_t type;
  ast_node_t *value;
} ast_variable_declaration_t;

typedef struct ast_variable_assignment_t
{
  ast_identifier_t *identifier;
  ast_node_t *expression;
} ast_variable_assignment_t;

typedef struct ast_if_stmt_t
{
  ast_node_t *condition;
  ast_node_t *body;
} ast_if_stmt_t;

typedef struct ast_unkown_token_t
{
  type_t expected_type;
  token_t reference_token;
} ast_unkown_token_t;

typedef enum
{
  AST_NAMESPACE,
  AST_BINARY_OPERATION,
  AST_BLOCK,
  AST_FUNCTION_DECLARATION,
  AST_FUNCTION_PARAMETER,
  AST_FUNCTION_CALL,
  AST_LITERAL,
  AST_RETURN_STMT,
  AST_IF_STMT,
  AST_VARIABLE_DECLARATION,
  AST_VARIABLE_ASSIGNMENT,
  AST_VARIABLE,
  AST_UNKOWN_NODE
} ast_node_kind_t;

typedef union
{
  ast_namespace_t ns;
  ast_binary_operation_t binary_operation;
  ast_function_declaration_t function;
  ast_function_parameter_t function_parameter;
  ast_function_call_t function_call;
  ast_literal_t literal;
  ast_block_t block;
  ast_if_stmt_t if_stmt;
  ast_return_stmt_t return_stmt;
  ast_variable_declaration_t variable_declaration;
  ast_variable_assignment_t variable_assignment;
  ast_variable_t variable;
  ast_unkown_token_t unknown;
} ast_node_data_t;

typedef struct ast_node_t
{
  ast_node_kind_t kind;
  ast_node_data_t data;
  type_t result_type;
} ast_node_t;

char *
ast_type_to_str(type_t type);

ast_node_t *
ast_node_new(void);

void
ast_node_destroy_vector(vector_t *vector);

void
ast_node_destroy(ast_node_t *node);

ast_node_t *
ast_node_new_namespace(vector_t *nodes);

ast_node_t *
ast_node_new_binary_operation(ast_binary_operation_kind_t kind,
                              ast_node_t *left,
                              ast_node_t *right,
                              type_t result_type);

ast_node_t *
ast_node_new_function_declaration(string_view_t function_name,
                                  type_t return_type,
                                  vector_t *parameters,
                                  ast_node_t *body);

ast_node_t *
ast_node_new_function_parameter(string_view_t name, type_t type);

ast_node_t *
ast_node_new_function_call(ast_identifier_t *identifier, type_t result_type, vector_t *arguments);

ast_node_t *
ast_node_new_return_stmt(ast_node_t *argument);

ast_node_t *
ast_node_new_variable_declaration(string_view_t variable_name, type_t type, ast_node_t *value);

ast_node_t *
ast_node_new_literal_integer(uint32_t number);

ast_node_t *
ast_node_new_block(vector_t *body);

ast_node_t *
ast_node_new_literal_bool(bool boolean);

ast_node_t *
ast_node_new_variable(ast_identifier_t *identifier, type_t result_type);

ast_node_t *
ast_node_new_variable_assignment(ast_identifier_t *identifier, ast_node_t *expression);

ast_node_t *
ast_node_new_if_stmt(ast_node_t *condition, ast_node_t *body);

ast_node_t *
ast_node_ns_get_function_node_by_sv(ast_node_t *ns, string_view_t name);

ast_node_t *
ast_node_ns_get_function_node_by_name(ast_node_t *ns, char *function_name);

bool
ast_node_is_variable_declaration(ast_node_t *node);

bool
ast_node_is_function_declaration(ast_node_t *node);

ast_identifier_t *
ast_node_function_declaration_identifier(ast_node_t *node);

string_view_t
ast_node_function_declaration_name(ast_node_t *node);

#endif /* AST_H */