/*
Copyright (C) 1996-1997 Id Software, Inc.

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.

*/
// conproc.c

#include <windows.h>
#include "conproc.h"
#include "quakedef.h"

HANDLE  heventDone;
HANDLE  hfileBuffer;
HANDLE  heventChildSend;
HANDLE  heventParentSend;
HANDLE  hStdout;
HANDLE  hStdin;

DWORD RequestProc (DWORD dwNichts);
LPVOID GetMappedBuffer (HANDLE hfileBuffer);
void ReleaseMappedBuffer (LPVOID pBuffer);
BOOL GetScreenBufferLines (int *piLines);
BOOL SetScreenBufferLines (int iLines);
BOOL ReadText (LPTSTR pszText, int iBeginLine, int iEndLine);
BOOL WriteText (LPCTSTR szText);
int CharToCode (char c);
BOOL SetConsoleCXCY(HANDLE hStdout, int cx, int cy);


void InitConProc (HANDLE hFile, HANDLE heventParent, HANDLE heventChild)
{
  DWORD dwID;
  CONSOLE_SCREEN_BUFFER_INFO  info;
  int   wheight, wwidth;

// ignore if we don't have all the events.
  if (!hFile || !heventParent || !heventChild)
    return;

  hfileBuffer = hFile;
  heventParentSend = heventParent;
  heventChildSend = heventChild;

// so we'll know when to go away.
  heventDone = CreateEvent (NULL, FALSE, FALSE, NULL);

  if (!heventDone)
  {
    Con_SafePrintf ("Couldn't create heventDone\n");
    return;
  }

  if (!CreateThread (NULL,
             0,
             (LPTHREAD_START_ROUTINE) RequestProc,
             0,
             0,
             &dwID))
  {
    CloseHandle (heventDone);
    Con_SafePrintf ("Couldn't create QHOST thread\n");
    return;
  }

// save off the input/output handles.
  hStdout = GetStdHandle (STD_OUTPUT_HANDLE);
  hStdin = GetStdHandle (STD_INPUT_HANDLE);

// force 80 character width, at least 25 character height
  SetConsoleCXCY (hStdout, 80, 25);
}


void DeinitConProc (void)
{
  if (heventDone)
    SetEvent (heventDone);
}


DWORD RequestProc (DWORD dwNichts)
{
  int   *pBuffer;
  DWORD dwRet;
  HANDLE  heventWait[2];
  int   iBeginLine, iEndLine;
  
  heventWait[0] = heventParentSend;
  heventWait[1] = heventDone;

  while (1)
  {
    dwRet = WaitForMultipleObjects (2, heventWait, FALSE, INFINITE);

  // heventDone fired, so we're exiting.
    if (dwRet == WAIT_OBJECT_0 + 1) 
      break;

    pBuffer = (int *) GetMappedBuffer (hfileBuffer);
    
  // hfileBuffer is invalid.  Just leave.
    if (!pBuffer)
    {
      Con_SafePrintf ("Invalid hfileBuffer\n");
      break;
    }

    switch (pBuffer[0])
    {
      case CCOM_WRITE_TEXT:
      // Param1 : Text
        pBuffer[0] = WriteText ((LPCTSTR) (pBuffer + 1));
        break;

      case CCOM_GET_TEXT:
      // Param1 : Begin line
      // Param2 : End line
        iBeginLine = pBuffer[1];
        iEndLine = pBuffer[2];
        pBuffer[0] = ReadText ((LPTSTR) (pBuffer + 1), iBeginLine, 
                     iEndLine);
        break;

      case CCOM_GET_SCR_LINES:
      // No params
        pBuffer[0] = GetScreenBufferLines (&pBuffer[1]);
        break;

      case CCOM_SET_SCR_LINES:
      // Param1 : Number of lines
        pBuffer[0] = SetScreenBufferLines (pBuffer[1]);
        break;
    }

    ReleaseMappedBuffer (pBuffer);
    SetEvent (heventChildSend);
  }

  return 0;
}


LPVOID GetMappedBuffer (HANDLE hfileBuffer)
{
  LPVOID pBuffer;

  pBuffer = MapViewOfFile (hfileBuffer,
              FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);

  return pBuffer;
}


void ReleaseMappedBuffer (LPVOID pBuffer)
{
  UnmapViewOfFile (pBuffer);
}


BOOL GetScreenBufferLines (int *piLines)
{
  CONSOLE_SCREEN_BUFFER_INFO  info;               
  BOOL            bRet;

  bRet = GetConsoleScreenBufferInfo (hStdout, &info);
    
  if (bRet)
    *piLines = info.dwSize.Y;

  return bRet;
}


BOOL SetScreenBufferLines (int iLines)
{

  return SetConsoleCXCY (hStdout, 80, iLines);
}


BOOL ReadText (LPTSTR pszText, int iBeginLine, int iEndLine)
{
  COORD coord;
  DWORD dwRead;
  BOOL  bRet;

  coord.X = 0;
  coord.Y = iBeginLine;

  bRet = ReadConsoleOutputCharacter(
    hStdout,
    pszText,
    80 * (iEndLine - iBeginLine + 1),
    coord,
    &dwRead);

  // Make sure it's null terminated.
  if (bRet)
    pszText[dwRead] = '\0';

  return bRet;
}


BOOL WriteText (LPCTSTR szText)
{
  DWORD     dwWritten;
  INPUT_RECORD  rec;
  char      upper, *sz;

  sz = (LPTSTR) szText;

  while (*sz)
  {
  // 13 is the code for a carriage return (\n) instead of 10.
    if (*sz == 10)
      *sz = 13;

    upper = toupper(*sz);

    rec.EventType = KEY_EVENT;
    rec.Event.KeyEvent.bKeyDown = TRUE;
    rec.Event.KeyEvent.wRepeatCount = 1;
    rec.Event.KeyEvent.wVirtualKeyCode = upper;
    rec.Event.KeyEvent.wVirtualScanCode = CharToCode (*sz);
    rec.Event.KeyEvent.uChar.AsciiChar = *sz;
    rec.Event.KeyEvent.uChar.UnicodeChar = *sz;
    rec.Event.KeyEvent.dwControlKeyState = isupper(*sz) ? 0x80 : 0x0; 

    WriteConsoleInput(
      hStdin,
      &rec,
      1,
      &dwWritten);

    rec.Event.KeyEvent.bKeyDown = FALSE;

    WriteConsoleInput(
      hStdin,
      &rec,
      1,
      &dwWritten);

    sz++;
  }

  return TRUE;
}


int CharToCode (char c)
{
  char upper;
    
  upper = toupper(c);

  switch (c)
  {
    case 13:
      return 28;

    default:
      break;
  }

  if (isalpha(c))
    return (30 + upper - 65); 

  if (isdigit(c))
    return (1 + upper - 47);

  return c;
}


BOOL SetConsoleCXCY(HANDLE hStdout, int cx, int cy)
{
  CONSOLE_SCREEN_BUFFER_INFO  info;
  COORD           coordMax;
 
  coordMax = GetLargestConsoleWindowSize(hStdout);

  if (cy > coordMax.Y)
    cy = coordMax.Y;

  if (cx > coordMax.X)
    cx = coordMax.X;
 
  if (!GetConsoleScreenBufferInfo(hStdout, &info))
    return FALSE;
 
// height
    info.srWindow.Left = 0;         
    info.srWindow.Right = info.dwSize.X - 1;                
    info.srWindow.Top = 0;
    info.srWindow.Bottom = cy - 1;          
 
  if (cy < info.dwSize.Y)
  {
    if (!SetConsoleWindowInfo(hStdout, TRUE, &info.srWindow))
      return FALSE;
 
    info.dwSize.Y = cy;
 
    if (!SetConsoleScreenBufferSize(hStdout, info.dwSize))
      return FALSE;
    }
    else if (cy > info.dwSize.Y)
    {
    info.dwSize.Y = cy;
 
    if (!SetConsoleScreenBufferSize(hStdout, info.dwSize))
      return FALSE;
 
    if (!SetConsoleWindowInfo(hStdout, TRUE, &info.srWindow))
      return FALSE;
    }
 
  if (!GetConsoleScreenBufferInfo(hStdout, &info))
    return FALSE;
 
// width
  info.srWindow.Left = 0;         
  info.srWindow.Right = cx - 1;
  info.srWindow.Top = 0;
  info.srWindow.Bottom = info.dwSize.Y - 1;               
 
  if (cx < info.dwSize.X)
  {
    if (!SetConsoleWindowInfo(hStdout, TRUE, &info.srWindow))
      return FALSE;
 
    info.dwSize.X = cx;
    
    if (!SetConsoleScreenBufferSize(hStdout, info.dwSize))
      return FALSE;
  }
  else if (cx > info.dwSize.X)
  {
    info.dwSize.X = cx;
 
    if (!SetConsoleScreenBufferSize(hStdout, info.dwSize))
      return FALSE;
 
    if (!SetConsoleWindowInfo(hStdout, TRUE, &info.srWindow))
      return FALSE;
  }
 
  return TRUE;
}