#ifndef FZL_ANALYZER_H
#define FZL_ANALYZER_H

#include <common/fzl_types.h>
#include <compiler/fzl_parser.h>
#include <compiler/fzl_token.h>
#include <compiler/utils/fzl_symtable.h>
#include <stdbool.h>
#include <stddef.h>

// Analyzing context type
typedef enum
{
  FZL_AN_CTX_TYPE_UNNECESSARY, // default type
  FZL_AN_CTX_TYPE_FUNCTION,    // when analyzing function
  FZL_AN_CTX_TYPE_LOOP,        // when analyzing loop
  FZL_AN_CTX_TYPE_CLASS,       // when analyzing class
} fzl_an_ctx_type_t;

// Inner node analyzing result descriptor
typedef struct
{
  bool error;

  fzl_type_t type;
  char *classname;
} fzl_an_res_t;

// Current node context descriptor
typedef struct fzl_an_ctx
{
  struct fzl_an_ctx *parent;

  fzl_an_ctx_type_t type;
  fzl_symtable_t *symbols;
  size_t symbols_level;

  union
  {
    fzl_node_t *fn;
    char *classname;
  };
} fzl_an_ctx_t;

// Analyzer descriptor
typedef struct
{
  char *warnings[256];
  size_t warnings_top;

  char *errors[256];
  size_t errors_top;

  fzl_symtable_t *symbols[256];
  size_t symbols_top;

  char *alloc_names[256];
  size_t alloc_names_top;

  fzl_node_t *root;
  fzl_an_ctx_t *ctx;
} fzl_analyzer_t;

// Allocate analyzer
fzl_analyzer_t *fzl_mkanalyzer(fzl_node_t *node);

// Push error to errors list
bool an_push_error(fzl_analyzer_t *analyzer, fzl_token_t *tok, char *error);

// Push warning to warnings list
bool an_push_warning(fzl_analyzer_t *analyzer, fzl_token_t *tok, char *warning);

// Analyze AST
void fzl_analyze(fzl_analyzer_t *analyzer);

// Free analyzer
void fzl_freeanalyzer(fzl_analyzer_t *analyzer);

fzl_an_res_t analyze_common(fzl_analyzer_t *analyzer, fzl_node_t *node);
fzl_an_res_t analyze_call(fzl_analyzer_t *analyzer, fzl_node_t *call_node);
fzl_an_res_t analyze_identifier(fzl_analyzer_t *analyzer, fzl_node_t *id);
fzl_an_res_t analyze_conditional(fzl_analyzer_t *analyzer, fzl_node_t *cond);
fzl_an_res_t analyze_function(fzl_analyzer_t *analyzer, fzl_node_t *fn_node);
fzl_an_res_t analyze_block(fzl_analyzer_t *analyzer, fzl_node_t *block_node);
fzl_an_res_t analyze_return(fzl_analyzer_t *analyzer, fzl_node_t *ret_node);
fzl_an_res_t analyze_class(fzl_analyzer_t *analyzer, fzl_node_t *class_node);
fzl_an_res_t analyze_field(fzl_analyzer_t *analyzer, fzl_node_t *field);
fzl_an_res_t analyze_declaration(fzl_analyzer_t *analyzer, fzl_node_t *decl);
fzl_an_res_t analyze_construct(fzl_analyzer_t *analyzer, fzl_node_t *construct);
fzl_an_res_t analyze_loop(fzl_analyzer_t *analyzer, fzl_node_t *loop_node);
fzl_an_res_t analyze_break(fzl_analyzer_t *analyzer, fzl_node_t *break_node);
fzl_an_res_t analyze_binmath(fzl_analyzer_t *analyzer, fzl_node_t *bin_node);
fzl_an_res_t analyze_unarymath(fzl_analyzer_t *analyzer, fzl_node_t *unary);
fzl_an_res_t analyze_condition(fzl_analyzer_t *analyzer, fzl_node_t *cond_node);
fzl_an_res_t analyze_unarycond(fzl_analyzer_t *analyzer, fzl_node_t *unary);
fzl_an_res_t analyze_assign(fzl_analyzer_t *analyzer, fzl_node_t *assign_node);

fzl_an_ctx_t *an_nest_ctx(fzl_analyzer_t *analyzer, fzl_an_ctx_type_t type);
fzl_an_ctx_t *an_fin_ctx(fzl_analyzer_t *analyzer);

#endif // FZL_ANALYZER_H