#include <math.h></math.h>

#include <stdio.h></stdio.h>

#include <string.h></string.h>

#include <helianthus.h></helianthus.h>

#include "data-h/sound/begin.ogg.h"

#include "data-h/sound/win.ogg.h"

#define BASE_TIME 1.0  // 1000.0 - to disable timeout

//#define EXTRA_TASKS

enum {

	ACTION_SUM = 0,

	ACTION_SUB = 1,

	ACTION_MUL = 2,

	ACTION_DIV = 3,

  ACTIONS_COUNT = 4,

	MASK_SUM = 1 << ACTION_SUM,

	MASK_SUB = 1 << ACTION_SUB,

	MASK_MUL = 1 << ACTION_MUL,

	MASK_DIV = 1 << ACTION_DIV,

	MASK_ALL = ~0,

	TASKS_COUNT = 20,

	TASK_MODE_NONE = 0,

	TASK_MODE_ERROR = 1,

	TASK_MODE_TIMEOUT = 2,

	TASK_MODE_DONE = 3,

  MODE_MENU = 0,

  MODE_BEGIN = 1,

	MODE_PLAYING = 2,

	MODE_FINISHED = 3,

};

const char *signs[] = {"+", "-", "·", ":"};

typedef struct {

	char question[1024];

	char answer[1024];

	char userAnswer[1024];

	double time;

	int mode;

	double x, y, vx, vy;

} Task;

typedef struct {

  char name[1024];

	double time;

	int actions;

	int minA, maxA;

	int minB, maxB;

	int minC, maxC;

	int advanced;

} Level;

Level levels[] = {

	{ "Счёт до 10", 5*BASE_TIME, MASK_SUM | MASK_SUB,  1,  9,  1,  9,  2,  10, 0 },

	{ "Число 10",   3*BASE_TIME, MASK_SUM | MASK_SUB,  1,  9,  1,  9, 10,  10, 0 },

	{ "Сложение и вычитание однозначных чисел",

                  7*BASE_TIME, MASK_SUM | MASK_SUB,  1,  9,  1,  9,  2,  18, 0 },

	{ "Сложение и вычитание двузначных чисел",

                 20*BASE_TIME, MASK_SUM | MASK_SUB, 10, 99, 10, 99, 20, 100, 0 },

  {}, {}, {}, {}, {}, {}, {}, {}, // Умножение на 2..9

  #ifdef EXTRA_TASKS

  {}, {}, {}, {}, {}, {}, {}, {}, // Деление на 2..9

  {}, {}, {}, {}, {}, {}, {}, {}, // Умножение и деление на 2..9

  #endif

	{ "Умножение однозначных чисел",

                  8*BASE_TIME, MASK_MUL,             2,  9,  2,  9,  0, 100, 0 },

	{ "Деление однозначных чисел",

                 12*BASE_TIME, MASK_DIV,             2,  9,  2,  9,  0, 100, 0 },

	{ "Умножение и деление однозначных чисел",

	               12*BASE_TIME, MASK_MUL | MASK_DIV,  2,  9,  2,  9,  0, 100, 0 },

	{ "Умножение и деление больших чисел",

	               24*BASE_TIME, 0,                    0,  0,  0,  0,  0,   0, 1 }

};

int levelsCount = sizeof(levels)/sizeof(*levels);

int currentLevel = 0;

Task tasks[TASKS_COUNT];

int currentTask = 0;

int errorsCount = 0;

int timeoutsCount = 0;

double taskStartTime = 0;

int mode = MODE_MENU;

double regularSize = 18;

double bigSize = 24;

double lineSpace = 7;

double ladderStep = 18 + 5;

double ladderCurrent = 0;

double ladderTarget = 0;

double ladderSpeed = 5;

Sound soundBegin;

Sound soundWin;

void init() {

  background(colorByName("#4c4c4c"));

  soundBegin = createSoundFromMemory(data_sound_begin_ogg, data_sound_begin_ogg_len);

  soundWin = createSoundFromMemory(data_sound_win_ogg, data_sound_win_ogg_len);

  for(int i = 2; i < 10; ++i) {

    Level *level = &levels[4 + i - 2];

    sprintf(level->name, "Умножение на %d",i);

    level->time = 5*BASE_TIME;

    level->actions = MASK_MUL;

    level->minA = level->maxA = i;

    level->minB = 2; level->maxB = 9;

    level->minC = 0; level->maxC = 100;

    #ifdef EXTRA_TASKS

    Level *levelD = &levels[4 + 8 + i - 2];

    memcpy(levelD, level, sizeof(Level));

    sprintf(levelD->name, "Деление на %d",i);

    levelD->time = 7*BASE_TIME;

    levelD->actions = MASK_DIV;

    Level *levelMD = &levels[4 + 8 + 8 + i - 2];

    memcpy(levelMD, level, sizeof(Level));

    sprintf(levelMD->name, "Умножение и деление на %d",i);

    levelMD->time = 7*BASE_TIME;

    levelMD->actions = MASK_MUL | MASK_DIV;

    #endif

  }

}

void generateAdvancedTask(Level *level, Task *task) {

  memset(task, 0, sizeof(*task));

  int a = randomNumber(2, 20);

  int b = randomNumber(2, 10);

	if (randomNumber(0, 100) < 20) a *= 10;

	if (randomNumber(0, 100) < 20) b *= 10;

	if (a < 10 && b < 10) {

		if (randomNumber(0, 1))

      a *= 10; else b *= 10;

  }

  if (randomNumber(0, 1))

    { int x = a; a = b; b = x; }

	int c = a * b;

  if (randomNumber(0, 100) < 25) {

    sprintf(task->question, "%d %s %d = ", c, signs[ACTION_DIV], a);

    sprintf(task->answer, "%d", b);

	} else {

    sprintf(task->question, "%d %s %d = ", a, signs[ACTION_MUL], b);

    sprintf(task->answer, "%d", c);

	}

  task->time = level->time;

}

void generateTask(Level *level, Task *task) {

  if (level->advanced)

    { generateAdvancedTask(level, task); return; }

  memset(task, 0, sizeof(*task));

	int action = 0;

	while(1) {

    action = randomNumber(0, ACTIONS_COUNT-1);

    if (level->actions & (1 << action)) break;

	}

	int a = 0, b = 0, c = 0;

	while(1) {

    a = randomNumber(level->minA, level->maxA);

    b = randomNumber(level->minB, level->maxB);

		if (action == ACTION_SUM || action == ACTION_SUB)

			c = a + b; else c = a * b;

		if (c >= level->minC && c <= level->maxC)

			break;

  }

	if (randomNumber(0, 1))

    { int x = a; a = b; b = x; }

	if (action == ACTION_SUM || action == ACTION_MUL) {

    sprintf(task->question, "%d %s %d = ", a, signs[action], b);

    sprintf(task->answer, "%d", c);

	} else {

    sprintf(task->question, "%d %s %d = ", c, signs[action], a);

    sprintf(task->answer, "%d", b);

	}

  task->time = level->time;

}

void nextTask() {

  int remains = 0;

  for(int i = 0; i < TASKS_COUNT; ++i)

    if (tasks[i].mode != TASK_MODE_DONE) ++remains;

  if (!remains) {

    ladderTarget = -100;

    mode = MODE_FINISHED;

    soundPlay(soundWin, FALSE);

    return;

  }

  ladderTarget = remains - 1;

  while(1) {

    currentTask = randomNumber(0, TASKS_COUNT-1);

    if (tasks[currentTask].mode != TASK_MODE_DONE) break;

  }

  Task *task = &tasks[currentTask];

  task->userAnswer[0] = 0;

  task->mode = TASK_MODE_NONE;

  task->x = 0;

  task->y = (remains - 1)*ladderStep;

  task->vx = 0;

  task->vy = 0;

  taskStartTime = windowGetSeconds();

}

void verifyTask() {

  Task *task = &tasks[currentTask];

  if (strcmp(task->answer, task->userAnswer) != 0) {

    task->mode = TASK_MODE_ERROR;

    ++errorsCount;

  } else

  if (windowGetSeconds() - taskStartTime > task->time) {

    task->mode = TASK_MODE_TIMEOUT;

    ++timeoutsCount;

  } else {

    task->mode = TASK_MODE_DONE;

  }

  nextTask();

}

void drawTask(Task *task) {

  saveState();

  double dt = windowGetFrameTime();

  noFill();

  stroke(colorByName("white"));

  textSize(regularSize);

  if (task->mode == TASK_MODE_NONE) {

    if (task != &tasks[currentTask]) noStroke();

  } else

  if (task->mode == TASK_MODE_ERROR) {

    task->vy += 100*dt;

    stroke(colorByRGBA(1, 1, 1, 0.25));

  } else

  if (task->mode == TASK_MODE_TIMEOUT) {

    task->vx -= 20*dt;

    stroke(colorByRGBA(1, 1, 1, 0.25));

  }

  task->x += task->vx;

  task->y += task->vy;

  textf(task->x, task->y, "%s%s", task->question, task->userAnswer);

  restoreState();

}

void drawLadder() {

	double d = 5*windowGetFrameTime();

	if (fabs(ladderCurrent - ladderTarget) < d) {

		ladderCurrent = ladderTarget;

	} else

	if (ladderCurrent < ladderTarget) {

		ladderCurrent += d;

	} else {

		ladderCurrent -= d;

  }

  saveState();

  stroke(colorByName("white"));

  strokeWidth(1);

	double w = 30;

	int i0 = -100;

	int i1 = 300;

	for(int i = i0; i <= i1; ++i)

    line(-w, i*ladderStep, w, i*ladderStep);

  line(-w, i0*ladderStep, -w, i1*ladderStep);

  line( w, i0*ladderStep,  w, i1*ladderStep);

  double k = ladderStep;

	double iy = floor(ladderCurrent/2)*2;

	double py = ladderCurrent - iy;

	double ly = iy + (py < 1 ? py : 1)*2;

	double ry = iy + (py < 1 ? 0 : py-1)*2 + 1;

	double yy = (ly + ry)/2;

	strokeWidth(0.6*k);

	point(0, yy*k);

	strokeWidth(1);

	line(0, (yy+0.3)*k,  0, (yy+2)*k);

	line(0, (yy+0.7)*k, -k,     ly*k);

	line(0, (yy+0.7)*k,  k,     ry*k);

	line(0, (yy+2.0)*k, -k, (ly+3)*k);

	line(0, (yy+2.0)*k,  k, (ry+3)*k);

	restoreState();

}

void startLevel() {

  currentTask = 0;

  errorsCount = 0;

  timeoutsCount = 0;

  for(int i = 0; i < TASKS_COUNT; ++i)

    generateTask(&levels[currentLevel], &tasks[i]);

  ladderTarget = ladderCurrent = TASKS_COUNT - 1;

  mode = MODE_BEGIN;

  soundPlay(soundBegin, FALSE);

}

void drawLevel(int width, int height) {

  double t = windowGetSeconds();

  Level *level = &levels[currentLevel];

  saveState();

  noFill();

  stroke(colorByName("white"));

  textSize(regularSize);

  textf(0, 0, "Уровень %d", (currentLevel + 1));

  textSize(bigSize);

  text(0, regularSize + lineSpace, level->name);

  textSize(regularSize);

  textf(0, 80, "Ошибки: %d", errorsCount);

  textf(0, 80 + regularSize + lineSpace, "Промедления: %d", timeoutsCount);

  if (mode == MODE_BEGIN || mode == MODE_FINISHED) {

    textSize(bigSize);

    double alpha = (1 + cos(10*t))/4 + 0.5;

    stroke(colorByRGBA(1, 1, 1, alpha));

    textAlign(HALIGN_LEFT, VALIGN_BOTTOM);

    text(0, height, "Нажмите Enter...");

    textAlign(HALIGN_LEFT, VALIGN_TOP);

  }

  if (mode != MODE_BEGIN) {

    saveState();

    translate(width - 300, height - TASKS_COUNT*ladderStep);

    for(int i = 0; i < TASKS_COUNT; ++i)

      drawTask(&tasks[i]);

    restoreState();

  }

  saveState();

  translate(width - 30, height - TASKS_COUNT*ladderStep);

  drawLadder();

  restoreState();

  restoreState();

  if (keyWentDown("escape")) mode = MODE_MENU;

  if (mode == MODE_BEGIN) {

    if (keyWentDown("any return")) { mode = MODE_PLAYING; nextTask(); }

  } else

  if (mode == MODE_PLAYING) {

    Task *task = &tasks[currentTask];

    char *ua = task->userAnswer;

    int i = strlen(ua);

    if (i > 0 && keyWentDown("backspace")) ua[--i] = 0;

    if (i == 1 && *ua == '0') i = 0;

    int ii = i;

    if (i < 10 && keyWentDown("any 0")) ua[i++] = '0';

    if (i < 10 && keyWentDown("any 1")) ua[i++] = '1';

    if (i < 10 && keyWentDown("any 2")) ua[i++] = '2';

    if (i < 10 && keyWentDown("any 3")) ua[i++] = '3';

    if (i < 10 && keyWentDown("any 4")) ua[i++] = '4';

    if (i < 10 && keyWentDown("any 5")) ua[i++] = '5';

    if (i < 10 && keyWentDown("any 6")) ua[i++] = '6';

    if (i < 10 && keyWentDown("any 7")) ua[i++] = '7';

    if (i < 10 && keyWentDown("any 8")) ua[i++] = '8';

    if (i < 10 && keyWentDown("any 9")) ua[i++] = '9';

    if (i > ii) ua[i] = 0;

    if (keyWentDown("any return")) verifyTask();

  } else

  if (mode == MODE_FINISHED) {

    if (keyWentDown("any return")) {

      ++currentLevel;

      if (currentLevel >= levelsCount) {

        currentLevel = levelsCount - 1;

        mode = MODE_MENU;

      } else {

        startLevel();

      }

    }

  }

}

void drawMenu(int width, int height) {

  saveState();

  noFill();

  stroke(colorByName("white"));

  double scrollY = currentLevel*(regularSize+lineSpace) + bigSize + lineSpace - height;

  if (scrollY < 0) scrollY = 0;

  double y = -scrollY;

  for(int i = 0; i < levelsCount; ++i) {

    double size = i == currentLevel ? bigSize : regularSize;

    textSize(size);

    text(0, y, levels[i].name);

    y += size + lineSpace;

  }

  restoreState();

  if (keyWentDown("escape")) windowStop();

  if (keyWentDown("up"  )) --currentLevel;

  if (keyWentDown("down")) ++currentLevel;

  if (keyWentDown("home")) currentLevel = 0;

  if (keyWentDown("end" )) currentLevel = levelsCount - 1;

  if (currentLevel >= levelsCount) currentLevel = levelsCount - 1;

  if (currentLevel < 0) currentLevel = 0;

  if (keyWentDown("any return")) startLevel();

}

void draw() {

  saveState();

  translate(70, 50);

  int width  = windowGetWidth() - 70 - 70;

  int height = windowGetHeight() - 50 - 80;

  if (mode == MODE_MENU)

    drawMenu(width, height);

  else

    drawLevel(width, height);

  restoreState();

}

int main() {

  windowSetTitle("Arithm");

	windowSetVariableFrameRate();

	windowSetSize(1000, 700);

	windowSetInit(&init);

	windowSetDraw(&draw);

	windowRun();

	return 0;

}