#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#include <math.h>
#include <gtk/gtk.h>


#define COUNT 10

const double speed = 10.0;
const double jump = 40.0;
const double gravity = 2.0;
  
typedef struct {
  double left;
  double top;
  double right;
  double bottom;
} Block;

cairo_surface_t *surface;
GtkWidget *window;
Block blocks[COUNT];
gboolean left_key = FALSE;
gboolean right_key = FALSE;
double px = 0.0;
double py = 0.0;
double vx = 0.0;
double vy = 0.0;
double score = 0.0;
double max_score = 0.0;


void generate_block(Block *block, double top) {
  double window_width = gtk_widget_get_allocated_width(window);
  double width = ((double)rand()/(double)RAND_MAX + 1.0) * window_width / 6.0;
  block->left   = (double)rand()/(double)RAND_MAX * (window_width - width);
  block->right  = block->left + width;
  block->top    = top;
  block->bottom = block->top + 10;
}

void generate_blocks() {
  srand(time(NULL));
  double window_height = gtk_widget_get_allocated_height(window);
  for(int i = 0; i < COUNT; ++i)
    generate_block(&blocks[i], window_height);
}

void scroll_blocks(double dy) {
  double window_height = gtk_widget_get_allocated_height(window);
  score += dy;
  if (score > max_score) max_score = score;
  py += dy;
  for(int i = 0; i < COUNT; ++i) {
    blocks[i].top    += dy;
    blocks[i].bottom += dy;
    if (blocks[i].top < 0) {
      generate_block(&blocks[i], window_height + (double)rand()/(double)RAND_MAX*fabs(dy));
    } else
    if (blocks[i].top > window_height) {
      generate_block(&blocks[i], -10.0 - (double)rand()/(double)RAND_MAX*fabs(dy));
    }
  }
}

gboolean timeout(gpointer data) {
  double window_height = gtk_widget_get_allocated_height(window);

  vy += gravity;

  if (left_key) px -= speed;
  if (right_key) px += speed;

  if (vy > 0.0) {
    gboolean found = FALSE;
    double top = py + vy;
    for(int i = 0; i < COUNT; ++i) {
      if ( px >= blocks[i].left
        && px <= blocks[i].right
        && blocks[i].top >= py
        && blocks[i].top <= top )
      {
        found = TRUE;
        top = blocks[i].top;
      }
    }
    if (found) {
      py = top;
      vy = -jump;
    } else {
      py += vy;
    }
  } else {
    py += vy;
  }

  scroll_blocks(window_height/2.0 - py);

  gtk_widget_queue_draw(window);
  return TRUE;
}

gboolean key_press(GtkWidget *widget, GdkEventKey *event, gpointer data) {
  if (event->keyval == GDK_KEY_Left) left_key = TRUE;
  if (event->keyval == GDK_KEY_Right) right_key = TRUE;
  if (event->keyval == GDK_KEY_space) generate_blocks();
  return TRUE;
}

gboolean key_release(GtkWidget *widget, GdkEventKey *event, gpointer data) {
  if (event->keyval == GDK_KEY_Left) left_key = FALSE;
  if (event->keyval == GDK_KEY_Right) right_key = FALSE;
  return TRUE;
}

gboolean draw(GtkWidget *widget, cairo_t *cr, gpointer data) {
  cairo_set_source_rgba(cr, 0.9, 0.9, 0.9, 1);
  cairo_paint(cr);

  cairo_set_source_rgba(cr, 0, 0, 0, 1);
  for(int i = 0; i < COUNT; ++i) {
    cairo_rectangle(
      cr,
      blocks[i].left,
      blocks[i].top,
      blocks[i].right - blocks[i].left,
      blocks[i].bottom - blocks[i].top );
    cairo_fill(cr);
  }
  
  cairo_set_source_surface(
    cr,
    surface,
    px - cairo_image_surface_get_width(surface)/2.0,
    py - cairo_image_surface_get_height(surface) );
  cairo_paint(cr);

  cairo_set_source_rgba(cr, 0, 0, 0, 1);
  cairo_set_font_size(cr, 15);
  char text[1024];
  sprintf(text, "Score: %.0f", score);
  cairo_move_to(cr, 10, 30);
  cairo_show_text(cr, text);
  sprintf(text, "Max score: %.0f", max_score);
  cairo_move_to(cr, 10, 50);
  cairo_show_text(cr, text);
  
  return TRUE;
}

void activate(GtkApplication* app, gpointer data) {
  window = gtk_application_window_new(app);
  g_signal_connect(window, "draw", G_CALLBACK(draw), NULL);
  g_signal_connect(window, "key-press-event", G_CALLBACK(key_press), NULL);
  g_signal_connect(window, "key-release-event", G_CALLBACK(key_release), NULL);
  gtk_widget_add_events(window, GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
  gtk_window_set_default_size(GTK_WINDOW(window), 800, 500);
  gtk_widget_show_all(window);

  generate_blocks();
  px = (blocks[0].left + blocks[0].right) / 2;
  py = blocks[0].top;
  
  g_timeout_add(50, timeout, NULL);
}

int main(int argc, char **argv) {
  surface = cairo_image_surface_create_from_png("ghost.png");
  
  GtkApplication *application = gtk_application_new(NULL, 0);
  g_signal_connect(application, "activate", G_CALLBACK(activate), NULL);
  int status = g_application_run(G_APPLICATION(application), argc, argv);
  g_object_unref(application);
  
  cairo_surface_destroy(surface);
  return status;
}