/*
* 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/>.
*/

#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "ast.h"
#include "lexer.h"
#include "parser.h"

void
parser_init(parser_t *parser, lexer_t *lexer)
{
  assert(parser && "parser must be defined");
  assert(lexer && "lexer must be defined");
  parser->lexer = lexer;
  parser->errors_len = 0;
}

static bool
expected_token(token_t *token, parser_t *parser, token_kind_t kind)
{
  lexer_next_token(parser->lexer, token);
  parser_error_t error;

  if (token->kind == TOKEN_EOF) {
    error.token = *token;
    sprintf(
        error.message,
        "expected '%s' but got end of file",
        token_kind_to_str(kind)
    );

    parser->errors[parser->errors_len++] = error;
    return false;
  }

  if (token->kind != kind) {
    error.token = *token;
    sprintf(
        error.message,
        "expected '%s' but got '%s'",
        token_kind_to_str(kind), token_kind_to_str(token->kind)
    );
    parser->errors[parser->errors_len++] = error;
    return false;
  }

  return true;
}

static bool
drop_expected_token(parser_t *parser, token_kind_t kind)
{
  token_t ignored_token;
  return expected_token(&ignored_token, parser, kind);
}

static bool
parser_parse_type(type_t *type, parser_t *parser)
{
  token_t token;

  if(!expected_token(&token, parser, TOKEN_NAME)) return false;

  if (string_view_eq(token.value, string_view_from_str("i32"))) {
    *type = TYPE_I32;
    return true;
  }

  parser_error_t error;
  error.token = token;

  sprintf(
      error.message,
      "type '"SVFMT"' is not defined",
      SVARG(&token.value)
  );

  parser->errors[parser->errors_len++] = error;
  return false;
}

bool
parser_literal_integer_node(ast_node_t *node, token_t *token)
{
  char number_as_str[token->value.size];
  string_view_to_str(&token->value, number_as_str);

  ast_literal_integer_create(node, atoi(number_as_str));
  return true;
}

bool
parser_parse_factor(parser_t *parser, ast_node_t *node)
{
  token_t token;
  lexer_next_token(parser->lexer, &token);

  if (token.kind == TOKEN_NUMBER) {
    return parser_literal_integer_node(node, &token);
  } else if (token.kind == TOKEN_OPAREN) {
    parser_parse_expression(parser, node);
    if (!drop_expected_token(parser, TOKEN_CPAREN)) return false;
    return true;
  }

  // FIXME: Extract this erros logic to a function
  parser_error_t error;
  error.token = token;
  sprintf(
      error.message,
      "unexpected '%s ("SVFMT")' token",
      token_kind_to_str(token.kind),
      SVARG(&token.value)
  );
  parser->errors[parser->errors_len++] = error;

  return false;
}

bool
parser_parse_term(parser_t *parser, ast_node_t *node)
{
  if (!parser_parse_factor(parser, node)) return false;

  token_t token;
  lexer_next_token(parser->lexer, &token);

  while (token.kind == TOKEN_OP && (string_view_eq(token.value, string_view_from_str("*")) || string_view_eq(token.value, string_view_from_str("/")))) {
    ast_node_t *left = ast_node_new();
    *left = *node;

    ast_node_t *right = ast_node_new();
    if (!parser_parse_factor(parser, right)) return false;

    ast_node_init_binary_operation(node, token.value, left, right);

    lexer_next_token(parser->lexer, &token);
  }

  lexer_step_back_to(parser->lexer, &token);

  return true;
}

/**
 *
 * <expression> ::= <term> (('+' | '-') term)*
 * <term>       ::= <factor> (('*' | '/') factor)*
 * <factor>     ::= <integer> | '(' <expression> ')'
 *
 */
bool
parser_parse_expression(parser_t *parser, ast_node_t *node)
{
  if (!parser_parse_term(parser, node)) return false;

  token_t token;
  lexer_next_token(parser->lexer, &token);

  while (token.kind == TOKEN_OP && (string_view_eq(token.value, string_view_from_str("+")) || string_view_eq(token.value, string_view_from_str("-")))) {
    ast_node_t *left = ast_node_new();
    *left = *node;

    ast_node_t *right = ast_node_new();
    if (!parser_parse_term(parser, right)) return false;

    ast_node_init_binary_operation(node, token.value, left, right);

    lexer_next_token(parser->lexer, &token);
  }

  lexer_step_back_to(parser->lexer, &token);

  return true;
}

bool
parser_parse_return_stmt(parser_t *parser, ast_node_t *node)
{
  token_t return_keyword_token;

  if (!drop_expected_token(parser, TOKEN_OCURLY)) return false;

  if(!expected_token(&return_keyword_token, parser, TOKEN_NAME)) return false;

  if (!string_view_eq(return_keyword_token.value, string_view_from_str("return"))) {
    parser_error_t error;
    error.token = return_keyword_token;

    sprintf(
        error.message,
        "expected 'return' keyword but got '"SVFMT"'",
        SVARG(&return_keyword_token.value)
    );

    parser->errors[parser->errors_len++] = error;
    return false;
  }

  ast_node_t *argument_token = ast_node_new();
  if (!parser_parse_expression(parser, argument_token)) return false;

  if (!drop_expected_token(parser, TOKEN_SEMICOLON)) return false;
  if (!drop_expected_token(parser, TOKEN_CCURLY)) return false;

  ast_node_init_return_stmt(node, argument_token);
  return true;
}

bool
parser_parse_function_declaration(parser_t *parser, ast_node_t *node)
{
  token_t func_name_token;

  if (!expected_token(&func_name_token, parser, TOKEN_NAME)) {
    return false;
  }

  if (!drop_expected_token(parser, TOKEN_OPAREN)) return false;
  if (!drop_expected_token(parser, TOKEN_CPAREN)) return false;
  if (!drop_expected_token(parser, TOKEN_COLON)) return false;

  type_t return_type;

  if(!parser_parse_type(&return_type, parser)) {
    return false;
  }

  ast_node_t *return_node = ast_node_new();

  bool parsed_return = parser_parse_return_stmt(parser, return_node);

  if (!parsed_return) {
    return false;
  }

  ast_node_init_function_declaration(
    node,
    func_name_token.value,
    return_type,
    return_node
  );

  return true;
}