#include <math.h>
#include <stdio.h>
#include <time.h>
#include <sys/time.h>
#include <cairo/cairo-pdf.h>
#include <X11/XKBlib.h>

#include "main.h"
#include "initcairo.h"
#include "triangle.h"
#include "linalg.h"

#define TOGGLE(a) do { (a) = !(a); } while(0)
#define SIGN(x) ((x) > 0 ? 1.0 : -1.0)

DrawingContext *screen_context;

// setup everything except cairo and dim, which will be provided by the graphics system
void setupContext(DrawingContext *ctx, int argc, char *argv[])
{
    ctx->n_group_elements = NUM_GROUP_ELEMENTS;
    ctx->n_group_elements_combinatorial = NUM_GROUP_ELEMENTS_COMBINATORIAL;
    ctx->p[0] = atoi(argv[1]);
    ctx->p[1] = atoi(argv[2]);
    ctx->p[2] = atoi(argv[3]);
    ctx->k[0] = atoi(argv[4]);
    ctx->k[1] = atoi(argv[5]);
    ctx->k[2] = atoi(argv[6]);
    if(argc > 7)
	ctx->parameter = atof(argv[7]);
    else
	ctx->parameter = 1.0;
    if(argc > 8)
	ctx->parameter2 = atof(argv[8]);
    else
	ctx->parameter2 = 1.0;
    if(argc > 12) {
	ctx->movie_filename = argv[9];
	ctx->movie_parameter_duration = atof(argv[10]);
	ctx->movie_parameter2_duration = atof(argv[11]);
	ctx->movie_n_frames = atoi(argv[12]);
    } else {
	ctx->movie_n_frames = 0;
    }
    //	ctx->parameter = 2.77;
    //	ctx->parameter = 0.1;
    ctx->show_boxes = 0;
    ctx->show_boxes2 = 0;
    ctx->show_attractors = 0;
    ctx->show_reflectors = 0;
    ctx->show_rotated_reflectors = 0;
    ctx->show_limit = 0;
    ctx->show_dual_limit = 0;
    ctx->show_text = 1;
    ctx->mode = 0;
    ctx->use_rotation_basis = 1;
    ctx->limit_with_lines = 0;
    ctx->use_repelling = 0;
    ctx->show_marking = 0;
    ctx->marking.x = -0.73679;
    ctx->marking.y = -0.01873;
    ctx->show_coxeter_orbit = 0;

    ctx->limit_curve = malloc(3*ctx->n_group_elements*sizeof(double));
    ctx->limit_curve_count = -1;

    ctx->group = malloc(ctx->n_group_elements_combinatorial*sizeof(groupelement_t));
    generate_triangle_group(ctx->group, ctx->n_group_elements_combinatorial, ctx->p[0], ctx->p[1], ctx->p[2]);

    // the temporary stuff
    ctx->cartan = gsl_matrix_alloc(3, 3);
    ctx->cob = gsl_matrix_alloc(3, 3);
    ctx->ws = workspace_alloc(3);
}

void destroyContext(DrawingContext *ctx)
{
    free(ctx->limit_curve);
    free(ctx->group);

    gsl_matrix_free(ctx->cartan);
    gsl_matrix_free(ctx->cob);

    workspace_free(ctx->ws);
}

void computeMatrix(DrawingContext *ctx, gsl_matrix *result, const char *type)
{
    gsl_matrix **gen = getTempMatrices(ctx->ws, 6);

    //	ERROR(strlen(type) != 2, "Invalid call of computeRotationMatrix()\n");

    initializeTriangleGeneratorsCurrent(gen, ctx);
    gsl_matrix_set_identity(result);
    for(int i = 0; i < strlen(type); i++) {
	if(type[i] >= 'a' && type[i] <= 'c')
	    multiply_right(result, gen[type[i]-'a'], ctx->ws);
	else if(type[i] >= 'A' && type[i] <= 'C')
	    multiply_right(result, gen[type[i]-'A'+3], ctx->ws);
    }

    releaseTempMatrices(ctx->ws, 6);
}

void computeRotationMatrixFrame(DrawingContext *ctx, gsl_matrix *result, const char *type)
{
    gsl_matrix *tmp = getTempMatrix(ctx->ws);
    computeMatrix(ctx, tmp, type);
    rotation_frame(tmp, result, ctx->ws);
    releaseTempMatrices(ctx->ws, 1);
}

void computeBoxTransform(DrawingContext *ctx, char *word1, char *word2, gsl_matrix *result)
{
    vector_t p[2][3],i[2];
    vector_t std[4] = {
	{-1, -1, 1},
	{-1, 1, 1},
	{1, 1, 1},
	{1, -1, 1}
    };

    gsl_vector **vertices = getTempVectors(ctx->ws, 4);
    gsl_vector **std_vertices = getTempVectors(ctx->ws, 4);
    gsl_matrix *tmp = getTempMatrix(ctx->ws);
    gsl_matrix *to_frame = getTempMatrix(ctx->ws);
    gsl_matrix *to_std_frame = getTempMatrix(ctx->ws);

    fixedPoints(ctx, word1, p[0]);
    fixedPoints(ctx, word2, p[1]);

    // intersect attracting line with neutral line of the other element
    for(int j = 0; j < 2; j++)
	i[j] = cross(cross(p[j%2][0],p[j%2][1]),cross(p[(j+1)%2][0],p[(j+1)%2][2]));

    // box consists of p[0][0], i[0], p[1][0], i[1]

    for(int i = 0; i < 4; i++)
	vectorToGsl(std[i], std_vertices[i]);

    vectorToGsl(p[0][0], vertices[0]);
    vectorToGsl(i[0],    vertices[1]);
    vectorToGsl(p[1][0], vertices[2]);
    vectorToGsl(i[1],    vertices[3]);

    projective_frame(std_vertices, to_std_frame, ctx->ws);
    projective_frame(vertices, to_frame, ctx->ws);
    invert(to_frame, tmp, ctx->ws);
    multiply(to_std_frame, tmp, result);

    /*
      LOOP(i) {
      LOOP(j) {
      printf("%.4f ", gsl_matrix_get(result, i, j));
      }
      printf("\n");
      }*/

    releaseTempVectors(ctx->ws, 8);
    releaseTempMatrices(ctx->ws, 3);
}

void updateMatrices(DrawingContext *ctx)
{
    double angle[3];
    LOOP(i) angle[i] = M_PI*ctx->k[i]/ctx->p[i];
    cartanMatrix(ctx->cartan, angle[0], angle[1], angle[2], ctx->parameter);

    gsl_matrix *tmp = getTempMatrix(ctx->ws);
    int nmodes = 5;

    if(ctx->use_rotation_basis % nmodes == 0) {
	gsl_matrix_set(tmp, 0, 0, 0.0);
	gsl_matrix_set(tmp, 0, 1, sqrt(3.0)/2.0);
	gsl_matrix_set(tmp, 0, 2, -sqrt(3.0)/2.0);
	gsl_matrix_set(tmp, 1, 0, 1.0);
	gsl_matrix_set(tmp, 1, 1, -0.5);
	gsl_matrix_set(tmp, 1, 2, -0.5);
	gsl_matrix_set(tmp, 2, 0, 1.0);
	gsl_matrix_set(tmp, 2, 1, 1.0);
	gsl_matrix_set(tmp, 2, 2, 1.0);
	gsl_matrix_memcpy(ctx->cob, tmp);
    } else if(ctx->use_rotation_basis % nmodes == 1) {
	gsl_matrix_set(tmp, 0, 0, 1.0);
	gsl_matrix_set(tmp, 0, 1, -1.0);
	gsl_matrix_set(tmp, 0, 2, 0.0);
	gsl_matrix_set(tmp, 1, 0, 1.0);
	gsl_matrix_set(tmp, 1, 1, 1.0);
	gsl_matrix_set(tmp, 1, 2, 0.0);
	gsl_matrix_set(tmp, 2, 0, 0.0);
	gsl_matrix_set(tmp, 2, 1, 0.0);
	gsl_matrix_set(tmp, 2, 2, 1.0);
	gsl_matrix_memcpy(ctx->cob, ctx->cartan); // is this a good choice of basis for any reason?
	multiply_left(tmp, ctx->cob, ctx->ws);
    } else if(ctx->use_rotation_basis % nmodes == 2) {
	computeRotationMatrixFrame(ctx, tmp, "C");
	invert(tmp, ctx->cob, ctx->ws);
    } else if(ctx->use_rotation_basis % nmodes == 3) {
	computeBoxTransform(ctx, "acb", "cba", ctx->cob);
	//		computeBoxTransform(ctx, "cab", "bca", ctx->cob);
	//		computeBoxTransform(ctx, "acb", "cba", ctx->cob);
    } else {
	cartanMatrix(tmp, M_PI/ctx->p[0], M_PI/ctx->p[1], M_PI/ctx->p[2], 1.0);
	diagonalize_symmetric_form(tmp, ctx->cob, ctx->ws);
    }

    releaseTempMatrices(ctx->ws, 1);
}

void output_info(DrawingContext *ctx)
{
    vector_t p[4][3];
    point_t pt;

    fixedPoints(ctx, "abc", p[0]);
    fixedPoints(ctx, "bca", p[1]);
    fixedPoints(ctx, "cab", p[2]);

    pt = vectorToPoint(ctx, p[0][0]);
    printf("(abc)-+ = (%f %f)\n", pt.x, pt.y);
    pt = vectorToPoint(ctx, p[1][0]);
    printf("(bca)-+ = (%f %f)\n", pt.x, pt.y);
}

void print(DrawingContext *screen)
{
    DrawingContext file;
    DimensionsInfo dim;
    cairo_surface_t *surface;

    char filename[100];
    time_t t = time(NULL);
    strftime(filename, sizeof(filename), "screenshot_%Y%m%d_%H%M%S.pdf", localtime(&t));

    memcpy(&file, screen, sizeof(file));

    dim.width = screen->dim->width;
    dim.height = screen->dim->width / sqrt(2.0);
    dim.matrix = screen->dim->matrix;
    dim.matrix.y0 += ((double)dim.height - (double)screen->dim->height) / 2.0; // recenter vertically
    updateDimensions(&dim);
    file.dim = &dim;

    surface = cairo_pdf_surface_create(filename, (double)dim.width, (double)dim.height);
    file.cairo = cairo_create(surface);

    draw(&file);

    cairo_destroy(file.cairo);
    cairo_surface_destroy(surface);

    printf("Wrote sceenshot to file: %s\n", filename);
}

int processEvent(GraphicsInfo *info, XEvent *ev)
{
    int state;
    unsigned long key;
    char filename[100];

    //	fprintf(stderr, "Event: %d\n", ev->type);

    switch(ev->type) {
    case ButtonPress:
	state = ev->xbutton.state & (ShiftMask | LockMask | ControlMask);

	if(ev->xbutton.button == 1 && state & ShiftMask) {
	    screen_context->marking.x = (double)ev->xbutton.x;
	    screen_context->marking.y = (double)ev->xbutton.y;
	    printf("mouse button pressed: %f, %f\n", screen_context->marking.x, screen_context->marking.y);
	    cairo_set_matrix(screen_context->cairo, &screen_context->dim->matrix);
	    cairo_device_to_user(screen_context->cairo, &screen_context->marking.x, &screen_context->marking.y);
	    printf("mouse button pressed transformed: %f, %f\n", screen_context->marking.x, screen_context->marking.y);
	    return STATUS_REDRAW;
	}
	break;

    case KeyPress:
	state = ev->xkey.state & (ShiftMask | LockMask | ControlMask);
	key = XkbKeycodeToKeysym(ev->xkey.display, ev->xkey.keycode, 0, !!(state & ShiftMask));
	printf("Key pressed: %ld\n", key);

	switch(key) {
	case XK_Down:
	    if(ev->xkey.state & ShiftMask)
		screen_context->parameter /= exp(0.00005);
	    else
		screen_context->parameter /= exp(0.002);
	    updateMatrices(screen_context);
	    computeLimitCurve(screen_context);
	    break;
	case XK_Up:
	    if(ev->xkey.state & ShiftMask)
		screen_context->parameter *= exp(0.00005);
	    else
		screen_context->parameter *= exp(0.002);
	    updateMatrices(screen_context);
	    computeLimitCurve(screen_context);
	    break;
	case XK_Left:
	    if(ev->xkey.state & ShiftMask)
		screen_context->parameter2 /= exp(0.00005);
	    else
		screen_context->parameter2 /= exp(0.002);
	    updateMatrices(screen_context);
	    computeLimitCurve(screen_context);
	    break;
	case XK_Right:
	    if(ev->xkey.state & ShiftMask)
		screen_context->parameter2 *= exp(0.00005);
	    else
		screen_context->parameter2 *= exp(0.002);
	    updateMatrices(screen_context);
	    computeLimitCurve(screen_context);
	    break;
	case XK_Page_Down:
	    screen_context->parameter /= exp(0.02);
	    updateMatrices(screen_context);
	    computeLimitCurve(screen_context);
	    break;
	case XK_Page_Up:
	    screen_context->parameter *= exp(0.02);
	    updateMatrices(screen_context);
	    computeLimitCurve(screen_context);
	    break;
	case ' ':
	    screen_context->parameter = 5.57959706;
	    updateMatrices(screen_context);
	    computeLimitCurve(screen_context);
	    break;
	case XK_Return:
	    //			screen_context->parameter = 2.76375163;
	    screen_context->parameter = 5.29063366;
	    updateMatrices(screen_context);
	    computeLimitCurve(screen_context);
	    break;
	case 'm':
	    printf("matrix.xx = %f;\n", info->dim->matrix.xx);
	    printf("matrix.xy = %f;\n", info->dim->matrix.xy);
	    printf("matrix.x0 = %f;\n", info->dim->matrix.x0);
	    printf("matrix.yx = %f;\n", info->dim->matrix.yx);
	    printf("matrix.yy = %f;\n", info->dim->matrix.yy);
	    printf("matrix.y0 = %f;\n", info->dim->matrix.y0);
	    break;
	case 'i':
	    output_info(screen_context);
	    break;
	case 'b':
	    TOGGLE(screen_context->show_boxes);
	    break;
	case 'B':
	    TOGGLE(screen_context->show_boxes2);
	    break;
	case 'a':
	    TOGGLE(screen_context->show_attractors);
	    break;
	case 'r':
	    TOGGLE(screen_context->show_reflectors);
	    break;
	case 'x':
	    TOGGLE(screen_context->show_rotated_reflectors);
	    break;
	case 'L':
	    TOGGLE(screen_context->limit_with_lines);
	    break;
	case 'l':
	    TOGGLE(screen_context->show_limit);
	    break;
	case 'd':
	    TOGGLE(screen_context->show_dual_limit);
	    break;
	case 'R':
	    screen_context->use_rotation_basis++;
	    updateMatrices(screen_context);
	    computeLimitCurve(screen_context);
	    break;
	case 'p':
	    print(screen_context);
	    break;
	case 'M':
	    screen_context->limit_with_lines = 0;
	    double parameter_start = screen_context->parameter;
	    double parameter2_start = screen_context->parameter2;
	    for(int i = 0; i <= screen_context->movie_n_frames; i++) {
		screen_context->parameter = SIGN(parameter_start)*exp(log(fabs(parameter_start)) +
						i*screen_context->movie_parameter_duration/screen_context->movie_n_frames);
		screen_context->parameter2 = SIGN(parameter2_start)*exp(log(fabs(parameter2_start)) +
						 i*screen_context->movie_parameter2_duration/screen_context->movie_n_frames);
		updateMatrices(screen_context);
		computeLimitCurve(screen_context);
		draw(screen_context);
		sprintf(filename, "output/%s%03d.png", screen_context->movie_filename, i);
		cairo_surface_write_to_png(info->buffer_surface, filename);
		printf("Finished drawing %s\n", filename);
	    }

	case 'f':
	    TOGGLE(screen_context->use_repelling);
	    computeLimitCurve(screen_context);
	    break;
	case 't':
	    TOGGLE(screen_context->show_text);
	    break;
	case 'c':
	    TOGGLE(screen_context->show_coxeter_orbit);
	    break;
	case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '0':
	    screen_context->mode = key - '0';
	    break;
	}

	return STATUS_REDRAW;
    }

    return STATUS_NOTHING;
}

int main(int argc, char *argv[])
{
    GraphicsInfo *info;

    screen_context = malloc(sizeof(DrawingContext));
    setupContext(screen_context, argc, argv);
    updateMatrices(screen_context);
    computeLimitCurve(screen_context);

    info = initCairo(0, KeyPressMask, 200, 200, "Triangle group");
    if(!info)
	return 1;

    /*
      info->dim->matrix.xx = 274.573171;
      info->dim->matrix.xy = 0.000000;
      info->dim->matrix.x0 = 583.073462;
      info->dim->matrix.yx = 0.000000;
      info->dim->matrix.yy = 274.573171;
      info->dim->matrix.y0 = 777.225293;
    */

    info->dim->matrix.xx = 274.573171;
    info->dim->matrix.xy = 0.000000;
    info->dim->matrix.x0 = 910.073462;
    info->dim->matrix.yx = 0.000000;
    info->dim->matrix.yy = 274.573171;
    info->dim->matrix.y0 = 509.225293;

    updateDimensions(info->dim);

    screen_context->dim = info->dim;
    screen_context->cairo = info->buffer_context;

    startTimer(info);

    while(1) {
	int result = checkEvents(info, processEvent, NULL);
	if(result == STATUS_QUIT)
	    return 0;
	else if(result == STATUS_REDRAW) {
	    struct timeval current_time;
	    double start_time, intermediate_time, end_time;
	    gettimeofday(&current_time, 0);
	    start_time = current_time.tv_sec + current_time.tv_usec*1e-6;

	    draw(screen_context);

	    gettimeofday(&current_time, 0);
	    intermediate_time = current_time.tv_sec + current_time.tv_usec*1e-6;

	    cairo_set_source_surface(info->front_context, info->buffer_surface, 0, 0);
	    cairo_paint(info->front_context);

	    gettimeofday(&current_time, 0);
	    end_time = current_time.tv_sec + current_time.tv_usec*1e-6;
	    printf("drawing finished in %.2f milliseconds, of which %.2f milliseconds were buffer switching\n", (end_time - start_time) * 1000, (end_time - intermediate_time) * 1000);
	}
	waitUpdateTimer(info);
    }

    free(screen_context);
    destroyCairo(info);
    destroyContext(screen_context);

    return 0;
}