/***************************************************************************
 *   Copyright (C) 2001-2023 by Tom Hicks                                  *
 *   headhunter3@gmail.com                                                 *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifdef WIN32
// include necessary header files
#include <GL/glu.h>

#include "main.h"
#include "vector.h"
#include "version.h"
using OpenArena::Vec2i;

// link necessary libraries
#pragma comment(lib, "opengl32.lib")
#pragma comment(lib, "glu32.lib")
#pragma comment(lib, "glaux.lib")
#pragma comment(lib, "winmm.lib")

// Ensure CDS_FULLSCREEN is defined
#ifndef CDS_FULLSCREEN
#define CDS_FULLSCREEN 4
#endif

using namespace std;

void InitControls();
int InitGL(GLvoid);
void ReSizeGLScene(GLsizei width, GLsizei height);
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow);
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
OpenArena::Keys TranslateKey(int keyCode);
void HandleConsoleKeyPress(OpenArena::Keys key);

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Function Definitions

//
// void InitControls()
//  Purpose:
//	    Initializes controls by loading the default control config file "my.cfg".

void InitControls() {
  if (!level.LoadConfig("my.cfg")) level.LoadConfig();
}

//
//	int InitGL(GLvoid)
//	Purpose:
//		To do all required setup before creating an OpenGL window
//	Pre:
//
//	Post:
//

int InitGL(GLvoid) {
  level.LoadGLTextures();

  glEnable(GL_TEXTURE_2D);
  glShadeModel(GL_SMOOTH);
  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  glClearDepth(1.0f);
  glEnable(GL_DEPTH_TEST);
  glDepthFunc(GL_LEQUAL);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

  /*lighting disabled temporarily
  glLightfv(GL_LIGHT1, GL_AMBIENT, level.LightAmbient);
  for(index=0; index<level.numLights; index++)
  {
  glLightfv(GL_LIGHT1, GL_DIFFUSE, level.light[index].color);
  glLightfv(GL_LIGHT1, GL_POSITION, level.light[index].coords);
  }

  glEnable(GL_LIGHT1);
  glEnable(GL_LIGHTING);
  */
  // BuildFont();
  return true;
}

//
//	GLvoid ReSizeGLScene(GLsizei width, GLsizei height)
//	Purpose:
//		To resize the OpenGL window also called on creation
//	Pre:
//
//	Post:
//

void ReSizeGLScene(GLsizei width, GLsizei height) {
  if (height == 0) height = 1;
  glViewport(0, 0, width, height);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  gluPerspective(45.0f, (GLfloat)width / (GLfloat)height, 0.1f, 100.0f);

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
  switch (uMsg) {
    case WM_ACTIVATE: {
      if (!HIWORD(wParam)) {
        active = true;
      } else {
        active = false;
      }

      return 0;
    }
    case WM_SYSCOMMAND: {
      switch (wParam) {
        case SC_SCREENSAVE:
        case SC_MONITORPOWER:
          return 0;
      }
      break;
    }
    case WM_CLOSE: {
      PostQuitMessage(0);
      return 0;
    }
    case WM_KEYDOWN: {
      if (level.showConsole) {
        HandleConsoleKeyPress((OpenArena::Keys)TranslateKey(wParam));
      } else {
        keys[TranslateKey(wParam)] = true;
      }
      return 0;
    }
    case WM_KEYUP: {
      keys[TranslateKey(wParam)] = false;
      keys2[TranslateKey(wParam)] = false;
      return 0;
    }
    case WM_SYSKEYDOWN:
      break;
    case WM_SIZE: {
      ReSizeGLScene(LOWORD(lParam), HIWORD(lParam));
      return 0;
    }
    case WM_LBUTTONDOWN: {
      keys[OpenArena::KEY_LBUTTON] = true;
      return 0;
    }
    case WM_LBUTTONUP: {
      keys[OpenArena::KEY_LBUTTON] = false;
      keys[OpenArena::KEY_LBUTTON] = false;
      return 0;
    }
    case WM_RBUTTONDOWN: {
      keys[OpenArena::KEY_RBUTTON] = true;
      return 0;
    }
    case WM_RBUTTONUP: {
      keys[OpenArena::KEY_RBUTTON] = false;
      keys[OpenArena::KEY_RBUTTON] = false;
      return 0;
    }
    case WM_MBUTTONDOWN: {
      keys[OpenArena::KEY_MBUTTON] = true;
      return 0;
    }
    case WM_MBUTTONUP: {
      keys[OpenArena::KEY_MBUTTON] = false;
      keys[OpenArena::KEY_MBUTTON] = false;
      return 0;
    }
  }

  return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
  MSG msg;
  bool done = false;

  if (strlen(lpCmdLine)) level.ParseCmds(lpCmdLine);

  InitControls();

  g_Screen.SetInitializer(new OpenArena::Window::Initializer());
  g_Screen.SetResizer(new OpenArena::Window::Resizer());
  if (!g_Screen.Open(string(OPENARENA_VERSION),
                     level.screen.GetWidth(),
                     level.screen.GetHeight(),
                     level.screen.GetColorDepth(),
                     level.screen.GetFullscreen())) {
    return 0;
  }

  level.SetWindow(&g_Screen);
  level.glFont.SetScreenDimensions(level.screen.GetWidth() * 2, level.screen.GetHeight() * 2);
  // level.glFont.BuildFont("oa\\textures\\menu\\font.bmp");//(level.gamedir + "\\textures\\menu\\font.bmp").c_str());
  if (level.nextLevel == "") {
    level.LoadMap("intro.map");
  } else {
    level.LoadMap();
  }

  while (!done) {
    while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
      if (msg.message == WM_QUIT) {
        done = true;
      } else {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
      }
    }

    if (active) {
      if (keys[OpenArena::KEY_ESCAPE]) {
        done = true;
      } else {
        level.defaultPlayer[0].camera.Update();

        if (!level.showConsole) {
          if (level.mlook) {
            using OpenArena::Vec2i;
            Vec2i middleOfScreen = Vec2i(g_Screen.GetWidth() / 2, g_Screen.GetHeight() / 2);
            Vec2i mousePosition = g_Screen.GetMousePosition();
            if (mousePosition != middleOfScreen) {
              // Vec2i mouseDelta = mousePosition - middleOfScreen;
              Vec2i mouseDelta = middleOfScreen - mousePosition;
              g_Screen.SetMousePosition(middleOfScreen);
              const float MOUSE_SENSITIVITY_HORIZONTAL = 0.005f;
              const float MOUSE_SENSITIVITY_VERTICAL = 0.005f;
              float horizontalAngle = mouseDelta.x * MOUSE_SENSITIVITY_HORIZONTAL;
              float verticalAngle = mouseDelta.y * MOUSE_SENSITIVITY_VERTICAL;
              level.defaultPlayer[0].camera.RotateHorizontal(horizontalAngle);
              level.defaultPlayer[0].camera.RotateVertical(verticalAngle);
            }
          } else {
            g_Screen.SetMousePosition(Vec2i(g_Screen.GetWidth() / 2, g_Screen.GetHeight() / 2));
            // SetCursorPos(g_Screen.GetWidth()/2, g_Screen.GetHeight()/2);
          }

          //////////
          // Move Backward
          if (!level.defaultPlayer->controls.backward.IsEmpty()) {
            level.defaultPlayer->controls.backward.FirstPosition();
            if (keys[level.defaultPlayer->controls.backward.Retrieve()]) {
              level.defaultPlayer->camera.MoveCamera(-level.moveSpeed);
            } else {
              while (level.defaultPlayer->controls.backward.NextPosition()
                     && (keys[level.defaultPlayer->controls.backward.Retrieve()] != true))
                ;
              {
                if (keys[level.defaultPlayer->controls.backward.Retrieve()]) {
                  level.defaultPlayer->camera.MoveCamera(-level.moveSpeed);
                }
              }
            }
          }

          //////////
          // Move forward
          if (!level.defaultPlayer->controls.forward.IsEmpty()) {
            level.defaultPlayer->controls.forward.FirstPosition();
            if (keys[level.defaultPlayer->controls.forward.Retrieve()]) {
              level.defaultPlayer->camera.MoveCamera(level.moveSpeed);
            } else {
              while (level.defaultPlayer->controls.forward.NextPosition()
                     && (keys[level.defaultPlayer->controls.forward.Retrieve()] != true))
                ;
              {
                if (keys[level.defaultPlayer->controls.forward.Retrieve()]) {
                  level.defaultPlayer->camera.MoveCamera(level.moveSpeed);
                }
              }
            }
          }

          //////////
          // Strafe Left
          if (!level.defaultPlayer->controls.moveLeft.IsEmpty()) {
            level.defaultPlayer->controls.moveLeft.FirstPosition();
            if (keys[level.defaultPlayer->controls.moveLeft.Retrieve()]) {
              level.defaultPlayer->camera.StrafeCamera(-level.moveSpeed);
            } else {
              while (level.defaultPlayer->controls.moveLeft.NextPosition()
                     && (keys[level.defaultPlayer->controls.moveLeft.Retrieve()] != true))
                ;
              {
                if (keys[level.defaultPlayer->controls.moveLeft.Retrieve()]) {
                  level.defaultPlayer->camera.StrafeCamera(-level.moveSpeed);
                }
              }
            }
          }

          //////////
          // Strafe Right
          if (!level.defaultPlayer->controls.moveRight.IsEmpty()) {
            level.defaultPlayer->controls.moveRight.FirstPosition();
            if (keys[level.defaultPlayer->controls.moveRight.Retrieve()]) {
              level.defaultPlayer[0].camera.StrafeCamera(level.moveSpeed);
            } else {
              while (level.defaultPlayer->controls.moveRight.NextPosition()
                     && (keys[level.defaultPlayer->controls.moveRight.Retrieve()] != true))
                ;
              {
                if (keys[level.defaultPlayer->controls.moveRight.Retrieve()]) {
                  level.defaultPlayer->camera.StrafeCamera(level.moveSpeed);
                }
              }
            }
          }

          //////////
          // Keyboard Look Left
          if (!level.defaultPlayer->controls.lookLeft.IsEmpty()) {
            level.defaultPlayer->controls.lookLeft.FirstPosition();
            if (keys[level.defaultPlayer->controls.lookLeft.Retrieve()]) {
              level.defaultPlayer[0].camera.RotateView(level.turnSpeed, 0, 1, 0);
            } else {
              while (level.defaultPlayer->controls.lookLeft.NextPosition()
                     && (keys[level.defaultPlayer->controls.lookLeft.Retrieve()] != true))
                ;
              {
                if (keys[level.defaultPlayer->controls.lookLeft.Retrieve()]) {
                  level.defaultPlayer[0].camera.RotateView(level.turnSpeed, 0, 1, 0);
                }
              }
            }
          }

          //////////
          // Keyboard Look Right
          if (!level.defaultPlayer->controls.lookRight.IsEmpty()) {
            level.defaultPlayer->controls.lookRight.FirstPosition();
            if (keys[level.defaultPlayer->controls.lookRight.Retrieve()]) {
              level.defaultPlayer->camera.RotateView(-level.turnSpeed, 0, 1, 0);
            } else {
              while (level.defaultPlayer->controls.lookRight.NextPosition()
                     && (keys[level.defaultPlayer->controls.lookRight.Retrieve()] != true))
                ;
              {
                if (keys[level.defaultPlayer->controls.lookRight.Retrieve()]) {
                  level.defaultPlayer->camera.RotateView(-level.turnSpeed, 0, 1, 0);
                }
              }
            }
          }

          //////////
          // Keyboard Look Up
          if (!level.defaultPlayer->controls.lookUp.IsEmpty()) {
            level.defaultPlayer->controls.lookUp.FirstPosition();
            if (keys[level.defaultPlayer->controls.lookUp.Retrieve()]) {
              level.defaultPlayer->camera.RotateView(level.turnSpeed, 1, 0, 0);
            } else {
              while (level.defaultPlayer->controls.lookUp.NextPosition()
                     && (keys[level.defaultPlayer->controls.lookUp.Retrieve()] != true))
                ;
              {
                if (keys[level.defaultPlayer->controls.lookUp.Retrieve()]) {
                  level.defaultPlayer->camera.RotateView(level.turnSpeed, 1, 0, 0);
                }
              }
            }
          }

          //////////
          // Keyboard Look Down
          if (!level.defaultPlayer->controls.lookDown.IsEmpty()) {
            level.defaultPlayer->controls.lookDown.FirstPosition();
            if (keys[level.defaultPlayer->controls.lookDown.Retrieve()]) {
              level.defaultPlayer->camera.RotateView(-level.turnSpeed, 1, 0, 0);
            } else {
              while (level.defaultPlayer->controls.lookDown.NextPosition()
                     && (keys[level.defaultPlayer->controls.lookDown.Retrieve()] != true))
                ;
              {
                if (keys[level.defaultPlayer->controls.lookDown.Retrieve()]) {
                  level.defaultPlayer->camera.RotateView(-level.turnSpeed, 1, 0, 0);
                }
              }
            }
          }

          //////////
          // Toggle Show FPS
          if (!level.defaultPlayer->controls.toggleFPS.IsEmpty()) {
            level.defaultPlayer->controls.toggleFPS.FirstPosition();
            if (keys[level.defaultPlayer->controls.toggleFPS.Retrieve()]) {
              if (!keys2[level.defaultPlayer->controls.toggleFPS.Retrieve()]) {
                level.showFPS = !level.showFPS;
              }
            } else {
              while (level.defaultPlayer->controls.toggleFPS.NextPosition()
                     && (keys[level.defaultPlayer->controls.toggleFPS.Retrieve()] != true))
                ;
              {
                if (keys[level.defaultPlayer->controls.toggleFPS.Retrieve()]) {
                  if (!keys2[level.defaultPlayer->controls.toggleFPS.Retrieve()]) {
                    level.showFPS = !level.showFPS;
                  }
                }
              }
            }
          }

          //////////
          // Toggle MouseLook
          if (!level.defaultPlayer->controls.toggleMouseLook.IsEmpty()) {
            level.defaultPlayer->controls.toggleMouseLook.FirstPosition();
            if (keys[level.defaultPlayer->controls.toggleMouseLook.Retrieve()]) {
              if (keys2[level.defaultPlayer->controls.toggleMouseLook.Retrieve()]) {
                level.mlook = !level.mlook;
              }
            } else {
              while (level.defaultPlayer->controls.toggleMouseLook.NextPosition()
                     && (keys[level.defaultPlayer->controls.toggleMouseLook.Retrieve()] != true))
                ;
              {
                if (keys[level.defaultPlayer->controls.toggleMouseLook.Retrieve()]) {
                  if (keys2[level.defaultPlayer->controls.toggleMouseLook.Retrieve()]) {
                    level.mlook = !level.mlook;
                  }
                }
              }
            }
          }

          //////////
          // Toggle Console
          if (!level.defaultPlayer[0].controls.toggleConsole.IsEmpty()) {
            level.defaultPlayer[0].controls.toggleConsole.FirstPosition();
            if (keys[level.defaultPlayer[0].controls.toggleConsole.Retrieve()]) {
              if (!keys2[level.defaultPlayer[0].controls.toggleConsole.Retrieve()]) {
                level.showConsole = !level.showConsole;
                keys2[level.defaultPlayer[0].controls.toggleConsole.Retrieve()] = true;
              }
            } else {
              while (level.defaultPlayer[0].controls.toggleConsole.NextPosition()
                     && (keys[level.defaultPlayer[0].controls.toggleConsole.Retrieve()] != true))
                ;
              {
                if (keys[level.defaultPlayer[0].controls.toggleConsole.Retrieve()]) {
                  if (!keys2[level.defaultPlayer[0].controls.toggleConsole.Retrieve()]) {
                    level.showConsole = !level.showConsole;
                    keys2[level.defaultPlayer[0].controls.toggleConsole.Retrieve()] = true;
                  }
                }
              }
            }
          }

          //////////
          // Quick MouseLook
          if (!level.defaultPlayer->controls.quickMouseLook.IsEmpty()) {
            level.defaultPlayer->controls.quickMouseLook.FirstPosition();
            if (keys[level.defaultPlayer->controls.quickMouseLook.Retrieve()]) {
              if (keys2[level.defaultPlayer->controls.quickMouseLook.Retrieve()]) {
                level.mlook = !level.mlook;
              }
            } else {
              while (level.defaultPlayer->controls.quickMouseLook.NextPosition()
                     && (keys[level.defaultPlayer->controls.quickMouseLook.Retrieve()] != true))
                ;
              {
                if (keys[level.defaultPlayer->controls.quickMouseLook.Retrieve()]) {
                  if (keys2[level.defaultPlayer->controls.quickMouseLook.Retrieve()]) {
                    level.mlook = !level.mlook;
                  }
                }
              }
            }
          }
          // level.Render();
        }
        level.Render();
        //
      }
    }

    g_Screen.SwapBuffers();

    if (keys[OpenArena::KEY_F1]) {
      keys[OpenArena::KEY_F1] = false;
      g_Screen.Close();
      g_Screen.ToggleFullscreen();
      if (!g_Screen.Open("OpenArena",
                         g_Screen.GetWidth(),
                         g_Screen.GetHeight(),
                         g_Screen.GetColorDepth(),
                         g_Screen.GetFullscreen())) {
        return 0;
      }
    }
  }

  level.UnloadMap();
  g_Screen.Close();
  return (msg.wParam);
}

OpenArena::Keys TranslateKey(int keyCode) {
  switch (keyCode) {
    case VK_LEFT:
      return OpenArena::KEY_LEFT;
    case VK_RIGHT:
      return OpenArena::KEY_RIGHT;
    case VK_UP:
      return OpenArena::KEY_UP;
    case VK_DOWN:
      return OpenArena::KEY_DOWN;
    case VK_SPACE:
      return OpenArena::KEY_SPACE;
    case VK_RETURN:
      return OpenArena::KEY_RETURN;
    case VK_SHIFT:
      return OpenArena::KEY_SHIFT;
    case VK_PAUSE:
      return OpenArena::KEY_PAUSE;
    case VK_CONTROL:
      return OpenArena::KEY_CONTROL;
    case VK_CAPITAL:
      return OpenArena::KEY_CAPITAL;
    case VK_ESCAPE:
      return OpenArena::KEY_ESCAPE;
    case VK_PRIOR:
      return OpenArena::KEY_PRIOR;
    case VK_NEXT:
      return OpenArena::KEY_NEXT;
    case VK_END:
      return OpenArena::KEY_END;
    case VK_HOME:
      return OpenArena::KEY_HOME;
    case VK_INSERT:
      return OpenArena::KEY_INSERT;
    case VK_DELETE:
      return OpenArena::KEY_DELETE;
    case VK_LWIN:
      return OpenArena::KEY_LWIN;
    case VK_RWIN:
      return OpenArena::KEY_RWIN;
    case VK_APPS:
      return OpenArena::KEY_APPS;
    case VK_NUMPAD0:
      return OpenArena::KEY_NUMPAD0;
    case VK_NUMPAD1:
      return OpenArena::KEY_NUMPAD1;
    case VK_NUMPAD2:
      return OpenArena::KEY_NUMPAD2;
    case VK_NUMPAD3:
      return OpenArena::KEY_NUMPAD3;
    case VK_NUMPAD4:
      return OpenArena::KEY_NUMPAD4;
    case VK_NUMPAD5:
      return OpenArena::KEY_NUMPAD5;
    case VK_NUMPAD6:
      return OpenArena::KEY_NUMPAD6;
    case VK_NUMPAD7:
      return OpenArena::KEY_NUMPAD7;
    case VK_NUMPAD8:
      return OpenArena::KEY_NUMPAD8;
    case VK_NUMPAD9:
      return OpenArena::KEY_NUMPAD9;
    case VK_MULTIPLY:
      return OpenArena::KEY_MULTIPLY;
    case VK_ADD:
      return OpenArena::KEY_ADD;
    case VK_SUBTRACT:
      return OpenArena::KEY_SUBTRACT;
    case VK_DIVIDE:
      return OpenArena::KEY_DIVIDE;
    case VK_F1:
      return OpenArena::KEY_F1;
    case VK_F2:
      return OpenArena::KEY_F2;
    case VK_F3:
      return OpenArena::KEY_F3;
    case VK_F4:
      return OpenArena::KEY_F4;
    case VK_F5:
      return OpenArena::KEY_F5;
    case VK_F6:
      return OpenArena::KEY_F6;
    case VK_F7:
      return OpenArena::KEY_F7;
    case VK_F8:
      return OpenArena::KEY_F8;
    case VK_F9:
      return OpenArena::KEY_F9;
    case VK_F10:
      return OpenArena::KEY_F10;
    case VK_F11:
      return OpenArena::KEY_F11;
    case VK_F12:
      return OpenArena::KEY_F12;
    case VK_NUMLOCK:
      return OpenArena::KEY_NUMLOCK;
    case VK_SCROLL:
      return OpenArena::KEY_SCROLL;
    case VK_SEPARATOR:
      return OpenArena::KEY_SEPARATOR;
    case VK_OEM_1:
      return OpenArena::KEY_OEM_1;
    case VK_OEM_2:
      return OpenArena::KEY_OEM_2;
    case VK_OEM_3:
      return OpenArena::KEY_OEM_3;
    case VK_OEM_4:
      return OpenArena::KEY_OEM_4;
    case VK_OEM_5:
      return OpenArena::KEY_OEM_5;
    case VK_OEM_6:
      return OpenArena::KEY_OEM_6;
    case VK_OEM_7:
      return OpenArena::KEY_OEM_7;
    case VK_OEM_PERIOD:
      return OpenArena::KEY_OEM_PERIOD;
    case VK_OEM_PLUS:
      return OpenArena::KEY_OEM_PLUS;
    case VK_OEM_MINUS:
      return OpenArena::KEY_OEM_MINUS;
    case VK_OEM_COMMA:
      return OpenArena::KEY_OEM_COMMA;
    case VK_BACK:
      return OpenArena::KEY_BACK;
    case VK_TAB:
      return OpenArena::KEY_TAB;
    case '0':
      return OpenArena::KEY_0;
    case '1':
      return OpenArena::KEY_1;
    case '2':
      return OpenArena::KEY_2;
    case '3':
      return OpenArena::KEY_3;
    case '4':
      return OpenArena::KEY_4;
    case '5':
      return OpenArena::KEY_5;
    case '6':
      return OpenArena::KEY_6;
    case '7':
      return OpenArena::KEY_7;
    case '8':
      return OpenArena::KEY_8;
    case '9':
      return OpenArena::KEY_9;
    case 'A':
      return OpenArena::KEY_A;
    case 'B':
      return OpenArena::KEY_B;
    case 'C':
      return OpenArena::KEY_C;
    case 'D':
      return OpenArena::KEY_D;
    case 'E':
      return OpenArena::KEY_E;
    case 'F':
      return OpenArena::KEY_F;
    case 'G':
      return OpenArena::KEY_G;
    case 'H':
      return OpenArena::KEY_H;
    case 'I':
      return OpenArena::KEY_I;
    case 'J':
      return OpenArena::KEY_J;
    case 'K':
      return OpenArena::KEY_K;
    case 'L':
      return OpenArena::KEY_L;
    case 'M':
      return OpenArena::KEY_M;
    case 'N':
      return OpenArena::KEY_N;
    case 'O':
      return OpenArena::KEY_O;
    case 'P':
      return OpenArena::KEY_P;
    case 'Q':
      return OpenArena::KEY_Q;
    case 'R':
      return OpenArena::KEY_R;
    case 'S':
      return OpenArena::KEY_S;
    case 'T':
      return OpenArena::KEY_T;
    case 'U':
      return OpenArena::KEY_U;
    case 'V':
      return OpenArena::KEY_V;
    case 'W':
      return OpenArena::KEY_W;
    case 'X':
      return OpenArena::KEY_X;
    case 'Y':
      return OpenArena::KEY_Y;
    case 'Z':
      return OpenArena::KEY_Z;
    case VK_LBUTTON:
      return OpenArena::KEY_LBUTTON;
    case VK_RBUTTON:
      return OpenArena::KEY_RBUTTON;
    case VK_MBUTTON:
      return OpenArena::KEY_MBUTTON;
    default:
      return OpenArena::KEY_UNKNOWN;
  }
}

void HandleConsoleKeyPress(OpenArena::Keys key) {
  // See if we need to hide the console
  level.defaultPlayer[0].controls.toggleConsole.FirstPosition();
  if (key == level.defaultPlayer[0].controls.toggleConsole.Retrieve()) {
    level.showConsole = false;
  } else {
    while (level.defaultPlayer[0].controls.toggleConsole.NextPosition() && level.showConsole) {
      if (level.defaultPlayer[0].controls.toggleConsole.Retrieve() == key) {
        level.showConsole = false;
      }
    }
  }
  switch (key) {
    case OpenArena::KEY_SHIFT:
      keys[OpenArena::KEY_SHIFT] = true;
      break;
    case OpenArena::KEY_RETURN:
      level.UpdateConsole('\n');
      break;
    case OpenArena::KEY_SPACE:
      printf("hello");
      level.UpdateConsole(' ');
      break;
    case OpenArena::KEY_BACK:
      level.UpdateConsole(OpenArena::KEY_BACK);
      break;
    default:
      char ascii = OpenArena::KeyToASCII(key, keys[OpenArena::KEY_SHIFT]);
      if (ascii != '\0') {
        level.UpdateConsole(ascii);
      }
  }
}

#endif