#include "expression_printers.hpp"
#include "basic_nodes.hpp"
#include "basic_printers.hpp"
#include "expression_nodes.hpp"
#include "type_printers.hpp"

namespace printers {

void print_expression(const nodes::Expression &expression,
                      printers::Printer &printer) {} // IN PROGRESS

// --- flow control

void print_match(const nodes::Match &expression, printers::Printer &printer) {
} // IN PROGRESS

void print_condition(const nodes::Condition &expression,
                     printers::Printer &printer) {} // IN PROGRESS

void print_loop(const nodes::Loop &expression, printers::Printer &printer) {
} // IN PROGRESS

// --- containers

void print_container(const nodes::Container &expression,
                     printers::Printer &printer) {} // IN PROGRESS

// --- modifiers

void print_return(const nodes::Return &expression, printers::Printer &printer) {

  switch (expression.get_type()) {
  case nodes::Return::RETURN:
    printer.print("return ");
    break;
  case nodes::Return::BRING:
    printer.print("bring ");
    break;
  default:
    break;
  }

  print_expression(*expression.get_expression(), printer);
}

void print_name_definition(const nodes::NameDefinition &expression,
                           printers::Printer &printer) {

  if (printer.print_words_instead_of_symbols()) {
    switch (expression.get_modifier()) {
    case nodes::NameDefinition::LET:
      printer.print("let ");
      break;
    case nodes::NameDefinition::VAR:
      printer.print("var ");
      break;
    default:
      break;
    }
  } else {
    switch (expression.get_modifier()) {
    case nodes::NameDefinition::LET:
      printer.print("% ");
      break;
    case nodes::NameDefinition::VAR:
      printer.print("$ ");
      break;
    default:
      break;
    }
  }

  print_identifier(*expression.get_name(), printer);
}

void print_access(const nodes::Access &expression, printers::Printer &printer) {
  print_expression(*expression.get_value(), printer);

  switch (expression.get_type()) {
  case nodes::Access::ARRAY:
    printer.print('[');
    break;
  case nodes::Access::TUPLE:
    printer.print('.');
    break;
  default:
    break;
  }

  print_expression(*expression.get_index(), printer);

  switch (expression.get_type()) {
  case nodes::Access::ARRAY:
    printer.print(']');
    break;
  case nodes::Access::TUPLE:
    break;
  default:
    break;
  }
}

void print_loop_control(const nodes::LoopControl &expression,
                        printers::Printer &printer) {
  switch (expression.get_type()) {
  case nodes::LoopControl::BREAK:
    printer.print("break");
    break;
  case nodes::LoopControl::CONTINUE:
    printer.print("continue");
    break;
  default:
    break;
  }
}

void print_modifier_expression(const nodes::ModifierExpression &expression,
                               printers::Printer &printer) {

  if (printer.print_words_instead_of_symbols()) {
    switch (expression.get_modifier()) {
    case nodes::Modifier::OUT:
      printer.print("out ");
      break;
    case nodes::Modifier::IN:
      printer.print("in ");
      break;
    case nodes::Modifier::REF:
      printer.print("ref ");
      break;
    default:
      break;
    }
  } else {
    switch (expression.get_modifier()) {
    case nodes::Modifier::OUT:
      printer.print("-> ");
      break;
    case nodes::Modifier::IN:
      printer.print("<- ");
      break;
    case nodes::Modifier::REF:
      printer.print("<> ");
      break;
    default:
      break;
    }
  }

  print_expression(*expression.get_expression(), printer);

  switch (expression.get_modifier()) {
  case nodes::Modifier::OR_FALSE:
    printer.print('?');
    break;
  case nodes::Modifier::OR_RETURN:
    printer.print('!');
    break;
  default:
    break;
  }
}

// --- other

void print_name_expression(const nodes::NameExpression &expression,
                           printers::Printer &printer) {
  if (expression.is_operator_call() || expression.is_point_call()) {
    print_expression(*expression.get_argument_value(0), printer);
    if (expression.is_point_call()) {
      printer.print('.');
    } else {
      printer.space();
    }
  } else if (expression.get_prefix().has_value()) {
    print_type(*expression.get_prefix().value(), printer);
    printer.print('.');
  }

  print_identifier(*expression.get_name(), printer);

  for (size_t i = 0; i < expression.arguments_size(); ++i) {
    printer.space();

    if (expression.get_argument_annotation(i).has_value()) {
      print_annotation(*expression.get_argument_annotation(i).value(), printer);
      printer.space();
    }
    print_expression(*expression.get_argument_value(i), printer);
  }

} // IN PROGRESS

void print_constructor(const nodes::Constructor &expression,
                       printers::Printer &printer) {
  print_type(*expression.get_type(), printer);

  for (size_t i = 0; i < expression.arguments_size(); ++i) {
    printer.space();

    if (expression.get_argument_annotation(i).has_value()) {
      print_annotation(*expression.get_argument_annotation(i).value(), printer);
      printer.space();
    }

    print_expression(*expression.get_argument_value(i), printer);
  }

} // IN PROGRESS

void print_lambda(const nodes::Lambda &expression, printers::Printer &printer) {
  printer.print(printer.print_words_instead_of_symbols() ? "lambda " : "\\ ");

  for (size_t i = 0; i < expression.arguments_size(); ++i) {
    print_identifier(*expression.get_argument(i), printer);
    printer.space();
  }

  printer.print(printer.print_words_instead_of_symbols() ? "do " : "-> ");

  print_expression(*expression.get_expression(), printer);

} // IN PROGRESS

} // namespace printers