#include <math.h>

#include <stdlib.h>

#include <time.h>

#include <gtk/gtk.h>

#define BALLS_COUNT 5

const double pi = 3.141592653589793;

const double g = 100.0;

const guint interval_ms = 10;

typedef struct {

  double x, y, vx, vy, ax, ay, r, m;

} Ball;

Ball balls[BALLS_COUNT];

double ring_x = 500.0;

double ring_y = 500.0;

GtkWidget *window;

double ring_normalize(double a, double ring_size) {

  if (!ring_size) return a;

  return a - ring_size*floor(a/ring_size);

}

double ring_delta(double a, double b, double ring_size) {

  if (!ring_size) return a - b;

  double delta = ring_normalize(a - b, ring_size);

  if (delta > ring_size/2) delta -= ring_size;

  return delta;

}

gboolean timeout(gpointer data) {

  // draw do 100 frames per seconds (see interval_ms)

  // and 1000 calculation cycles per each frame

  double dt = (double)interval_ms/1000.0/1000.0;

  for(int t = 0; t < 1000; ++t) {

    // reset accelerations

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

      balls[i].ax = 0;

      balls[i].ay = 0;

    }

    // accumulate accelerations and detect collisions

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

      for(int j = i+1; j < BALLS_COUNT; ++j) {

        double dx = ring_delta(balls[j].x, balls[i].x, ring_x);

        double dy = ring_delta(balls[j].y, balls[i].y, ring_y);

        double d = sqrt(dx*dx + dy*dy);

        double nx = dx/d;

        double ny = dy/d;

        if (d > balls[i].r + balls[j].r) {

          // balls don't touches, just apply gravity acceleration

          double ax = g*balls[i].m*balls[j].m*nx/(d*d);

          double ay = g*balls[i].m*balls[j].m*ny/(d*d);

          balls[i].ax = balls[i].ax + ax;

          balls[i].ay = balls[i].ay + ay;

          balls[j].ax = balls[j].ax - ax;

          balls[j].ay = balls[j].ay - ay;

        } else {

          // collision detected

          double dvx = balls[j].vx - balls[i].vx;

          double dvy = balls[j].vy - balls[i].vy;

          double dv = dvx*nx + dvy*ny;

          if (dv < 0) {

            // calc velocities after ricochet, if balls still flies towards each other

            double v0 =  2.0*dv*balls[j].m/(balls[i].m + balls[j].m);

            double v1 = -2.0*dv*balls[i].m/(balls[i].m + balls[j].m);

            balls[i].vx = balls[i].vx + v0*nx;

            balls[i].vy = balls[i].vy + v0*ny;

            balls[j].vx = balls[j].vx + v1*nx;

            balls[j].vy = balls[j].vy + v1*ny;

          }

        }

      }

    }

    // apply accelerations

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

      balls[i].vx = balls[i].vx + balls[i].ax*dt/balls[i].m;

      balls[i].vy = balls[i].vy + balls[i].ay*dt/balls[i].m;

      balls[i].x = ring_normalize(balls[i].x + balls[i].vx*dt, ring_x);

      balls[i].y = ring_normalize(balls[i].y + balls[i].vy*dt, ring_y);

    }

  }

  gtk_widget_queue_draw(window);

  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);

  cairo_set_line_width(cr, 1.0);

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

    double r = balls[i].r;

    for(int j = -1; j <= 1; ++j) {

      for(int k = -1; k <= 1; ++k) {

        double x = balls[i].x + ring_x*j;

        double y = balls[i].y + ring_y*k;

        cairo_arc(cr, x, y, r, 0, 2*pi);

        cairo_stroke(cr);

      }

    }

  }

  return TRUE;

}

void activate(GtkApplication* app, gpointer data) {

  srand(time(NULL));

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

    double r = 10.0 + 30.0*(rand()/(double)(RAND_MAX));

    balls[i].x = ring_x*rand()/(double)(RAND_MAX);

    balls[i].y = ring_y*rand()/(double)(RAND_MAX);

    balls[i].vx = 0.0;

    balls[i].vy = 0.0;

    balls[i].r = r;

    balls[i].m = r*r*r;

  }

  window = gtk_application_window_new (app);

  g_signal_connect(window, "draw", G_CALLBACK(draw), NULL);

  gtk_window_set_default_size(GTK_WINDOW(window), (int)ring_x, (int)ring_y);

  gtk_widget_show_all(window);

  g_timeout_add(interval_ms, timeout, NULL);

}

int main(int argc, char **argv) {

  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);

  return status;

}