/** \file
 * \brief GLVal control
 *
 * See Copyright Notice in "iup.h"
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#include "iup.h"
#include "iupcbs.h"
#include "iupglcontrols.h"

#include "iup_object.h"
#include "iup_attrib.h"
#include "iup_str.h"
#include "iup_register.h"

#include "iup_glcontrols.h"
#include "iup_glfont.h"
#include "iup_gldraw.h"
#include "iup_glimage.h"
#include "iup_glsubcanvas.h"


typedef struct _iGLVal
{
  double value;  /* min<=value<max */
  double vmin;
  double vmax;
} iGLVal;


static void iGLValGetHandlerSize(Ihandle* ih, int is_horizontal, int *width, int *height)
{
  char *image = iupAttribGet(ih, "IMAGE");
  if (image)
    iupGLImageGetInfo(image, width, height, NULL);
  else
  {
    int handler_size = iupAttribGetInt(ih, "HANDLERSIZE");

    if (is_horizontal)
    {
      if (handler_size == 0)
        handler_size = ih->currentheight / 2;

      *width = handler_size;
      *height = ih->currentheight;
    }
    else
    {
      if (handler_size == 0)
        handler_size = ih->currentwidth / 2;

      *width = ih->currentwidth;
      *height = handler_size;
    }
  }
}

static int iGLValACTION_CB(Ihandle* ih)
{
  iGLVal* val = (iGLVal*)iupAttribGet(ih, "_IUP_GLVAL");
  float bwidth = iupAttribGetFloat(ih, "BORDERWIDTH");
  char* bordercolor = iupAttribGetStr(ih, "BORDERCOLOR");
  int active = iupAttribGetInt(ih, "ACTIVE");
  char* bgcolor = iupAttribGetStr(ih, "BGCOLOR");
  int slider_size = iupAttribGetInt(ih, "SLIDERSIZE");
  int border_width = (int)ceil(bwidth);
  int is_horizontal = iupStrEqualNoCase(iupAttribGetStr(ih, "ORIENTATION"), "HORIZONTAL");
  int handler_width, handler_height;
  char *image = iupAttribGet(ih, "IMAGE");
  char* bgimage = iupAttribGet(ih, "BACKIMAGE");
  double percent = (val->value - val->vmin) / (val->vmax - val->vmin);
  int x1, y1, x2, y2;

  iGLValGetHandlerSize(ih, is_horizontal, &handler_width, &handler_height);

  if (is_horizontal)
  {
    x1 = handler_width / 2;
    x2 = ih->currentwidth - 1 - handler_width / 2;
    y1 = (ih->currentheight - slider_size) / 2;
    y2 = y1 + slider_size;
  }
  else
  {
    y1 = handler_height / 2;
    y2 = ih->currentheight - 1 - handler_height / 2;
    x1 = (ih->currentwidth - slider_size) / 2;
    x2 = x1 + slider_size;
  }

  /* draw slider background */
  if (bgimage)
    iupGLDrawIconImageZoom(ih, border_width, border_width,
                           border_width, border_width,
                           "BACKIMAGE", bgimage, active);
  else
  {
    iupGLDrawBox(ih, x1 + border_width, x2 - border_width,
                     y1 + border_width, y2 - border_width, 
                     bgcolor, 1);  /* always active */

    /* draw slider border - can be disabled setting bwidth=0 */
    iupGLDrawRect(ih, x1, x2, y1, y2, bwidth, bordercolor, active, 0);
  }

  if (is_horizontal)
  {
    int xmid = x1 + iupRound((x2 - x1) * percent);

    x1 = xmid - handler_width / 2;  if (x1 < 0) x1 = 0;
    x2 = xmid + handler_width / 2;  if (x2 > ih->currentwidth - 1) x2 = ih->currentwidth - 1;
    y1 = 0;
    y2 = ih->currentheight - 1;
  }
  else
  {
    int ymid = y1 + iupRound((y2 - y1) * (1.0 - percent));

    y1 = ymid - handler_height / 2;  if (y1 < 0) y1 = 0;
    y2 = ymid + handler_height / 2;  if (y2 > ih->currentheight - 1) y2 = ih->currentheight - 1;
    x1 = 0;
    x2 = ih->currentwidth - 1;
  }

  if (image)
  {
    int x, y, width, height;
    iupGLImageGetInfo(image, &width, &height, NULL);

    /* always center the image */
    x = (x2 - x1 + 1 - width) / 2;
    y = (y2 - y1 + 1 - height) / 2;

    if (x1 + x < 0) x = 0;
    if (y1 + y < 0) y = 0;
    if (x1 + x + width > ih->currentwidth - 1) x = ih->currentwidth - 1 - width - x1;
    if (y1 + y + height > ih->currentheight - 1) y = ih->currentheight - 1 - height - y1;

    iupGLDrawIconImage(ih, x1 + x, y1 + y, "IMAGE", image, active);
  }
  else
  {
    int pressed = iupAttribGetInt(ih, "PRESSED");
    int highlight = iupAttribGetInt(ih, "HIGHLIGHT");
    char* fgcolor = iupAttribGetStr(ih, "FGCOLOR");

    if (pressed)
    {
      char* presscolor = iupAttribGetStr(ih, "PSCOLOR");
      if (presscolor)
        fgcolor = presscolor;
    }
    else if (highlight)
    {
      char* hlcolor = iupAttribGetStr(ih, "HLCOLOR");
      if (hlcolor)
        fgcolor = hlcolor;
    }

    /* draw handler foreground */
    iupGLDrawBox(ih, x1 + border_width, x2 - border_width, y1 + border_width, y2 - border_width, fgcolor, active);

    /* draw handler border - can still be disabled setting bwidth=0
       after the background because of the round rect */
    iupGLDrawRect(ih, x1, x2, y1, y2, bwidth, bordercolor, active, 1);
  }

  return IUP_DEFAULT;
}

static void iGLValCropValue(iGLVal* val)
{
  if (val->value>val->vmax)
    val->value = val->vmax;
  else if (val->value<val->vmin)
    val->value = val->vmin;
}

static int iGLValGetSliderInfo(Ihandle* ih, int dx, int dy, int is_horizontal, int *p, int *p1, int *p2, int *handler_op_size)
{
  int handler_width, handler_height;
  iGLValGetHandlerSize(ih, is_horizontal, &handler_width, &handler_height);

  if (is_horizontal)
  {
    *p1 = handler_width / 2;
    *p2 = ih->currentwidth - 1 - handler_width / 2;
    *p = dx;
    if (handler_op_size) *handler_op_size = handler_height;
    return handler_width;
  }
  else
  {
    *p1 = handler_height / 2;
    *p2 = ih->currentheight - 1 - handler_height / 2;
    *p = dy;
    if (handler_op_size) *handler_op_size = handler_width;
    return handler_height;
  }
}

static void iGLValGetSliderOpositeInfo(Ihandle* ih, int dx, int dy, int is_horizontal, int *q, int *op_size)
{
  if (is_horizontal)
  {
    *op_size = ih->currentheight;
    *q = dy;
  }
  else
  {
    *op_size = ih->currentwidth;
    *q = dx;
  }
}

static int iGLValMoveHandler(Ihandle* ih, int dx, int dy)
{
  iGLVal* val = (iGLVal*)iupAttribGet(ih, "_IUP_GLVAL");
  int is_horizontal = iupStrEqualNoCase(iupAttribGetStr(ih, "ORIENTATION"), "HORIZONTAL");
  double percent, old_percent, delta;
  int dp, p1, p2;

  iGLValGetSliderInfo(ih, dx, dy, is_horizontal, &dp, &p1, &p2, NULL);

  if (dp == 0)
    return 0;

  old_percent = percent = (val->value - val->vmin) / (val->vmax - val->vmin);

  delta = (double)dp / (double)(p2 - p1);
  if (!is_horizontal) delta *= -1.0;

  percent += delta;
  if (percent < 0.0) percent = 0;
  if (percent > 1.0) percent = 1.0;

  if (old_percent == percent)
    return 0;

  val->value = percent * (val->vmax - val->vmin) + val->vmin;
  return 1;
}

static int iGLValIsInsideHandler(Ihandle* ih, int x, int y)
{
  iGLVal* val = (iGLVal*)iupAttribGet(ih, "_IUP_GLVAL");
  int is_horizontal = iupStrEqualNoCase(iupAttribGetStr(ih, "ORIENTATION"), "HORIZONTAL");
  double percent;
  int p, p1, p2, pmid, handler_op_size;

  int handler_size = iGLValGetSliderInfo(ih, x, y, is_horizontal, &p, &p1, &p2, &handler_op_size);

  percent = (val->value - val->vmin) / (val->vmax - val->vmin);
  if (!is_horizontal)
    percent = 1.0 - percent;
  pmid = p1 + iupRound((p2 - p1) * percent);

  p1 = pmid - handler_size / 2;
  p2 = pmid + handler_size / 2;

  if (p >= p1 && p <= p2)
  {
    int q, q1, q2, qmid, op_size;

    iGLValGetSliderOpositeInfo(ih, x, y, is_horizontal, &q, &op_size);

    qmid = op_size / 2;
    q1 = qmid - handler_op_size / 2;
    q2 = qmid + handler_op_size / 2;

    if (q >= q1 && q <= q2)
      return 1;
    else
      return 0;
  }
  else
    return 0;
}

static int iGLValBUTTON_CB(Ihandle* ih, int button, int pressed, int x, int y, char* status)
{
  if (button == IUP_BUTTON1)
  {
    if (pressed)
    {
      if (!iGLValIsInsideHandler(ih, x, y))
        iupAttribSet(ih, "PRESSED", NULL);
      else
      {
        iupAttribSetInt(ih, "_IUP_GLVAL_START_X", x);
        iupAttribSetInt(ih, "_IUP_GLVAL_START_Y", y);
      }
    }
    else
    {
      if (iupAttribGet(ih, "_IUP_GLVAL_DRAG"))
      {
        IFni cb = (IFni)IupGetCallback(ih, "VALUECHANGING_CB");
        if (cb) cb(ih, 0);

        iupAttribSet(ih, "_IUP_GLVAL_DRAG", NULL);
      }
    }

    iupGLSubCanvasRedraw(ih);
  }

  (void)status;
  return IUP_DEFAULT;
}

static int iGLValMOTION_CB(Ihandle* ih, int x, int y, char* status)
{
  int redraw = 0;
  int pressed = iupAttribGetInt(ih, "PRESSED");

  /* special highlight processing for handler area */
  if (iGLValIsInsideHandler(ih, x, y))
  {
    if (!iupAttribGet(ih, "HIGHLIGHT"))
    {
      redraw = 1;
      iupAttribSet(ih, "HIGHLIGHT", "1");
    }
  }
  else
  {
    if (iupAttribGet(ih, "HIGHLIGHT"))
    {
      redraw = 1;
      iupAttribSet(ih, "HIGHLIGHT", NULL);
    }
  }

  if (pressed)
  {
    int start_x = iupAttribGetInt(ih, "_IUP_GLVAL_START_X");
    int start_y = iupAttribGetInt(ih, "_IUP_GLVAL_START_Y");

    if (iGLValMoveHandler(ih, x - start_x, y - start_y))
    {
      iupGLSubCanvasRedraw(ih);
      redraw = 0;

      if (!iupAttribGet(ih, "_IUP_GLVAL_DRAG"))
      {
        IFni cb = (IFni)IupGetCallback(ih, "VALUECHANGING_CB");
        if (cb) cb(ih, 1);
      }

      iupBaseCallValueChangedCb(ih);

      iupAttribSet(ih, "_IUP_GLVAL_DRAG", "1");
    }

    iupAttribSetInt(ih, "_IUP_GLVAL_START_X", x);
    iupAttribSetInt(ih, "_IUP_GLVAL_START_Y", y);
  }

  if (redraw)
    iupGLSubCanvasRedraw(ih);

  (void)status;
  return IUP_DEFAULT;
}

static int iGLValENTERWINDOW_CB(Ihandle* ih, int x, int y)
{
  /* special highlight processing for handler area */
  if (iGLValIsInsideHandler(ih, x, y))
    iupAttribSet(ih, "HIGHLIGHT", "1");
  else
    iupAttribSet(ih, "HIGHLIGHT", NULL);

  return iupGLSubCanvasRedraw(ih);
}

static int iGLValSetValueAttrib(Ihandle* ih, const char* value)
{
  iGLVal* val = (iGLVal*)iupAttribGet(ih, "_IUP_GLVAL");
  if (iupStrToDouble(value, &(val->value)))
    iGLValCropValue(val);
  return 0; /* do not store value in hash table */
}

static char* iGLValGetValueAttrib(Ihandle* ih)
{
  iGLVal* val = (iGLVal*)iupAttribGet(ih, "_IUP_GLVAL");
  return iupStrReturnDouble(val->value);
}

static int iGLValSetMinAttrib(Ihandle* ih, const char* value)
{
  iGLVal* val = (iGLVal*)iupAttribGet(ih, "_IUP_GLVAL");
  if (iupStrToDouble(value, &(val->vmin)))
    iGLValCropValue(val);
  return 0; /* do not store value in hash table */
}

static char* iGLValGetMinAttrib(Ihandle* ih)
{
  iGLVal* val = (iGLVal*)iupAttribGet(ih, "_IUP_GLVAL");
  return iupStrReturnDouble(val->vmin);
}

static int iGLValSetMaxAttrib(Ihandle* ih, const char* value)
{
  iGLVal* val = (iGLVal*)iupAttribGet(ih, "_IUP_GLVAL");
  if (iupStrToDouble(value, &(val->vmax)))
    iGLValCropValue(val);
  return 0; /* do not store value in hash table */
}

static char* iGLValGetMaxAttrib(Ihandle* ih)
{
  iGLVal* val = (iGLVal*)iupAttribGet(ih, "_IUP_GLVAL");
  return iupStrReturnDouble(val->vmax);
}

static void iGLValComputeNaturalSizeMethod(Ihandle* ih, int *w, int *h, int *children_expand)
{
  int natural_w = 0,
      natural_h = 0;
  int fit2backimage = iupAttribGetBoolean(ih, "FITTOBACKIMAGE");
  char* bgimage = iupAttribGet(ih, "BACKIMAGE");

  if (fit2backimage && bgimage)
  {
    iupAttribSet(ih, "BORDERWIDTH", "0");
    iupGLImageGetInfo(bgimage, &natural_w, &natural_h, NULL);
  }
  else
  {
    int charwidth, charheight;
    int is_horizontal = iupStrEqualNoCase(iupAttribGetStr(ih, "ORIENTATION"), "HORIZONTAL");

    iupGLFontGetCharSize(ih, &charwidth, &charheight);

    if (is_horizontal)
    {
      natural_h = charheight;
      if (ih->userwidth <= 0)
        natural_w = 15 * charwidth;
    }
    else
    {
      natural_w = charheight;
      if (ih->userheight <= 0)
        natural_h = 15 * charwidth;
    }
  }

  *w = natural_w;
  *h = natural_h;

  (void)children_expand; /* unset if not a container */
}

static int iGLValCreateMethod(Ihandle* ih, void **params)
{
  iGLVal* val = (iGLVal*)malloc(sizeof(iGLVal));
  iupAttribSet(ih, "_IUP_GLVAL", (char*)val);

  memset(val, 0, sizeof(iGLVal));

  /* default values */
  val->vmax = 1;

  IupSetCallback(ih, "GL_ACTION", (Icallback)iGLValACTION_CB);
  IupSetCallback(ih, "GL_BUTTON_CB", (Icallback)iGLValBUTTON_CB);
  IupSetCallback(ih, "GL_MOTION_CB", (Icallback)iGLValMOTION_CB);
  IupSetCallback(ih, "GL_LEAVEWINDOW_CB", iupGLSubCanvasRedraw);
  IupSetCallback(ih, "GL_ENTERWINDOW_CB", (Icallback)iGLValENTERWINDOW_CB);

  (void)params;
  return IUP_NOERROR;
}

static void iGLValDestroyMethod(Ihandle* ih)
{
  iGLVal* val = (iGLVal*)iupAttribGet(ih, "_IUP_GLVAL");
  free(val);
}

Iclass* iupGLValNewClass(void)
{
  Iclass* ic = iupClassNew(iupRegisterFindClass("glsubcanvas"));

  ic->name = "glval";
  ic->cons = "GLVal";
  ic->format = NULL; /* no parameters */
  ic->nativetype = IUP_TYPEVOID;
  ic->childtype = IUP_CHILDNONE;
  ic->is_interactive = 0;

  /* Class functions */
  ic->New = iupGLValNewClass;
  ic->Create  = iGLValCreateMethod;
  ic->Destroy = iGLValDestroyMethod;
  ic->ComputeNaturalSize = iGLValComputeNaturalSizeMethod;

  /* Callbacks */
  iupClassRegisterCallback(ic, "VALUECHANGED_CB", "");
  iupClassRegisterCallback(ic, "VALUECHANGING_CB", "i");

  /* IupGLVal only */
  iupClassRegisterAttribute(ic, "MIN", iGLValGetMinAttrib, iGLValSetMinAttrib, IUPAF_SAMEASSYSTEM, "0", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "MAX", iGLValGetMaxAttrib, iGLValSetMaxAttrib, IUPAF_SAMEASSYSTEM, "1", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "VALUE", iGLValGetValueAttrib, iGLValSetValueAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "ORIENTATION", NULL, NULL, IUPAF_SAMEASSYSTEM, "HORIZONTAL", IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "SLIDERSIZE", NULL, NULL, IUPAF_SAMEASSYSTEM, "5", IUPAF_NO_INHERIT);

  iupClassRegisterAttribute(ic, "FGCOLOR", NULL, NULL, IUPAF_SAMEASSYSTEM, "200 225 245", IUPAF_DEFAULT);  /* inheritable */
  iupClassRegisterAttribute(ic, "HLCOLOR", NULL, NULL, IUPAF_SAMEASSYSTEM, "190 210 230", IUPAF_DEFAULT);  /* inheritable */
  iupClassRegisterAttribute(ic, "HANDLERSIZE", NULL, NULL, IUPAF_SAMEASSYSTEM, "0", IUPAF_NO_INHERIT);

  iupClassRegisterAttribute(ic, "IMAGE", NULL, NULL, NULL, NULL, IUPAF_IHANDLENAME | IUPAF_NO_DEFAULTVALUE | IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "IMAGEPRESS", NULL, NULL, NULL, NULL, IUPAF_IHANDLENAME | IUPAF_NO_DEFAULTVALUE | IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "IMAGEHIGHLIGHT", NULL, NULL, NULL, NULL, IUPAF_IHANDLENAME | IUPAF_NO_DEFAULTVALUE | IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "IMAGEINACTIVE", NULL, NULL, NULL, NULL, IUPAF_IHANDLENAME | IUPAF_NO_DEFAULTVALUE | IUPAF_NO_INHERIT);

  iupClassRegisterAttribute(ic, "BACKIMAGE", NULL, NULL, NULL, NULL, IUPAF_IHANDLENAME | IUPAF_NO_DEFAULTVALUE | IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "BACKIMAGEPRESS", NULL, NULL, NULL, NULL, IUPAF_IHANDLENAME | IUPAF_NO_DEFAULTVALUE | IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "BACKIMAGEHIGHLIGHT", NULL, NULL, NULL, NULL, IUPAF_IHANDLENAME | IUPAF_NO_DEFAULTVALUE | IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "BACKIMAGEINACTIVE", NULL, NULL, NULL, NULL, IUPAF_IHANDLENAME | IUPAF_NO_DEFAULTVALUE | IUPAF_NO_INHERIT);
  iupClassRegisterAttribute(ic, "FITTOBACKIMAGE", NULL, NULL, NULL, NULL, IUPAF_NO_INHERIT);

  return ic;
}

Ihandle* IupGLVal(void)
{
  return IupCreate("glval");
}