#include "../snake.h"

#include "../read_input/read_input.h"

#include <jag_parse.h>

#define DELAY 10

#define KEY_PROTECTION 2


bool start_animation() {  

  struct winsize current_size;
  if ((ioctl(STDOUT_FILENO, TIOCGWINSZ, &current_size)) == -1)
    return false;


  char *snake[3][7] = {
    {
      "           ________  ",
      "         _/ _      \\_",
      "________/  (_)       ",
      "\\       \\            ",
      "/_______/   _        ",
      "        \\_ (_)      _",
      "          \\________/ "
    },
    {
      "        ",
      "________",
      "\\      /",
      " \\    / ",
      "  \\  /  ",
      "___\\/___",
      "        ",
    },
    {
      "         ",
      "__        ",
      "  \\_____ ",
      "        \\",
      "   _____/",
      "__/      ",
      "         "
    }
  };

  uint8_t width_snake[3] = {};

  {
    uint8_t i;

    for (i = 0; i < 3; i++)
      width_snake[i] = (uint8_t) strlen(snake[i][0]);
  }

  uint8_t middle;

  uint8_t height = 7;
  uint8_t width = width_snake[0] + width_snake[1] + width_snake[2];

  for (middle = 1; width < current_size.ws_col; middle++)
    width += width_snake[1];

  int32_t end = current_size.ws_col + width;

  uint8_t wait_incomplete = 0;
  bool key_lock = false;

  bool exit = false;

  while (end >= 0 && !exit) {

    ioctl(STDOUT_FILENO, TIOCGWINSZ, &current_size);

    int32_t start = end - width; 

    int32_t i, j;
  
    printf("\033[2J\033[H");

    for (j = 0; j < ((height > current_size.ws_row) ? current_size.ws_row : height) ; j++) {

    for (i = 0; i < current_size.ws_col; i++) {
      int32_t index = i - start;

      if (index >= 0 && index < width) {
        if (index < width_snake[0]) {
          printf("%c", snake[0][j][index]);
        } else if (index < width_snake[0] + width_snake[1] * middle) {
          printf("%c", snake[1][j][(index - width_snake[0]) % width_snake[1]]);
        } else {
          printf("%c", snake[2][j][index - (width_snake[0] + width_snake[1] * middle)]);
        }
      } else {
        printf(" ");
      }
    }      
    
      printf("\n");

    }
    fflush(stdout);
    
    end--;


    bool is_broken = false;
 
    if (wait_incomplete >= KEY_PROTECTION) {
     
      key_lock = false;
      wait_incomplete = 0;
      is_broken = true;
    }


    if (key_lock)
      wait_incomplete++;


    
    keypress *input;
    size_t input_len = 0;

    if (read_input(&input, &input_len, &key_lock, is_broken, DELAY)) {
   
      size_t k;

      for (k = 0; k < input_len; k++) {
        switch (input[k]) {
          case Q_KEY:
          case ESCAPE_KEY:
            exit = true;
            return false;
            break;
          case ENTER_KEY:
            end = -1; 
            break;
          default:
            break;
        } 
      }

      free_input(input);
    }
  }

  return exit ? false : true;
}