/* 
Compile with:
gcc xmirror.c -o a -L../lib -L/usr/X11R6/lib -lnr -lm -lX11
*/


#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include <limits.h>
#include <assert.h>  
#include <unistd.h>  
#include <time.h>
#include <X11/Xlib.h>
/* Every Xlib program must include this */
#include <X11/X10.h>

#include "../util/nr.h"
#include "../util/nrutil.h"
#include "../util/matutl6.c"

#define DISP_W 600
#define DISP_H 600
#define BEAM_W 0.004
#define EPS 1.0e-10
#define NIL 0

typedef struct vec {
  double x, y;
} vec;

typedef struct mirror {
  vec  a,b,normal;
} mirror;

Display *dpy;
Window w;
GC gc;
int blackColor,whiteColor,redColor,glassColor;

void Xinit_display(void)
{
  /* Open the display */
  dpy = XOpenDisplay(NIL);
  assert(dpy);
  /* Get some colors */
  blackColor = BlackPixel(dpy, DefaultScreen(dpy));
  whiteColor = WhitePixel(dpy, DefaultScreen(dpy));
  glassColor = 0xfff;
  redColor = 0xff000;

  /* Create the window */
  w= XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0, 0, 
	     DISP_W, DISP_H, 0, blackColor,blackColor);
  /* We want to get MapNotify events */
  XSelectInput(dpy, w, StructureNotifyMask);
  /* "Map" the window (that is, make it appear on the screen) */
  XMapWindow(dpy, w);
  /* Create a "Graphics Context" */
  gc = XCreateGC(dpy, w, 0, NIL);
  /* Tell the GC we draw using the white color */

  XSetForeground(dpy, gc, whiteColor);

  /* Wait for the MapNotify event */

  for(;;) {
    XEvent e;
    XNextEvent(dpy, &e);
    if (e.type == MapNotify)
    break;
  }
}

void Xdraw_mirrors(mirror *m, int mirrors)
{
  int i,j,corr;
  vec p;
  float t,mirror_w=BEAM_W*2.0;
  corr=(int)((mirror_w*DISP_W)/2.0);

  XSetForeground(dpy, gc, glassColor);

  for(j=0;j<mirrors;j++)
  {
  
    for(i=0;i<=1000;i++)   
    {
      t=(float)i*0.001;
      p.x= t*m[j].b.x + (1.0-t)*m[j].a.x;
      p.y= t*m[j].b.y + (1.0-t)*m[j].a.y;
      p.y= 1.0-p.y;
      XFillArc(dpy,w,gc,(int)(p.x*DISP_W)-corr,
        (int)(p.y*DISP_W)-corr,(int)(mirror_w*DISP_W),
        (int)(mirror_w*DISP_W),0,23040);
      XFlush(dpy);
    } 
  }
}

void Xlaser_beam(vec a, vec b)
{
  int i,corr;
  vec p;
  float t;
  corr=(int)((BEAM_W*DISP_W)/2.0);
  XSetForeground(dpy, gc, redColor);

  for(i=0;i<=1000;i++)   
  {
    t=(float)i*0.001;
    p.x= t*b.x + (1.0-t)*a.x;
    p.y= t*b.y + (1.0-t)*a.y;
    p.y= 1.0 - p.y;
    XFillArc(dpy,w,gc,(int)(p.x*DISP_W)-corr,
      (int)(p.y*DISP_W)-corr,(int)(BEAM_W*DISP_W),
      (int)(BEAM_W*DISP_W),0,23040);
    XFlush(dpy);
    wait();
  } 
}

void init_mirrors(mirror *m, int mirrors)
{
  int i;
  vec a,b;
  a.x=0.0; a.y=0.0; b.x=0.0; b.y=0.0;

  init_srand();

  m[0].a.x = 1.0; m[0].a.y=1.0; m[0].b.x=1.0; m[0].b.y=0.0;
  m[1].a.x = 0.0; m[1].a.y=0.0; m[1].b.x=0.0; m[1].b.y=1.0;
  m[2].a.x = 0.0; m[2].a.y=0.0; m[2].b.x=1.0; m[2].b.y=0.0;

  for (i=3;i<mirrors;i++)
  {
    while(((b.x-a.x)*(b.x-a.x)+(b.y-a.y)*(b.y-a.y))<0.1)
    {
      a.x=rdm(0.0,1.0);
      a.y=rdm(0.0,1.0);
      b.x=rdm(0.0,1.0);
      b.y=rdm(0.0,1.0);
    }
    m[i].a=a;
    m[i].b=b;
    a.x=0.0; a.y=0.0; b.x=0.0; b.y=0.0;
  }
}

void get_mirrors(mirror *m, int mirrors)
{
  float **a;
  char *tied="mirrors.dat";
  int i;
  long b=4, mm=(long)mirrors;
  a=getmat(&b,&mm,tied);
  showmat(a,b,mm);

  for (i=0;i<mirrors;i++)
  {
    m[i].a.x=(double)a[i+1][1];
    m[i].a.y=(double)a[i+1][2];
    m[i].b.x=(double)a[i+1][3];
    m[i].b.y=(double)a[i+1][4];
  }
  free_matrix(a,1,mirrors,1,4);
}

void get_normal(mirror *m, int mirrors)
{
  int i;
  double x,y;

  for (i=0;i<mirrors;i++)
  {
    y=(m[i].b.x-m[i].a.x);
    x=-(m[i].b.y-m[i].a.y);

    m[i].normal.x=x/sqrt(x*x+y*y);
    m[i].normal.y=y/sqrt(x*x+y*y);

  }
}

int test_flash(mirror m, vec v, vec u)
{
  double temp;
  temp = (v.x*(m.a.y-u.y) - v.y*(m.a.x-u.x));
  temp*= (v.x*(m.b.y-u.y) - v.y*(m.b.x-u.x));
  if (temp < 0) return 1;
  else return 0;
}

double flashpoint(mirror m, vec v, vec u)
{
  double t=0.0;

  if (test_flash(m,v,u))
  { 
    t = (m.a.x-u.x)*(m.b.y-m.a.y) - (m.a.y-u.y)*(m.b.x-m.a.x);
    t/= (v.x)*(m.b.y-m.a.y) - (v.y)*(m.b.x-m.a.x);
  } 
  return t;
}

int main(void)
{
  vec v, u;
  int i,i_min,j,mirrors=8;
  double t,d,t_min;

  vec temp;
  mirror *m = malloc(48*mirrors);

  temp.x=0.0;temp.y=0.0;
  u.x=0.0; u.y=0.0;  /* Sateen alkupisteen koordinaatit */
  v.x=1.0; v.y=0.5;  /* - " -  - " - suuntavektori */
  d=sqrt(v.x*v.x+v.y*v.y);
  v.x/=d;
  v.y/=d;

  Xinit_display();

/*  init_mirrors(m,mirrors); */  /* Sijoittaa satunnaisia peilejä */
  get_mirrors(m,mirrors);    /* Hakee peilit tiedostosta */
  
  Xdraw_mirrors(m,mirrors);
  get_normal(m,mirrors);

  while ((temp.x>=0.0-EPS) && (temp.x<=1.0+EPS) && (temp.y>=0.0-EPS) &&
(temp.y<=1.0+EPS))
  {
    i_min=-1; t_min=sqrt(2.0);

    temp=u;
    for (i=0;i<mirrors;i++)
    {
      t=flashpoint(m[i],v,u);

      if ((t<t_min) && (t>EPS)) { 
        t_min=t;
        i_min=i;
      }
    }

    if (i_min >=0) 
    {
      u.x += t_min*v.x;
      u.y += t_min*v.y;
      d = v.x*m[i_min].normal.x + v.y*m[i_min].normal.y;
      v.x -= 2*d*m[i_min].normal.x;
      v.y -= 2*d*m[i_min].normal.y;
    }
    else 
    {
      u.x += t_min*v.x;
      u.y += t_min*v.y;
      Xlaser_beam(temp,u);
      break;
    }
    Xlaser_beam(temp,u);
  }

  getchar();
  
  free(m);
  return 0;
}