/***************************************************************************
 *   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
// clang-format off
// include necessary header files
#include "windows.h"
#include <iostream>
#include "DrawEvent.h"
#include "EventManager.h"
#include "KeyPressEvent.h"
#include "KeyReleaseEvent.h"
#include "Logger.h"
#include "WindowsLogger.h"
#include "console_logger.h"
#include "level.h"
#include "main.h"
#include "mygl.h"
#include "opengl.h"
#include "opengl/window.h"
#include "vector.h"
#include "version.h"

// clang-format on

namespace {
using OpenArena::ConsoleLogger;
using OpenArena::ControlScheme;
using OpenArena::DrawEvent;
using OpenArena::EventManager;
using OpenArena::g_Screen;
using OpenArena::KeyPressEvent;
using OpenArena::KeyReleaseEvent;
using OpenArena::Keys;
using OpenArena::Level;
using OpenArena::Logger;
using OpenArena::Vec2i;
using OpenArena::WindowsLogger;
using OpenArena::OpenGL::Window;
using std::exception;
using std::make_shared;
using std::string;
using std::to_string;
}  // End namespace

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);
Keys TranslateKey(int keyCode);
void HandleConsoleKeyPress(Keys key);

Level* level = nullptr;
bool keys[256] = {false};
bool keys2[256] = {false};
bool active = false;

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

int DrawGLScene(Level* level) {
  level->Render();

  g_Screen->SwapBuffers();

  return 1;
}

//
// 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((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) {
  auto p_console_logger = make_shared<ConsoleLogger>();
  auto p_windows_logger = make_shared<WindowsLogger>();
  p_windows_logger->SetMinType(Logger::MessageType::Error);
  Logger::AddLogger(p_console_logger);
  Logger::AddLogger(p_windows_logger);
  Logger::LogDebug("Starting");
  OpenArena::Logger::LogUnimplementedMethod;
  MSG msg;
  try {
    g_Screen = new Window();
    DrawEvent::DrawEventHandler* _drawEventHandler = new DrawEvent::DrawEventHandler(level);
    KeyPressEvent::KeyPressEventHandler* _keyPressEventHandler = new KeyPressEvent::KeyPressEventHandler();
    KeyReleaseEvent::KeyReleaseEventHandler* _keyReleaseEventHandler = new KeyReleaseEvent::KeyReleaseEventHandler();

    EventManager* em = new EventManager();
    level = new Level(em);
    bool done = false;
    if (strlen(lpCmdLine)) level->ParseCmds(lpCmdLine);
    InitControls();
    g_Screen->SetInitializer(new Window::Initializer());
    g_Screen->SetResizer(new Window::Resizer());
    if (!g_Screen->Open(string(OPENARENA_VERSION), g_Screen->GetWidth(), g_Screen->GetHeight(),
                        g_Screen->GetColorDepth(), g_Screen->GetFullscreen())) {
      Logger::LogError("Screen open failed.");
      return -1;
    }

    level->SetWindow(g_Screen);
    level->glFont.SetScreenDimensions(g_Screen->GetWidth() * 2, g_Screen->GetHeight() * 2);

    if (level->nextLevel == "") {
      Logger::LogDebug("Loading intro.map");
      level->LoadMap("intro.map");
    } else {
      Logger::LogDebug("Loading nextLevel: " + level->nextLevel);
      level->LoadMap();
    }
    Logger::LogDebug("About to start main loop.");
    while (!done) {
      // Logger::LogDebug("in 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) {
              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));
            }

            // //////////
            // // 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();
          //
        }
      }

      // Why the hell are we swapping buffers even if the window is not active?
      g_Screen->SwapBuffers();

      if (keys[Keys::KEY_F1]) {
        keys[Keys::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())) {
          Logger::LogError("Window failed to reopen after changing fullscreen flag.");
          return -1;
        }
      }
    }

  } catch (const exception& ex) {
    Logger::LogWtf("Unhandled exception", ex);
  } catch (...) {
    Logger::LogWtf("Unhandled exception");
  }

  Logger::LogDebug("level->UnloadMap()");
  level->UnloadMap();
  g_Screen->Close();
  Logger::LogDebug("g_Screen->Close()");
  Logger::LogDebug("Exiting with msg.wParam " + to_string(msg.wParam));
  return (msg.wParam);
}

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(Keys key) {
  // See if we need to hide the console
  if (level->defaultPlayer->controls.GetAction(key) == ControlScheme::ACTION_TOGGLE_CONSOLE) {
    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 = KeyToASCII(key, keys[OpenArena::KEY_SHIFT]);
      if (ascii != '\0') {
        level->UpdateConsole(ascii);
      }
  }
}

#endif