#include "PlayingViewVisualizer.hpp"
#include "ChessboardVisualizer.hpp"
#include "HistorieVisualizer.hpp"
#include "CommandMenuVisualizer.hpp"

void PlayingViewVisualizer::GenerateElement() {
  position_vector.clear();
  display_vector.clear();
  ChessboardVisualizer chessboardVisualizer = ChessboardVisualizer(CHESSBOARD, 2);
  HistorieVisualizer historieVisualizer = HistorieVisualizer(CHESSBOARD, 32, 2);
  CommandMenuVisualizer cmdMenuVisualizer = CommandMenuVisualizer(CHESSBOARD, 2);

  GeneratePositionVector(chessboardVisualizer.GetDisplayVector(), historieVisualizer.GetDisplayVector(), cmdMenuVisualizer.GetDisplayVector());

  BaseVisualizer::GenerateTopBottomBorder(MAX_MENU_WIDTH, true, false);
  BaseVisualizer::GenerateEmptyLine(MAX_MENU_WIDTH, false);

  std::vector<std::string> temp;

  //((single) ? BaseVisualizer::VERTICAL_LINE_SINGLE : BaseVisualizer::VERTICAL_LINE) + std::string(padding, ' ')

  for (const auto& row : position_vector) {
    display_vector.push_back(row);
  }

  BaseVisualizer::GenerateEmptyLine(MAX_MENU_WIDTH, false);
  BaseVisualizer::GenerateTopBottomBorder(MAX_MENU_WIDTH, false, false);
  //size_t maxWidth = BaseVisualizer::FindMaxLength(chessboardVisualizer.display_vector);

}

void PlayingViewVisualizer::GeneratePositionVector(
  std::vector<std::vector<std::string>>* chessboard_display_vector,
  std::vector<std::vector<std::string>>* historie_display_vector,
  std::vector<std::vector<std::string>>* command_menu_display_vector)
{
  for (size_t i = 0; i < chessboard_display_vector->size(); ++i) {
    size_t test;
    std::vector<std::string> temp;
    temp.push_back({BaseVisualizer::VERTICAL_LINE + "   "});
    if (i == 0) {
      const std::string& first_element = chessboard_display_vector->at(i).at(0);
      temp.push_back(first_element);
      temp.push_back(std::string(62-BaseVisualizer::CountVisibleCharacters(first_element), ' '));
    } else if (chessboard_display_vector->at(i).size() > 1 && i != 0) {
      temp.insert(temp.end(), chessboard_display_vector->at(i).begin(), chessboard_display_vector->at(i).end());
    } else {
      temp.push_back(chessboard_display_vector->at(i).at(0));
    }

    if (i < historie_display_vector->size()) {
      temp.push_back(std::string(DISTANCE_BETWEEN_ELEMENTS, ' '));
      temp.push_back(historie_display_vector->at(i)[0]);
    } else if (i-3-historie_display_vector->size() < command_menu_display_vector->size()) {
      temp.push_back(std::string(DISTANCE_BETWEEN_ELEMENTS, ' '));
      temp.push_back(command_menu_display_vector->at(i-3-historie_display_vector->size())[0]);
    } else{
      temp.push_back({"", ""});
    }

    BaseVisualizer::GetSumAllCharsFromVector(temp);
    temp.push_back(std::string(MAX_MENU_WIDTH-BaseVisualizer::GetSumAllCharsFromVector(temp)-1, ' ') + BaseVisualizer::VERTICAL_LINE);

    position_vector.push_back(temp);
  }
}

void PlayingViewVisualizer::DisplayElement() {
  PlayingViewVisualizer::GenerateElement();
  size_t size;
  std::string temp;
  for (int row = 0; row < display_vector.size(); ++row) {
    for (int column = 0; column < display_vector[row].size(); ++column) {
      if (row >= 4 && row <= 27 && column >= 3 && column <= 10) {
        bool isSecondRowOfField = ((row-1) % 3 == 2);
        bool isBlackWhite = ((column-1) % 2 == (row-1) % 2);

        if ((row - 1) % 3 == 0) { // Change after 3 rows
          if (isSecondRowOfField) {
            this->SetConsoleColor(isBlackWhite ? BLACK : WHITE, isBlackWhite ? WHITE : BLACK);
          } else {
            this->SetConsoleColor(isBlackWhite ? WHITE : BLACK, isBlackWhite ? BLACK : WHITE);
          }
        } else {
          if (isSecondRowOfField) {
            this->SetConsoleColor(isBlackWhite ? WHITE : BLACK, isBlackWhite ? BLACK : WHITE);
          } else {
            this->SetConsoleColor(isBlackWhite ? BLACK : WHITE, isBlackWhite ? WHITE : BLACK);
          }
        }
      }
      std::cout << display_vector[row][column];
      this->SetConsoleColor(DEFAULT, DEFAULT);
    }
    this->SetConsoleColor(DEFAULT, DEFAULT);

    std::cout << std::endl;
  }
}

std::string PlayingViewVisualizer::GetMove() {
  return move;
}