/* tronbit, Copyright (c) 2011-2014 Jamie Zawinski <jwz@jwz.org>
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation.  No representations are made about the suitability of this
 * software for any purpose.  It is provided "as is" without express or 
 * implied warranty.
 */

#define DEFAULTS	"*delay:	30000       \n" \
			"*count:        30          \n" \
			"*showFPS:      False       \n" \
			"*wireframe:    False       \n"

# define release_bit 0
#undef countof
#define countof(x) (sizeof((x))/sizeof((*x)))

#include "xlockmore.h"
#include "colors.h"
#include "sphere.h"
#include "rotator.h"
#include "gltrackball.h"
#include <ctype.h>

#ifdef USE_GL /* whole file */

#include "gllist.h"

extern const struct gllist *tronbit_idle1, *tronbit_idle2,
  *tronbit_no, *tronbit_yes;
static const struct gllist * const *all_objs[] = {
  &tronbit_idle1, &tronbit_idle2, &tronbit_no, &tronbit_yes };


#define DEF_SPIN        "True"
#define DEF_WANDER      "True"
#define DEF_SPEED       "1.0"

#define HISTORY_LENGTH 512
typedef enum { BIT_IDLE1, BIT_IDLE2, BIT_NO, BIT_YES } bit_state;
#define MODELS 4


typedef struct {
  GLXContext *glx_context;
  rotator *rot;
  trackball_state *trackball;
  Bool button_down_p;

  double frequency;
  double confidence;

  double last_time;
  unsigned char history   [HISTORY_LENGTH];
  unsigned char histogram [HISTORY_LENGTH];
  int history_fp, histogram_fp;

  GLuint dlists[MODELS], polys[MODELS];
  char kbd;

} bit_configuration;

static bit_configuration *bps = NULL;

static const GLfloat colors[][4] = {
  { 0.66, 0.85, 1.00, 1.00 },
  { 0.66, 0.85, 1.00, 1.00 },
  { 1.00, 0.12, 0.12, 1.00 },
  { 0.98, 0.85, 0.30, 1.00 }
};


static Bool do_spin;
static GLfloat speed;
static Bool do_wander;

static XrmOptionDescRec opts[] = {
  { "-spin",   ".spin",   XrmoptionNoArg, "True" },
  { "+spin",   ".spin",   XrmoptionNoArg, "False" },
  { "-speed",  ".speed",  XrmoptionSepArg, 0 },
  { "-wander", ".wander", XrmoptionNoArg, "True" },
  { "+wander", ".wander", XrmoptionNoArg, "False" }
};

static argtype vars[] = {
  {&do_spin,   "spin",   "Spin",   DEF_SPIN,   t_Bool},
  {&do_wander, "wander", "Wander", DEF_WANDER, t_Bool},
  {&speed,     "speed",  "Speed",  DEF_SPEED,  t_Float},
};

ENTRYPOINT ModeSpecOpt bit_opts = {countof(opts), opts, countof(vars), vars, NULL};


/* Returns the current time in seconds as a double.
 */
static double
double_time (void)
{
  struct timeval now;
# ifdef GETTIMEOFDAY_TWO_ARGS
  struct timezone tzp;
  gettimeofday(&now, &tzp);
# else
  gettimeofday(&now);
# endif

  return (now.tv_sec + ((double) now.tv_usec * 0.000001));
}


static int
make_bit (ModeInfo *mi, bit_state which)
{
  static const GLfloat spec[4] = {1.0, 1.0, 1.0, 1.0};
  static const GLfloat shiny   = 128.0;
  const GLfloat *color = colors[which];
  int wire = MI_IS_WIREFRAME(mi);
  int polys = 0;
  GLfloat s;
  const struct gllist *gll;

  glMaterialfv (GL_FRONT, GL_SPECULAR,            spec);
  glMateriali  (GL_FRONT, GL_SHININESS,           shiny);
  glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, color);
  glColor4f (color[0], color[1], color[2], color[3]);

  glPushMatrix();
  switch (which)
    {
    case BIT_IDLE1:
      glRotatef (-44, 0, 1, 0);   /* line up the models with each other */
      glRotatef (-11, 1, 0, 0);
      glRotatef (  8, 0, 0, 1);
      s = 1.0;
      break;
    case BIT_IDLE2:
      glRotatef ( 16.0, 0, 0, 1);
      glRotatef (-28.0, 1, 0, 0);
      s = 1.0;
      break;
    case BIT_NO:
      glRotatef ( 16.0, 0, 0, 1);
      glRotatef (-28.0, 1, 0, 0);
      s = 1.6;
      break;
    case BIT_YES:
      glRotatef (-44.0, 0, 1, 0);
      glRotatef (-32.0, 1, 0, 0);
      s = 1.53;
      break;
    default:
      abort();
      break;
    }
  glScalef (s, s, s);
  gll = *all_objs[which];
  renderList (gll, wire);
  polys += gll->points / 3;
  glPopMatrix();

  return polys;
}


static void
tick_bit (ModeInfo *mi, double now)
{
  bit_configuration *bp = &bps[MI_SCREEN(mi)];
  double freq = bp->frequency;
  int n = bp->history[bp->history_fp];
  int histogram_speed = 3 * speed;
  int i;

  if (histogram_speed < 1) histogram_speed = 1;

  if (n == BIT_YES || n == BIT_NO)
    freq *= 2;

  if (bp->button_down_p) return;

  for (i = 0; i < histogram_speed; i++)
    {
      int nn = (n == BIT_YES ? 240 : n == BIT_NO  ? 17 : 128);
      int on = bp->histogram[(bp->histogram_fp-1) % countof(bp->histogram)];

      /* smooth out the square wave a little bit */

      if (!(nn > 100 && nn < 200) !=
          !(on > 100 && on < 200))
        nn += (((random() % 48) - 32) *
               ((on > 100 && on < 200) ? 1 : -1));

      nn += (random() % 16) - 8;

      bp->histogram_fp++;
      if (bp->histogram_fp >= countof(bp->history))
        bp->histogram_fp = 0;
      bp->histogram [bp->histogram_fp] = nn;
    }


  if (bp->last_time + freq > now && !bp->kbd) return;

  bp->last_time = now;

  bp->history_fp++;
  if (bp->history_fp >= countof(bp->history))
    bp->history_fp = 0;

  if (bp->kbd)
    {
      n = (bp->kbd == '1' ? BIT_YES :
           bp->kbd == '0' ? BIT_NO :
           (random() & 1) ? BIT_YES : BIT_NO);
      bp->kbd = 0;
    }
  else if (n == BIT_YES || 
           n == BIT_NO ||
           frand(1.0) >= bp->confidence)
    n = (n == BIT_IDLE1 ? BIT_IDLE2 : BIT_IDLE1);
  else
    n = (random() & 1) ? BIT_YES : BIT_NO;

  bp->history [bp->history_fp] = n;
}


static int
animate_bits (ModeInfo *mi, bit_state omodel, bit_state nmodel, GLfloat ratio)
{
  bit_configuration *bp = &bps[MI_SCREEN(mi)];
  int polys = 0;
  GLfloat scale = sin (ratio * M_PI / 2);
  GLfloat osize, nsize, small;
  int wire = MI_IS_WIREFRAME(mi);

  glShadeModel(GL_SMOOTH);

  glEnable(GL_DEPTH_TEST);
  glEnable(GL_NORMALIZE);
  glEnable(GL_CULL_FACE);

  if (!wire)
    {
      glEnable(GL_LIGHTING);
      glEnable(GL_DEPTH_TEST);
      glEnable(GL_CULL_FACE);
    }

 if ((omodel == BIT_IDLE1 || omodel == BIT_IDLE2) &&
     (nmodel == BIT_IDLE1 || nmodel == BIT_IDLE2))
   small = 0.9;
 else
   small = 0.5;

  nsize = small + (1 - small) * scale;
  osize = small + (1 - small) * (1 - scale);

  glPushMatrix();
  glScalef (osize, osize, osize);
  glCallList (bp->dlists [omodel]);
  polys += bp->polys [omodel];
  glPopMatrix();

  glPushMatrix();
  glScalef (nsize, nsize, nsize);
  glCallList (bp->dlists [nmodel]);
  polys += bp->polys [nmodel];
  glPopMatrix();

  return polys;
}


static int
draw_histogram (ModeInfo *mi, GLfloat ratio)
{
  bit_configuration *bp = &bps[MI_SCREEN(mi)];
  int samples = countof (bp->histogram);
  GLfloat scalex = (GLfloat) mi->xgwa.width / samples;
  GLfloat scaley = mi->xgwa.height / 255.0 / 4;  /* about 1/4th of screen */
  int polys = 0;
  int overlays = 5;
  int k;
  
  glDisable (GL_TEXTURE_2D);
  glDisable (GL_LIGHTING);
  glDisable (GL_BLEND);
  glDisable (GL_DEPTH_TEST);
  glDisable (GL_CULL_FACE);

  glMatrixMode(GL_PROJECTION);
  glPushMatrix();
  {
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();

    glLoadIdentity();
    /* glRotatef(current_device_rotation(), 0, 0, 1); */
    glOrtho (0, mi->xgwa.width, 0, mi->xgwa.height, -1, 1);

    for (k = 0; k < overlays; k++)
      {
        int i, j;
        GLfloat a = (GLfloat) k / overlays;

        glColor3f (0.3 * a, 0.7 * a, 1.0 * a);

        glBegin (GL_LINE_STRIP);

        j = bp->histogram_fp + 1;
        for (i = 0; i < samples; i++)
          {
            GLfloat x, y, z;
            if (j >= samples) j = 0;
            x = i;
            y = bp->histogram[j];
            z = 0;

            y += (int) ((random() % 16) - 8);
            y += 16;  /* margin at bottom of screen */

            x *= scalex;
            y *= scaley;

            glVertex3f (x, y, z);
            ++j;
            polys++;
          }
        glEnd();
      }

    glPopMatrix();
  }
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();

  glMatrixMode(GL_MODELVIEW);

  return polys;
}


/* Window management, etc
 */
ENTRYPOINT void
reshape_bit (ModeInfo *mi, int width, int height)
{
  GLfloat h = (GLfloat) height / (GLfloat) width;

  glViewport (0, 0, (GLint) width, (GLint) height);

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective (30.0, 1/h, 1.0, 100.0);

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  gluLookAt( 0.0, 0.0, 30.0,
             0.0, 0.0, 0.0,
             0.0, 1.0, 0.0);

  glClear(GL_COLOR_BUFFER_BIT);
}



ENTRYPOINT Bool
bit_handle_event (ModeInfo *mi, XEvent *event)
{
  bit_configuration *bp = &bps[MI_SCREEN(mi)];

  if (gltrackball_event_handler (event, bp->trackball,
                                 MI_WIDTH (mi), MI_HEIGHT (mi),
                                 &bp->button_down_p))
    return True;
  else if (event->xany.type == KeyPress)
    {
      KeySym keysym;
      char c = 0;
      XLookupString (&event->xkey, &c, 1, &keysym, 0);

      if (keysym == XK_Up || keysym == XK_Left || keysym == XK_Prior)
        c = '1';
      else if (keysym == XK_Down || keysym == XK_Right || keysym == XK_Next)
        c = '0';

      if (c == ' ' || c == '\t' || c == '\n' || c == '1' || c == '0')
        {
          bp->kbd = c;
          return True;
        }
    }

  return False;
}


ENTRYPOINT void 
init_bit (ModeInfo *mi)
{
  bit_configuration *bp;
  int i;

  MI_INIT (mi, bps);

  bp = &bps[MI_SCREEN(mi)];

  bp->glx_context = init_GL(mi);

  reshape_bit (mi, MI_WIDTH(mi), MI_HEIGHT(mi));

  {
    double spin_speed   = 3.0;
    double wander_speed = 0.03 * speed;
    double spin_accel   = 4.0;

    bp->rot = make_rotator (do_spin ? spin_speed : 0,
                            do_spin ? spin_speed : 0,
                            do_spin ? spin_speed : 0,
                            spin_accel,
                            do_wander ? wander_speed : 0,
                            False);
    bp->trackball = gltrackball_init (False);
  }

  for (i = 0; i < countof(bp->dlists); i++)
    {
      bp->dlists[i] = glGenLists (1);
      glNewList (bp->dlists[i], GL_COMPILE);
      bp->polys [i] = make_bit (mi, i);
      glEndList ();
    }

  bp->frequency  = 0.30 / speed;	/* parity around 3x/second */
  bp->confidence = 0.06;		/* provide answer 1/15 or so */

  for (i = 0; i < countof(bp->histogram); i++)
    bp->histogram[i] = 128 + (random() % 16) - 8;
}


ENTRYPOINT void
draw_bit (ModeInfo *mi)
{
  bit_configuration *bp = &bps[MI_SCREEN(mi)];
  Display *dpy = MI_DISPLAY(mi);
  Window window = MI_WINDOW(mi);
  int wire = MI_IS_WIREFRAME(mi);

  if (!bp->glx_context)
    return;

  glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *bp->glx_context);

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  if (!wire)
    {
      GLfloat pos[4] = {1.0, 1.0, 1.0, 0.0};
      GLfloat amb[4] = {0.0, 0.0, 0.0, 1.0};
      GLfloat dif[4] = {1.0, 1.0, 1.0, 1.0};
      GLfloat spc[4] = {0.0, 1.0, 1.0, 1.0};

      glEnable(GL_LIGHTING);
      glEnable(GL_LIGHT0);
      glLightfv(GL_LIGHT0, GL_POSITION, pos);
      glLightfv(GL_LIGHT0, GL_AMBIENT,  amb);
      glLightfv(GL_LIGHT0, GL_DIFFUSE,  dif);
      glLightfv(GL_LIGHT0, GL_SPECULAR, spc);
    }

  glPushMatrix ();
  glScalef(1.1, 1.1, 1.1);

# ifdef HAVE_MOBILE	/* Keep it the same relative size when rotated. */
  {
    GLfloat h = MI_HEIGHT(mi) / (GLfloat) MI_WIDTH(mi);
    int o = (int) current_device_rotation();
    if (o != 0 && o != 180 && o != -180)
      glScalef (1/h, 1/h, 1/h);
    glRotatef(o, 0, 0, 1);
  }
# endif

  {
    double x, y, z;
    get_position (bp->rot, &x, &y, &z, !bp->button_down_p);
    glTranslatef((x - 0.5) * 11,
                 (y - 0.5) * 5,
                 (z - 0.5) * 3);
    gltrackball_rotate (bp->trackball);

    get_rotation (bp->rot, &x, &y, &z, !bp->button_down_p);
    glRotatef (x * 360, 1.0, 0.0, 0.0);
    glRotatef (y * 360, 0.0, 1.0, 0.0);
    glRotatef (z * 360, 0.0, 0.0, 1.0);
  }

  mi->polygon_count = 0;

  glScalef (6, 6, 6);

  {
    int nmodel = bp->history [bp->history_fp];
    int omodel = bp->history [bp->history_fp > 0
                              ? bp->history_fp-1
                              : countof(bp->history)-1];
    double now = double_time();
    double ratio = 1 - ((bp->last_time + bp->frequency) - now) / bp->frequency;
    if (ratio > 1) ratio = 1;
    mi->polygon_count += draw_histogram (mi, ratio);

    if (MI_WIDTH(mi) > MI_HEIGHT(mi) * 5) {   /* wide window: scale up */
      glScalef (8, 8, 8);
    }

    mi->polygon_count += animate_bits (mi, omodel, nmodel, ratio);
    tick_bit (mi, now);
  }
  glPopMatrix ();

  if (mi->fps_p) do_fps (mi);
  glFinish();

  glXSwapBuffers(dpy, window);
}


ENTRYPOINT void
free_bit (ModeInfo *mi)
{
  bit_configuration *bp = &bps[MI_SCREEN(mi)];
  int i;

  if (!bp->glx_context) return;
  glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *bp->glx_context);

  if (bp->trackball) gltrackball_free (bp->trackball);
  if (bp->rot) free_rotator (bp->rot);
  for (i = 0; i < countof(bp->dlists); i++)
    if (glIsList(bp->dlists[i])) glDeleteLists(bp->dlists[i], 1);

}

XSCREENSAVER_MODULE_2 ("TronBit", tronbit, bit)

#endif /* USE_GL */