/*
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.

*/
//
// vid_dos.c: DOS-specific video routines
//

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <dos.h>
#include <dpmi.h>
#include <go32.h>

#include "quakedef.h"
#include "d_local.h"
#include "dosisms.h"
#include "vid_dos.h"

int     vid_modenum;
vmode_t   *pcurrentmode = NULL;
int     vid_testingmode, vid_realmode;
double    vid_testendtime;

cvar_t    vid_mode = {"vid_mode","0", false};
cvar_t    vid_wait = {"vid_wait","0"};
cvar_t    vid_nopageflip = {"vid_nopageflip","0", true};
cvar_t    _vid_wait_override = {"_vid_wait_override", "0", true};
cvar_t    _vid_default_mode = {"_vid_default_mode","0", true};
cvar_t    _vid_default_mode_win = {"_vid_default_mode_win","1", true};
cvar_t    vid_config_x = {"vid_config_x","800", true};
cvar_t    vid_config_y = {"vid_config_y","600", true};
cvar_t    vid_stretch_by_2 = {"vid_stretch_by_2","1", true};
cvar_t    _windowed_mouse = {"_windowed_mouse","0", true};
cvar_t    vid_fullscreen_mode = {"vid_fullscreen_mode","3", true};
cvar_t    vid_windowed_mode = {"vid_windowed_mode","0", true};
cvar_t    block_switch = {"block_switch","0", true};
cvar_t    vid_window_x = {"vid_window_x", "0", true};
cvar_t    vid_window_y = {"vid_window_y", "0", true};

int d_con_indirect = 0;

int   numvidmodes;
vmode_t *pvidmodes;

static int  firstupdate = 1;

extern regs_t regs;

void VID_TestMode_f (void);
void VID_NumModes_f (void);
void VID_DescribeCurrentMode_f (void);
void VID_DescribeMode_f (void);
void VID_DescribeModes_f (void);

byte  vid_current_palette[768]; // save for mode changes


static qboolean nomodecheck = false;

unsigned short  d_8to16table[256];  // not used in 8 bpp mode
unsigned    d_8to24table[256];  // not used in 8 bpp mode

void VID_MenuDraw (void);
void VID_MenuKey (int key);


/*
================
VID_Init
================
*/
void    VID_Init (unsigned char *palette)
{
  Cvar_RegisterVariable (&vid_mode);
  Cvar_RegisterVariable (&vid_wait);
  Cvar_RegisterVariable (&vid_nopageflip);
  Cvar_RegisterVariable (&_vid_wait_override);
  Cvar_RegisterVariable (&_vid_default_mode);
  Cvar_RegisterVariable (&_vid_default_mode_win);
  Cvar_RegisterVariable (&vid_config_x);
  Cvar_RegisterVariable (&vid_config_y);
  Cvar_RegisterVariable (&vid_stretch_by_2);
  Cvar_RegisterVariable (&_windowed_mouse);
  Cvar_RegisterVariable (&vid_fullscreen_mode);
  Cvar_RegisterVariable (&vid_windowed_mode);
  Cvar_RegisterVariable (&block_switch);

  Cmd_AddCommand ("vid_testmode", VID_TestMode_f);
  Cmd_AddCommand ("vid_nummodes", VID_NumModes_f);
  Cmd_AddCommand ("vid_describecurrentmode", VID_DescribeCurrentMode_f);
  Cmd_AddCommand ("vid_describemode", VID_DescribeMode_f);
  Cmd_AddCommand ("vid_describemodes", VID_DescribeModes_f);

// set up the mode list; note that later inits link in their modes ahead of
// earlier ones, so the standard VGA modes are always first in the list. This
// is important because mode 0 must always be VGA mode 0x13
  if (!COM_CheckParm ("-stdvid"))
    VID_InitExtra ();
  VGA_Init ();

  vid_testingmode = 0;

  vid_modenum = vid_mode.value;

  VID_SetMode (vid_modenum, palette);

  vid_realmode = vid_modenum;
  
  vid_menudrawfn = VID_MenuDraw;
  vid_menukeyfn = VID_MenuKey;
}


/*
=================
VID_GetModePtr
=================
*/
vmode_t *VID_GetModePtr (int modenum)
{
  vmode_t *pv;

  pv = pvidmodes;
  if (!pv)
    Sys_Error ("VID_GetModePtr: empty vid mode list");

  while (modenum--)
  {
    pv = pv->pnext;
    if (!pv)
      Sys_Error ("VID_GetModePtr: corrupt vid mode list");
  }

  return pv;
}

/*
================
VID_NumModes
================
*/
int VID_NumModes ()
{
  return (numvidmodes);
}


/*
================
VID_ModeInfo
================
*/
char *VID_ModeInfo (int modenum, char **ppheader)
{
  static char *badmodestr = "Bad mode number";
  vmode_t   *pv;

  pv = VID_GetModePtr (modenum);

  if (!pv)
  {
    if (ppheader)
      *ppheader = NULL;
    return badmodestr;
  }
  else
  {
    if (ppheader)
      *ppheader = pv->header;
    return pv->name;
  }
}


/*
================
VID_SetMode 
================
*/
int VID_SetMode (int modenum, unsigned char *palette)
{
  int   stat;
  vmode_t *pnewmode, *poldmode;

  if ((modenum >= numvidmodes) || (modenum < 0))
  {
    Cvar_SetValue ("vid_mode", (float)vid_modenum);

    nomodecheck = true;
    Con_Printf ("No such video mode: %d\n", modenum);
    nomodecheck = false;

    if (pcurrentmode == NULL)
    {
      modenum = 0;  // mode hasn't been set yet, so initialize to base
              //  mode since they gave us an invalid initial mode
    }
    else
    {
      return 0;
    }
  }

  pnewmode = VID_GetModePtr (modenum);

  if (pnewmode == pcurrentmode)
    return 1; // already in the desired mode

// initialize the new mode
  poldmode = pcurrentmode;
  pcurrentmode = pnewmode;

  vid.width = pcurrentmode->width;
  vid.height = pcurrentmode->height;
  vid.aspect = pcurrentmode->aspect;
  vid.rowbytes = pcurrentmode->rowbytes;

  stat = (*pcurrentmode->setmode) (&vid, pcurrentmode);

  if (stat < 1)
  {
    if (stat == 0)
    {
    // real, hard failure that requires resetting the mode
      if (!VID_SetMode (vid_modenum, palette))  // restore prior mode
        Sys_Error ("VID_SetMode: Unable to set any mode, probably "
               "because there's not enough memory available");
      Con_Printf ("Failed to set mode %d\n", modenum);
      return 0;
    }
    else if (stat == -1)
    {
    // not enough memory; just put things back the way they were
      pcurrentmode = poldmode;
      vid.width = pcurrentmode->width;
      vid.height = pcurrentmode->height;
      vid.aspect = pcurrentmode->aspect;
      vid.rowbytes = pcurrentmode->rowbytes;
      return 0;
    }
    else
    {
      Sys_Error ("VID_SetMode: invalid setmode return code %d");
    }
  }

  (*pcurrentmode->setpalette) (&vid, pcurrentmode, palette);

  vid_modenum = modenum;
  Cvar_SetValue ("vid_mode", (float)vid_modenum);

  nomodecheck = true;
  Con_Printf ("%s\n", VID_ModeInfo (vid_modenum, NULL));
  nomodecheck = false;

  vid.recalc_refdef = 1;

  return 1;
}


/*
================
VID_SetPalette
================
*/
void    VID_SetPalette (unsigned char *palette)
{
  if (palette != vid_current_palette)
    Q_memcpy(vid_current_palette, palette, 768);
  (*pcurrentmode->setpalette)(&vid, pcurrentmode, vid_current_palette);
}


/*
================
VID_ShiftPalette
================
*/
void    VID_ShiftPalette (unsigned char *palette)
{

  VID_SetPalette (palette);
}


/*
================
VID_Shutdown
================
*/
void VID_Shutdown (void)
{

  regs.h.ah = 0;
  regs.h.al = 0x3;
  dos_int86(0x10);

  vid_testingmode = 0;
}


/*
================
VID_Update
================
*/
void    VID_Update (vrect_t *rects)
{
  if (firstupdate && _vid_default_mode.value)
  {
    if(_vid_default_mode.value >= numvidmodes)
      Cvar_SetValue ("_vid_default_mode", 0);

    firstupdate = 0;
    Cvar_SetValue ("vid_mode", _vid_default_mode.value);
  }

  (*pcurrentmode->swapbuffers)(&vid, pcurrentmode, rects);

  if (!nomodecheck)
  {
    if (vid_testingmode)
    {
      if (realtime >= vid_testendtime)
      {
        VID_SetMode (vid_realmode, vid_current_palette);
        vid_testingmode = 0;
      }
    }
    else
    {
      if (vid_mode.value != vid_realmode)
      {
        VID_SetMode ((int)vid_mode.value, vid_current_palette);
        Cvar_SetValue ("vid_mode", (float)vid_modenum);
                  // so if mode set fails, we don't keep on
                  //  trying to set that mode
        vid_realmode = vid_modenum;
      }
    }
  }
}


/*
=================
VID_NumModes_f
=================
*/
void VID_NumModes_f (void)
{
  int   nummodes;

  nummodes = VID_NumModes ();
  if (nummodes == 1)
    Con_Printf ("%d video mode is available\n", VID_NumModes ());
  else
    Con_Printf ("%d video modes are available\n", VID_NumModes ());
}


/*
=================
VID_DescribeCurrentMode_f
=================
*/
void VID_DescribeCurrentMode_f (void)
{
  Con_Printf ("%s\n", VID_ModeInfo (vid_modenum, NULL));
}


/*
=================
VID_DescribeMode_f
=================
*/
void VID_DescribeMode_f (void)
{
  int   modenum;
  
  modenum = Q_atoi (Cmd_Argv(1));

  Con_Printf ("%s\n", VID_ModeInfo (modenum, NULL));
}


/*
=================
VID_DescribeModes_f
=================
*/
void VID_DescribeModes_f (void)
{
  int     i, nummodes;
  char    *pinfo, *pheader;
  vmode_t   *pv;
  qboolean  na;

  na = false;

  nummodes = VID_NumModes ();
  for (i=0 ; i<nummodes ; i++)
  {
    pv = VID_GetModePtr (i);
    pinfo = VID_ModeInfo (i, &pheader);
    if (pheader)
      Con_Printf ("\n%s\n", pheader);

    if (VGA_CheckAdequateMem (pv->width, pv->height, pv->rowbytes,
      (pv->numpages == 1) || vid_nopageflip.value))
    {
      Con_Printf ("%2d: %s\n", i, pinfo);
    }
    else
    {
      Con_Printf ("**: %s\n", pinfo);
      na = true;
    }
  }

  if (na)
  {
    Con_Printf ("\n[**: not enough system RAM for mode]\n");
  }
}


/*
=================
VID_GetModeDescription
=================
*/
char *VID_GetModeDescription (int mode)
{
  char    *pinfo, *pheader;
  vmode_t   *pv;

  pv = VID_GetModePtr (mode);
  pinfo = VID_ModeInfo (mode, &pheader);

  if (VGA_CheckAdequateMem (pv->width, pv->height, pv->rowbytes,
    (pv->numpages == 1) || vid_nopageflip.value))
  {
    return pinfo;
  }
  else
  {
    return NULL;
  }
}


/*
=================
VID_TestMode_f
=================
*/
void VID_TestMode_f (void)
{
  int   modenum;
  double  testduration;

  if (!vid_testingmode)
  {
    modenum = Q_atoi (Cmd_Argv(1));

    if (VID_SetMode (modenum, vid_current_palette))
    {
      vid_testingmode = 1;
      testduration = Q_atof (Cmd_Argv(2));
      if (testduration == 0)
        testduration = 5.0;
      vid_testendtime = realtime + testduration;
    }
  }
}


/*
================
D_BeginDirectRect
================
*/
void D_BeginDirectRect (int x, int y, byte *pbitmap, int width, int height)
{

  if (!vid.direct || !pcurrentmode)
    return;

  if ((width > 24) || (height > 24) || (width < 1) || (height < 1))
    return;

  if (width & 0x03)
    return;

  (*pcurrentmode->begindirectrect) (&vid, pcurrentmode, x, y, pbitmap, width,
                    height);
}


/*
================
D_EndDirectRect
================
*/
void D_EndDirectRect (int x, int y, int width, int height)
{

  if (!vid.direct || !pcurrentmode)
    return;

  if ((width > 24) || (height > 24) || (width < 1) || (height < 1))
    return;

  if ((width & 0x03) || (height & 0x03))
    return;

  (*pcurrentmode->enddirectrect) (&vid, pcurrentmode, x, y, width, height);
}


//===========================================================================

extern void M_Menu_Options_f (void);
extern void M_Print (int cx, int cy, char *str);
extern void M_PrintWhite (int cx, int cy, char *str);
extern void M_DrawCharacter (int cx, int line, int num);
extern void M_DrawTransPic (int x, int y, qpic_t *pic);
extern void M_DrawPic (int x, int y, qpic_t *pic);

static int  vid_line, vid_wmodes, vid_column_size;

typedef struct
{
  int   modenum;
  char  *desc;
  int   iscur;
} modedesc_t;

#define MAX_COLUMN_SIZE 11

#define MAX_MODEDESCS (MAX_COLUMN_SIZE*3)

static modedesc_t modedescs[MAX_MODEDESCS];

/*
================
VID_MenuDraw
================
*/
void VID_MenuDraw (void)
{
  qpic_t    *p;
  char    *ptr;
  int     nummodes, i, j, column, row, dup;
  char    temp[100];

  vid_wmodes = 0;
  nummodes = VID_NumModes ();
  
  p = Draw_CachePic ("gfx/vidmodes.lmp");
  M_DrawPic ( (320-p->width)/2, 4, p);

  for (i=0 ; i<nummodes ; i++)
  {
    if (vid_wmodes < MAX_MODEDESCS)
    {
      if (i != 1)
      {
        ptr = VID_GetModeDescription (i);

        if (ptr)
        {
          dup = 0;

          for (j=0 ; j<vid_wmodes ; j++)
          {
            if (!strcmp (modedescs[j].desc, ptr))
            {
              if (modedescs[j].modenum != 0)
              {
                modedescs[j].modenum = i;
                dup = 1;

                if (i == vid_modenum)
                  modedescs[j].iscur = 1;
              }
              else
              {
                dup = 1;
              }

              break;
            }
          }

          if (!dup)
          {
            modedescs[vid_wmodes].modenum = i;
            modedescs[vid_wmodes].desc = ptr;
            modedescs[vid_wmodes].iscur = 0;

            if (i == vid_modenum)
              modedescs[vid_wmodes].iscur = 1;

            vid_wmodes++;
          }
        }
      }
    }
  }

  vid_column_size = (vid_wmodes + 2) / 3;

  column = 16;
  row = 36;

  for (i=0 ; i<vid_wmodes ; i++)
  {
    if (modedescs[i].iscur)
      M_PrintWhite (column, row, modedescs[i].desc);
    else
      M_Print (column, row, modedescs[i].desc);

    row += 8;

    if ((i % vid_column_size) == (vid_column_size - 1))
    {
      column += 13*8;
      row = 36;
    }
  }

// line cursor
  if (vid_testingmode)
  {
    sprintf (temp, "TESTING %s",
        modedescs[vid_line].desc);
    M_Print (13*8, 36 + MAX_COLUMN_SIZE * 8 + 8*4, temp);
    M_Print (9*8, 36 + MAX_COLUMN_SIZE * 8 + 8*6,
        "Please wait 5 seconds...");
  }
  else
  {
    M_Print (9*8, 36 + MAX_COLUMN_SIZE * 8 + 8,
        "Press Enter to set mode");
    M_Print (6*8, 36 + MAX_COLUMN_SIZE * 8 + 8*3,
        "T to test mode for 5 seconds");
    ptr = VID_GetModeDescription (vid_modenum);
    sprintf (temp, "D to make %s the default", ptr);
    M_Print (6*8, 36 + MAX_COLUMN_SIZE * 8 + 8*5, temp);
    ptr = VID_GetModeDescription ((int)_vid_default_mode.value);

    if (ptr)
    {
      sprintf (temp, "Current default is %s", ptr);
      M_Print (7*8, 36 + MAX_COLUMN_SIZE * 8 + 8*6, temp);
    }

    M_Print (15*8, 36 + MAX_COLUMN_SIZE * 8 + 8*8,
        "Esc to exit");

    row = 36 + (vid_line % vid_column_size) * 8;
    column = 8 + (vid_line / vid_column_size) * 13*8;

    M_DrawCharacter (column, row, 12+((int)(realtime*4)&1));
  }
}


/*
================
VID_MenuKey
================
*/
void VID_MenuKey (int key)
{
  if (vid_testingmode)
    return;

  switch (key)
  {
  case K_ESCAPE:
    S_LocalSound ("misc/menu1.wav");
    M_Menu_Options_f ();
    break;

  case K_UPARROW:
    S_LocalSound ("misc/menu1.wav");
    vid_line--;

    if (vid_line < 0)
      vid_line = vid_wmodes - 1;
    break;

  case K_DOWNARROW:
    S_LocalSound ("misc/menu1.wav");
    vid_line++;

    if (vid_line >= vid_wmodes)
      vid_line = 0;
    break;

  case K_LEFTARROW:
    S_LocalSound ("misc/menu1.wav");
    vid_line -= vid_column_size;

    if (vid_line < 0)
    {
      vid_line += ((vid_wmodes + (vid_column_size - 1)) /
          vid_column_size) * vid_column_size;

      while (vid_line >= vid_wmodes)
        vid_line -= vid_column_size;
    }
    break;

  case K_RIGHTARROW:
    S_LocalSound ("misc/menu1.wav");
    vid_line += vid_column_size;

    if (vid_line >= vid_wmodes)
    {
      vid_line -= ((vid_wmodes + (vid_column_size - 1)) /
          vid_column_size) * vid_column_size;

      while (vid_line < 0)
        vid_line += vid_column_size;
    }
    break;

  case K_ENTER:
    S_LocalSound ("misc/menu1.wav");
    VID_SetMode (modedescs[vid_line].modenum, vid_current_palette);
    break;

  case 'T':
  case 't':
    S_LocalSound ("misc/menu1.wav");
    if (VID_SetMode (modedescs[vid_line].modenum, vid_current_palette))
    {
      vid_testingmode = 1;
      vid_testendtime = realtime + 5.0;
    }
    break;

  case 'D':
  case 'd':
    S_LocalSound ("misc/menu1.wav");
    firstupdate = 0;
    Cvar_SetValue ("_vid_default_mode", vid_modenum);
    break;

  default:
    break;
  }
}