#include <GL/glui.h>

#define X 0
#define Y 1
#define Z 2

extern void setCamera();
extern void reset();

extern float rightShoulderAngle;
extern float leftShoulderAngle;
extern float rightElbowAngle;
extern float leftElbowAngle;
extern float headTurnAngle;
extern float headTiltAngle;
extern float rightLegAngle;
extern float leftLegAngle;
extern float rightKneeAngle;
extern float leftKneeAngle;

extern float eye[3];
extern float ref[3];
extern float up[3];

extern float leftX,rightX,bottomY,topY,nearZ,farZ;


GLUI *robotUI = NULL;
GLUI *cameraUI = NULL;

GLUI_Spinner *rightShoulderSpinner;
GLUI_Spinner *leftShoulderSpinner;
GLUI_Spinner *rightElbowSpinner;
GLUI_Spinner *leftElbowSpinner;
GLUI_Spinner *headTurnSpinner;
GLUI_Spinner *headTiltSpinner;
GLUI_Spinner *rightLegSpinner;
GLUI_Spinner *leftLegSpinner;
GLUI_Spinner *rightKneeSpinner;
GLUI_Spinner *leftKneeSpinner;

GLUI_Spinner *eyeXSpinner;
GLUI_Spinner *eyeYSpinner;
GLUI_Spinner *eyeZSpinner;
GLUI_Spinner *upXSpinner;
GLUI_Spinner *upYSpinner;
GLUI_Spinner *upZSpinner;
GLUI_Spinner *refXSpinner;
GLUI_Spinner *refYSpinner;
GLUI_Spinner *refZSpinner;

GLUI_Spinner *leftXSpinner;
GLUI_Spinner *rightXSpinner;
GLUI_Spinner *bottomYSpinner;
GLUI_Spinner *topYSpinner;
GLUI_Spinner *nearZSpinner;
GLUI_Spinner *farZSpinner;

enum {RIGHT_SHOULDER,RIGHT_ELBOW,
      LEFT_SHOULDER,LEFT_ELBOW,
      HEAD_TURN,HEAD_TILT,
      RIGHT_LEG,RIGHT_KNEE,
      LEFT_LEG,LEFT_KNEE,
	  RESET,QUIT,
      EYE_X,EYE_Y,EYE_Z,
      REF_X,REF_Y,REF_Z,
      UP_X,UP_Y,UP_Z,
      LEFT_X,RIGHT_X,
      BOTTOM_Y,TOP_Y,
      NEAR_Z,FAR_Z};

///////////////////////////////////////////////////////////
//
// Tell the UI's variables that the corresponding
// variables in the program have changed.
//
///////////////////////////////////////////////////////////


void syncVars() {
  if (robotUI != NULL) {
    rightShoulderSpinner->set_float_val(rightShoulderAngle);
    leftShoulderSpinner->set_float_val(leftShoulderAngle);
    rightElbowSpinner->set_float_val(rightElbowAngle);
    leftElbowSpinner->set_float_val(leftElbowAngle);
    headTurnSpinner->set_float_val(headTurnAngle);
    headTiltSpinner->set_float_val(headTiltAngle);
    rightLegSpinner->set_float_val(rightLegAngle);
    leftLegSpinner->set_float_val(leftLegAngle);
    rightKneeSpinner->set_float_val(rightKneeAngle);
    leftKneeSpinner->set_float_val(leftKneeAngle);

    eyeXSpinner->set_float_val(eye[X]);
    eyeYSpinner->set_float_val(eye[Y]);
    eyeZSpinner->set_float_val(eye[Z]);
    upXSpinner->set_float_val(up[X]);
    upYSpinner->set_float_val(up[Y]);
    upZSpinner->set_float_val(up[Z]);
    refXSpinner->set_float_val(ref[X]);
    refYSpinner->set_float_val(ref[Y]);
    refZSpinner->set_float_val(ref[Z]);

    leftXSpinner->set_float_val(leftX);
    rightXSpinner->set_float_val(rightX);
    bottomYSpinner->set_float_val(bottomY);
    topYSpinner->set_float_val(topY);
    nearZSpinner->set_float_val(nearZ);
    farZSpinner->set_float_val(farZ);
  }
}

///////////////////////////////////////////////////////////
//
// This is called when the user interacts with a
// widget on the user interface (UI).
// The ID parameter identifies which widget was affected.
//
///////////////////////////////////////////////////////////

void handleGLUIEvent( int ID ) {
  switch (ID) {

  case RESET:
    reset();
    setCamera();
    syncVars();
    glutPostRedisplay();
    break;

  case QUIT:
    exit(0);

  case RIGHT_X:
  case LEFT_X:
  case BOTTOM_Y:
  case TOP_Y:
  case NEAR_Z:
  case FAR_Z:
	setCamera();
	glutPostRedisplay();
	break;

  default:
    glutPostRedisplay();
    break;

  }
}


///////////////////////////////////////////////////////////
//
// Set up the graphical user interface (UI),
// Which includes two checkboxes, two spinners,
// and two buttons.
//
///////////////////////////////////////////////////////////

void setupUI (int mainWindowID) {
  robotUI = GLUI_Master.create_glui( "Robot Controls", 0 );

  headTurnSpinner = robotUI->add_spinner("Head Turn",
                    GLUI_SPINNER_FLOAT, &headTurnAngle,
					HEAD_TURN, handleGLUIEvent );
  headTurnSpinner->set_float_limits(-90, 90 , GLUI_LIMIT_CLAMP);

  headTiltSpinner = robotUI->add_spinner("Head Tilt",
                    GLUI_SPINNER_FLOAT, &headTiltAngle,
					HEAD_TILT, handleGLUIEvent );
  headTiltSpinner->set_float_limits(-45, 45 , GLUI_LIMIT_CLAMP);

  robotUI->add_separator();

  leftShoulderSpinner =	robotUI->add_spinner("Left Shoulder",
                    GLUI_SPINNER_FLOAT, &leftShoulderAngle,
					LEFT_SHOULDER, handleGLUIEvent );
  leftShoulderSpinner->set_float_limits(0,135 , GLUI_LIMIT_CLAMP);

  leftElbowSpinner = robotUI->add_spinner("Left Elbow",
					GLUI_SPINNER_FLOAT, &leftElbowAngle,
					LEFT_SHOULDER, handleGLUIEvent );
  leftElbowSpinner->set_float_limits(0, 90 , GLUI_LIMIT_CLAMP);

  robotUI->add_separator();

  rightShoulderSpinner = robotUI->add_spinner("Right Shoulder",
                    GLUI_SPINNER_FLOAT, &rightShoulderAngle,
					RIGHT_SHOULDER, handleGLUIEvent );
  rightShoulderSpinner->set_float_limits(0,135 , GLUI_LIMIT_CLAMP);

  rightElbowSpinner = robotUI->add_spinner("Right Elbow",
                    GLUI_SPINNER_FLOAT, &rightElbowAngle,
					RIGHT_ELBOW, handleGLUIEvent );
  rightElbowSpinner->set_float_limits(0, 90 , GLUI_LIMIT_CLAMP);


  robotUI->add_separator();

  leftLegSpinner = robotUI->add_spinner("Left Leg",
                    GLUI_SPINNER_FLOAT, &leftLegAngle,
					LEFT_LEG, handleGLUIEvent );
  leftLegSpinner->set_float_limits(0,90 , GLUI_LIMIT_CLAMP);

  leftKneeSpinner = robotUI->add_spinner("Left Knee",
					GLUI_SPINNER_FLOAT, &leftKneeAngle,
					LEFT_LEG, handleGLUIEvent );
  leftKneeSpinner->set_float_limits(0, 90 , GLUI_LIMIT_CLAMP);

  robotUI->add_separator();

  rightLegSpinner = robotUI->add_spinner("Right Leg",
                    GLUI_SPINNER_FLOAT, &rightLegAngle,
					RIGHT_LEG, handleGLUIEvent );
  rightLegSpinner->set_float_limits(0,90 , GLUI_LIMIT_CLAMP);

  rightKneeSpinner = robotUI->add_spinner("Right Knee",
                    GLUI_SPINNER_FLOAT, &rightKneeAngle,
					RIGHT_KNEE, handleGLUIEvent );
  rightKneeSpinner->set_float_limits(0, 90 , GLUI_LIMIT_CLAMP);

  robotUI->add_button("Reset", RESET, handleGLUIEvent);
  robotUI->add_button("Quit", QUIT, handleGLUIEvent);

  robotUI->set_main_gfx_window( mainWindowID );

  cameraUI = GLUI_Master.create_glui( "Camera", 0 );

  eyeXSpinner = cameraUI->add_spinner("Eye X",
                    GLUI_SPINNER_FLOAT, &eye[X],
					EYE_X, handleGLUIEvent );
  eyeXSpinner->set_float_limits(-10, 10 , GLUI_LIMIT_CLAMP);

  eyeYSpinner = cameraUI->add_spinner("Eye Y",
                    GLUI_SPINNER_FLOAT, &eye[Y],
					EYE_Y, handleGLUIEvent );
  eyeYSpinner->set_float_limits(-10, 10 , GLUI_LIMIT_CLAMP);

  eyeZSpinner = cameraUI->add_spinner("Eye Z",
                    GLUI_SPINNER_FLOAT, &eye[Z],
					EYE_Z, handleGLUIEvent );
  eyeZSpinner->set_float_limits(-10, 10 , GLUI_LIMIT_CLAMP);

  cameraUI->add_separator();

  refXSpinner = cameraUI->add_spinner("Ref X",
                    GLUI_SPINNER_FLOAT, &ref[X],
					REF_X, handleGLUIEvent );
  refXSpinner->set_float_limits(-10, 10 , GLUI_LIMIT_CLAMP);

  refYSpinner = cameraUI->add_spinner("Ref Y",
                    GLUI_SPINNER_FLOAT, &ref[Y],
					REF_Y, handleGLUIEvent );
  refYSpinner->set_float_limits(-10, 10 , GLUI_LIMIT_CLAMP);

  refZSpinner = cameraUI->add_spinner("Ref Z",
                    GLUI_SPINNER_FLOAT, &ref[Z],
					REF_Z, handleGLUIEvent );
  refZSpinner->set_float_limits(-10, 10 , GLUI_LIMIT_CLAMP);

  cameraUI->add_separator();

  upXSpinner = cameraUI->add_spinner("Up X",
                    GLUI_SPINNER_FLOAT, &up[X],
					UP_X, handleGLUIEvent );
  upXSpinner->set_float_limits(-10, 10 , GLUI_LIMIT_CLAMP);

  upYSpinner = cameraUI->add_spinner("Up Y",
                    GLUI_SPINNER_FLOAT, &up[Y],
					UP_Y, handleGLUIEvent );
  upYSpinner->set_float_limits(-10, 10 , GLUI_LIMIT_CLAMP);

  upZSpinner = cameraUI->add_spinner("Up Z",
                    GLUI_SPINNER_FLOAT, &up[Z],
					UP_Z, handleGLUIEvent );
  upZSpinner->set_float_limits(-10, 10 , GLUI_LIMIT_CLAMP);

  cameraUI->add_separator();

  leftXSpinner = cameraUI->add_spinner("Left X",
                    GLUI_SPINNER_FLOAT, &leftX,
					LEFT_X, handleGLUIEvent );
  leftXSpinner->set_float_limits(-10, 10 , GLUI_LIMIT_CLAMP);

  rightXSpinner = cameraUI->add_spinner("Right X",
                    GLUI_SPINNER_FLOAT, &rightX,
					RIGHT_X, handleGLUIEvent );
  rightXSpinner->set_float_limits(-10, 10 , GLUI_LIMIT_CLAMP);

  bottomYSpinner = cameraUI->add_spinner("Bottom Y",
                    GLUI_SPINNER_FLOAT, &bottomY,
					BOTTOM_Y, handleGLUIEvent );
  bottomYSpinner->set_float_limits(-10, 10 , GLUI_LIMIT_CLAMP);

  topYSpinner = cameraUI->add_spinner("Top Y",
                    GLUI_SPINNER_FLOAT, &topY,
					TOP_Y, handleGLUIEvent );
  topYSpinner->set_float_limits(-10, 10 , GLUI_LIMIT_CLAMP);

  nearZSpinner = cameraUI->add_spinner("Near Z",
                    GLUI_SPINNER_FLOAT, &nearZ,
					NEAR_Z, handleGLUIEvent );
  nearZSpinner->set_float_limits(1, 20 , GLUI_LIMIT_CLAMP);

  farZSpinner = cameraUI->add_spinner("Far Z",
                    GLUI_SPINNER_FLOAT, &farZ,
					FAR_Z, handleGLUIEvent );
  farZSpinner->set_float_limits(1, 20 , GLUI_LIMIT_CLAMP);

  cameraUI->set_main_gfx_window( mainWindowID );

  GLUI_Master.set_glutIdleFunc( NULL );

  glutMainLoop();
}