#include <common/fzl_types.h>
#include <compiler/fzl_analyzer.h>
#include <compiler/fzl_parser.h>
#include <compiler/fzl_token.h>
#include <compiler/internals/analyzer.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>

// Analyzer main function
fzl_an_res_t analyze_common(fzl_analyzer_t *analyzer, fzl_node_t *node)
{
  if (!analyzer || !node)
    return (fzl_an_res_t){.error = true};

  fzl_an_res_t res = {.error = false, .type = FZL_TYPE_NULL, .classname = NULL};
  switch (node->type)
  {
    case FZL_NODETYPE_EXTERN:
      res = analyze_extern(analyzer, node);
      break;

    case FZL_NODETYPE_EXTERN_FN:
      res = analyze_externfn(analyzer, node);
      break;

    case FZL_NODETYPE_REFERENCE:
      res = analyze_ref(analyzer, node);
      break;

    case FZL_NODETYPE_STRUCT:
      res = analyze_struct(analyzer, node);
      break;

    case FZL_NODETYPE_ALIAS:
      res.type = an_toktotype(analyzer, node->token, NULL);
      break;

    case FZL_NODETYPE_HANDLE:
      res.type = FZL_TYPE_HANDLE;
      break;

    case FZL_NODETYPE_TYPEDEF:
      res = analyze_typedef(analyzer, node);
      break;

    case FZL_NODETYPE_FMT_STRING:
      res = analyze_strfmt(analyzer, node);
      break;

    case FZL_NODETYPE_ASSIGN:
      res = analyze_assign(analyzer, node);
      break;

    case FZL_NODETYPE_NOT:
      res = analyze_unarycond(analyzer, node);
      break;

    case FZL_NODETYPE_OR:
    case FZL_NODETYPE_AND:
    case FZL_NODETYPE_LESS:
    case FZL_NODETYPE_LESS_EQUAL:
    case FZL_NODETYPE_GREATER:
    case FZL_NODETYPE_GREATER_EQUAL:
    case FZL_NODETYPE_EQUAL:
    case FZL_NODETYPE_NEQUAL:
      res = analyze_condition(analyzer, node);
      break;

    case FZL_NODETYPE_UNARY_MINUS:
    case FZL_NODETYPE_UNARY_PLUS:
      res = analyze_unarymath(analyzer, node);
      break;

    case FZL_NODETYPE_ADD:
    case FZL_NODETYPE_SUB:
    case FZL_NODETYPE_MUL:
    case FZL_NODETYPE_DIV:
    case FZL_NODETYPE_POW:
    case FZL_NODETYPE_MOD:
      res = analyze_binmath(analyzer, node);
      break;

    case FZL_NODETYPE_BREAK:
      res = analyze_break(analyzer, node);
      break;

    case FZL_NODETYPE_LOOP:
      res = analyze_loop(analyzer, node);
      break;

    case FZL_NODETYPE_CONSTRUCT:
      res = analyze_construct(analyzer, node);
      break;

    case FZL_NODETYPE_DECLARATION:
      res = analyze_declaration(analyzer, node);
      break;

    case FZL_NODETYPE_FIELD:
      res = analyze_field(analyzer, node);
      break;

    case FZL_NODETYPE_CLASS:
      res = analyze_class(analyzer, node);
      break;

    case FZL_NODETYPE_RETURN:
      res = analyze_return(analyzer, node);
      break;

    case FZL_NODETYPE_FUNCTION:
      res = analyze_function(analyzer, node);
      break;

    case FZL_NODETYPE_CONDITIONAL:
      res = analyze_conditional(analyzer, node);
      break;

    case FZL_NODETYPE_IDENTIFIER:
      res = analyze_identifier(analyzer, node);
      break;

    case FZL_NODETYPE_BLOCK:
      res = analyze_block(analyzer, node);
      break;

    case FZL_NODETYPE_CALL:
      res = analyze_call(analyzer, node);
      break;

    case FZL_NODETYPE_LITERAL:
      switch (node->token->type)
      {
        case FZL_TOKTYPE_STR_LITERAL:
          res.type = FZL_TYPE_STRING;
          break;

        case FZL_TOKTYPE_NUM_LITERAL:
          res.type = FZL_TYPE_INT;
          break;

        case FZL_TOKTYPE_BOOL_LITERAL:
          res.type = FZL_TYPE_BOOL;
          break;

        case FZL_TOKTYPE_NULL_LITERAL:
          res.type      = FZL_TYPE_OBJECT;
          res.classname = "null";
          break;

        default:
          an_push_error(analyzer, node->token, "unknown literal type");
          res.error = true;
          break;
      }
      break;
  }

  return res;
}