#include "StdAfx.h"

#include <ncurses.h>
#include <signal.h>
#include <iostream>

#include "Common.h"
#include "Disk.h"
#include "Video.h"
#include "DiskImageHelper.h"
#include "Memory.h"

#include "linux/interface.h"

#include "frontends/ncurses/colors.h"

namespace
{
  std::shared_ptr<WINDOW> frame;
  std::shared_ptr<WINDOW> buffer;
  std::shared_ptr<WINDOW> borders;

  std::shared_ptr<GRColors> grColors;


  int    g_nTrackDrive1  = -1;
  int    g_nTrackDrive2  = -1;
  int    g_nSectorDrive1 = -1;
  int    g_nSectorDrive2 = -1;
  TCHAR  g_sTrackDrive1 [8] = TEXT("??");
  TCHAR  g_sTrackDrive2 [8] = TEXT("??");
  TCHAR  g_sSectorDrive1[8] = TEXT("??");
  TCHAR  g_sSectorDrive2[8] = TEXT("??");
  Disk_Status_e g_eStatusDrive1 = DISK_STATUS_OFF;
  Disk_Status_e g_eStatusDrive2 = DISK_STATUS_OFF;

  LPBYTE        g_pTextBank1; // Aux
  LPBYTE        g_pTextBank0; // Main
  LPBYTE        g_pHiresBank1;
  LPBYTE        g_pHiresBank0;

#define  SW_80COL         (g_uVideoMode & VF_80COL)
#define  SW_DHIRES        (g_uVideoMode & VF_DHIRES)
#define  SW_HIRES         (g_uVideoMode & VF_HIRES)
#define  SW_80STORE       (g_uVideoMode & VF_80STORE)
#define  SW_MIXED         (g_uVideoMode & VF_MIXED)
#define  SW_PAGE2         (g_uVideoMode & VF_PAGE2)
#define  SW_TEXT          (g_uVideoMode & VF_TEXT)

  BYTE nextKey = 0;
  bool keyReady = false;

  void sig_handler(int signo)
  {
    endwin();
    exit(1);
  }

  chtype mapCharacter(BYTE ch)
  {
    const bool normal = ch & 0x80;
    char low = ch & 0x7f;

    // just in case the following logic misses something
    chtype result = ACS_DIAMOND;

    if (low == 0x7f)
    {
      result = ACS_CKBOARD;
    }
    else
    {
      result = low;
      if (low >= 0x00 && low < 0x20)
      {
	result += 0x40;
      }
    }

    if (!normal)
    {
      result |= A_REVERSE;
    }

    return result;
  }

  void output(const char *fmt, ...)
  {
    va_list args;
    va_start(args, fmt);

    vwprintw(buffer.get(), fmt, args);
    wrefresh(buffer.get());
  }

}

bool Update40ColCell (int x, int y, int xpixel, int ypixel, int offset)
{
  BYTE ch = *(g_pTextBank0+offset);

  if (ch)
  {
    const chtype ch2 = mapCharacter(ch);
    mvwaddch(frame.get(), 1 + y, 1 + x, ch2);
  }

  return true;
}

bool Update80ColCell (int x, int y, int xpixel, int ypixel, int offset)
{
  return true;
}

bool UpdateLoResCell (int x, int y, int xpixel, int ypixel, int offset)
{
  BYTE val = *(g_pTextBank0+offset);

  const int pair = grColors->getPair(val);

  wattron(frame.get(), COLOR_PAIR(pair));
  mvwaddstr(frame.get(), 1 + y, 1 + x, "\u2580");
  wattroff(frame.get(), COLOR_PAIR(pair));

  return true;
}

bool UpdateDLoResCell (int x, int y, int xpixel, int ypixel, int offset)
{
  return true;
}

bool UpdateHiResCell (int x, int y, int xpixel, int ypixel, int offset)
{
  return true;
}

bool UpdateDHiResCell (int x, int y, int xpixel, int ypixel, int offset)
{
  return true;
}


void FrameRefresh()
{
  // std::cout << "Status Drive 1: " << g_eStatusDrive1 << ", Track: " << g_sTrackDrive1 << ", Sector: " << g_sSectorDrive1 << " ";
  // std::cout << "Status Drive 2: " << g_eStatusDrive2 << ", Track: " << g_sTrackDrive2 << ", Sector: " << g_sSectorDrive2 << " ";
  // std::cout << "\r" << std::flush;
}

void FrameDrawDiskLEDS(HDC x)
{
  DiskGetLightStatus(&g_eStatusDrive1, &g_eStatusDrive1);
  FrameRefresh();
}

void FrameDrawDiskStatus(HDC x)
{
  if (mem == NULL)
    return;

  // We use the actual drive since probing from memory doesn't tell us anything we don't already know.
  //        DOS3.3   ProDOS
  // Drive  $B7EA    $BE3D
  // Track  $B7EC    LC1 $D356
  // Sector $B7ED    LC1 $D357
  // RWTS            LC1 $D300
  int nActiveFloppy = DiskGetCurrentDrive();

  int nDisk1Track  = DiskGetTrack(0);
  int nDisk2Track  = DiskGetTrack(1);

  // Probe known OS's for Track/Sector
  int  isProDOS = mem[ 0xBF00 ] == 0x4C;
  bool isValid  = true;

  // Try DOS3.3 Sector
  if ( !isProDOS )
  {
    int nDOS33track  = mem[ 0xB7EC ];
    int nDOS33sector = mem[ 0xB7ED ];

    if ((nDOS33track  >= 0 && nDOS33track  < 40)
	&&  (nDOS33sector >= 0 && nDOS33sector < 16))
    {

      /**/ if (nActiveFloppy == 0) g_nSectorDrive1 = nDOS33sector;
      else if (nActiveFloppy == 1) g_nSectorDrive2 = nDOS33sector;
    }
    else
      isValid = false;
  }
  else // isProDOS
  {
    // we can't just read from mem[ 0xD357 ] since it might be bank-switched from ROM
    // and we need the Language Card RAM
    // memrom[ 0xD350 ] = " ERROR\x07\x00"  Applesoft error message
    //                             T   S
    int nProDOStrack  = *MemGetMainPtr( 0xC356 ); // LC1 $D356
    int nProDOSsector = *MemGetMainPtr( 0xC357 ); // LC1 $D357

    if ((nProDOStrack  >= 0 && nProDOStrack  < 40)
	&&  (nProDOSsector >= 0 && nProDOSsector < 16))
    {
      /**/ if (nActiveFloppy == 0) g_nSectorDrive1 = nProDOSsector;
      else if (nActiveFloppy == 1) g_nSectorDrive2 = nProDOSsector;
    }
    else
      isValid = false;
  }

  g_nTrackDrive1  = nDisk1Track;
  g_nTrackDrive2  = nDisk2Track;

  if( !isValid )
  {
    if (nActiveFloppy == 0) g_nSectorDrive1 = -1;
    else                    g_nSectorDrive2 = -1;
  }

  snprintf( g_sTrackDrive1 , sizeof(g_sTrackDrive1 ), "%2d", g_nTrackDrive1 );
  if (g_nSectorDrive1 < 0) snprintf( g_sSectorDrive1, sizeof(g_sSectorDrive1), "??" );
  else                     snprintf( g_sSectorDrive1, sizeof(g_sSectorDrive1), "%2d", g_nSectorDrive1 );

  snprintf( g_sTrackDrive2 , sizeof(g_sTrackDrive2),  "%2d", g_nTrackDrive2 );
  if (g_nSectorDrive2 < 0) snprintf( g_sSectorDrive2, sizeof(g_sSectorDrive2), "??" );
  else                     snprintf( g_sSectorDrive2, sizeof(g_sSectorDrive2), "%2d", g_nSectorDrive2 );

  FrameRefresh();
}

void FrameRefreshStatus(int x, bool)
{
  // std::cerr << "Status: " << x << std::endl;
}

void VideoInitialize()
{
  setlocale(LC_ALL, "");
  initscr();

  grColors.reset(new GRColors(20, 20));

  curs_set(0);
  signal(SIGINT, sig_handler);

  noecho();
  cbreak();
  set_escdelay(0);

  frame.reset(newwin(1 + 24 + 1, 1 + 40 + 1, 0, 0), delwin);
  box(frame.get(), 0 , 0);
  wtimeout(frame.get(), 0);
  keypad(frame.get(), true);
  wrefresh(frame.get());

  borders.reset(newwin(1 + 24 + 1, 1 + 40 + 1, 0, 43), delwin);
  box(borders.get(), 0 , 0);
  wrefresh(borders.get());

  buffer.reset(newwin(24, 40, 1, 44), delwin);
  scrollok(buffer.get(), true);
  wrefresh(buffer.get());
}

void VideoRedrawScreen()
{
  const int displaypage2 = (SW_PAGE2) == 0 ? 0 : 1;

  g_pHiresBank1 = MemGetAuxPtr (0x2000 << displaypage2);
  g_pHiresBank0 = MemGetMainPtr(0x2000 << displaypage2);
  g_pTextBank1  = MemGetAuxPtr (0x400  << displaypage2);
  g_pTextBank0  = MemGetMainPtr(0x400  << displaypage2);

  VideoUpdateFuncPtr_t update = SW_TEXT
    ? SW_80COL
    ? Update80ColCell
    : Update40ColCell
    : SW_HIRES
    ? (SW_DHIRES && SW_80COL)
    ? UpdateDHiResCell
    : UpdateHiResCell
    : (SW_DHIRES && SW_80COL)
    ? UpdateDLoResCell
    : UpdateLoResCell;

  int  y        = 0;
  int  ypixel   = 0;
  while (y < 20) {
    int offset = ((y & 7) << 7) + ((y >> 3) * 40);
    int x      = 0;
    int xpixel = 0;
    while (x < 40) {
      update(x, y, xpixel, ypixel, offset + x);
      ++x;
      xpixel += 14;
    }
    ++y;
    ypixel += 16;
  }

  if (SW_MIXED)
    update = SW_80COL ? Update80ColCell
      : Update40ColCell;

  while (y < 24) {
    int offset = ((y & 7) << 7) + ((y >> 3) * 40);
    int x      = 0;
    int xpixel = 0;
    while (x < 40) {
      update(x, y, xpixel, ypixel, offset + x);
      ++x;
      xpixel += 14;
    }
    ++y;
    ypixel += 16;
  }

  wrefresh(frame.get());
}

void ProcessKeyboard()
{
  int ch = wgetch(frame.get());
  if (ch != ERR)
  {
    switch (ch)
    {
    case '\n':
      ch = 0x0d; // ENTER
      break;
    case KEY_BACKSPACE:
    case KEY_LEFT:
      ch = 0x08;
      break;
    case KEY_RIGHT:
      ch = 0x15;
      break;
    case KEY_UP:
      ch = 0x0b;
      break;
    case KEY_DOWN:
      ch = 0x0a;
      break;
    case 0x14a: // DEL
      ch = 0x7f;
      break;
    default:
      if (ch >= 0x80)
      {
	ch = ERR;
      }
      else
      {
	// Standard for Apple II is Upper case
	if (ch >= 'A' && ch <= 'Z')
	{
	  ch += 'a' - 'A';
	}
	else if (ch >= 'a' && ch <= 'z')
	{
	  ch -= 'a' - 'A';
	}
      }
    }

    if (ch != ERR)
    {
      nextKey = ch | 0x80;
      keyReady = true;
    }
  }
}

BYTE    KeybGetKeycode ()
{
  return 0;
}

BYTE __stdcall KeybReadData (WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
{
  return nextKey;
}

BYTE __stdcall KeybReadFlag (WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nCyclesLeft)
{
  BYTE result = keyReady ? nextKey : 0;
  nextKey = 0;
  return result;
}