*/

#include "common.h"

#include <string.h>

#if HAVE_TIOCGWINSZ || HAVE_TIOCGSIZE

# if (!defined(GWINSZ_IN_SYS_IOCTL) || HAVE_TIOCGSIZE) && HAVE_TERMIOS_H

#  include <termios.h>

# endif

# if HAVE_SYS_IOCTL_H

#  include <sys/ioctl.h>

# endif

#endif

#include "frobtadsappcurses.h"

#include "colors.h"

/* Service routine.  Gets the terminal's size.

 * On success, stores the terminal dimensions in 'width' and

 * 'height' and returns true.  On failure, returns false and

 * 'width' nor 'height' are modified.

 */

static bool

getTermSize( unsigned& width, unsigned& height )

{

	// If the system has support for the TIOCGWINSZ or TIOCGSIZE

	// ioctl, use it to obtain the terminal's dimensions.

	int res = -1;

	unsigned w = 0;

	unsigned h = 0;

#if HAVE_TIOCGWINSZ

	winsize size;

	size.ws_col = size.ws_row = 0;

	res = ioctl(0, TIOCGWINSZ, &size);

	w = size.ws_col;

	h = size.ws_row;

#elif HAVE_TIOCGSIZE

	ttysize size;

	size.ts_cols = size.ts_lines = 0;

	res = ioctl(0, TIOCGSIZE, &size);

	w = size.ts_cols;

	h = size.ts_lines;

#endif

	if (res < 0 or w == 0 or h == 0) {

		// The call failed or the system doesn't seem to know

		// the terminal's size.

		return false;

	}

	width = w;

	height = h;

	return true;

}

FrobTadsApplicationCurses::FrobTadsApplicationCurses( const FrobOptions& opts )

: FrobTadsApplication(opts), fGameWindow(0), fDispBuf(0)

{

	// Before starting curses, we set the LINES and COLUMNS env.

	// variables to a "maximum" value.  This is needed in case we're

	// running on a system with an old/broken curses implementation

	// (Solaris curses, for example).  This forces curses to

	// allocate enough internal memory for the windows in case the

	// terminal gets resized.  Note that we only do this if

	// detection of the terminal size is possible at all.

#if HAVE_PUTENV

	unsigned bogusX, bogusY; // Dummies.

	if (getTermSize(bogusX, bogusY)) {

		// The strings become part of the environment; they have to be

		// static.

		static char lines[] = "LINES=225";

		static char columns[] = "COLUMNS=300";

		putenv(lines);

		putenv(columns);

	}

#endif

	// Fire-up curses.

	initscr();

	// Make characters typed by the user immediately available to

	// the program.

	cbreak();

	// Tell courses not to echo user-input (TADS does the echoing).

	noecho();

	// Hide the cursor.  This avoids the "crazy cursor jumping"

	// problem on *really* slow terminals, as TADS constantly moves

	// the cursor all over the place.

	curs_set(0);

	// Tell courses not to try to translate the RETURN/ENTER key on

	// input (or else getch() and friends would never report that

	// key), and the '\n' character on output (since the osgen layer

	// handles newlines).

	nonl();

	// Initialize colors if we want color support and the terminal supports it.

	if ((opts.useColors and has_colors()) or opts.forceColors) {

		this->fColorsEnabled = true;

		start_color();

		// Assign terminal default foreground/background colors

		// to color number -1 / color pair 0.

#ifdef HAVE_USE_DEFAULT_COLORS

		if (opts.defColors) {

			use_default_colors();

		}

#endif

		// Initialize the curses color-pairs we use.

		//

		// This is paranoia, but better to make sure that curses

		// will use the right colors.  The paranoid part of this

		// is that we assume that there might be some curses

		// version out there that does not use monotonically

		// increasing values for the COLOR_* symbols.

		init_pair(makeColorPair(FROB_BLACK,   FROB_BLACK), COLOR_BLACK,   COLOR_BLACK);

		init_pair(makeColorPair(FROB_RED,     FROB_BLACK), COLOR_RED,     COLOR_BLACK);

		init_pair(makeColorPair(FROB_GREEN,   FROB_BLACK), COLOR_GREEN,   COLOR_BLACK);

		init_pair(makeColorPair(FROB_YELLOW,  FROB_BLACK), COLOR_YELLOW,  COLOR_BLACK);

		init_pair(makeColorPair(FROB_BLUE,    FROB_BLACK), COLOR_BLUE,    COLOR_BLACK);

		init_pair(makeColorPair(FROB_MAGENTA, FROB_BLACK), COLOR_MAGENTA, COLOR_BLACK);

		init_pair(makeColorPair(FROB_CYAN,    FROB_BLACK), COLOR_CYAN,    COLOR_BLACK);

		// White on black is wired to color pair 0 by

		// definition; we can't and don't need to initialize it.

		//init_pair(makeColorPair(FROB_WHITE,   FROB_BLACK), COLOR_WHITE,   COLOR_BLACK);

		init_pair(makeColorPair(FROB_BLACK,   FROB_RED), COLOR_BLACK,   COLOR_RED);

		init_pair(makeColorPair(FROB_RED,     FROB_RED), COLOR_RED,     COLOR_RED);

		init_pair(makeColorPair(FROB_GREEN,   FROB_RED), COLOR_GREEN,   COLOR_RED);

		init_pair(makeColorPair(FROB_YELLOW,  FROB_RED), COLOR_YELLOW,  COLOR_RED);

		init_pair(makeColorPair(FROB_BLUE,    FROB_RED), COLOR_BLUE,    COLOR_RED);

		init_pair(makeColorPair(FROB_MAGENTA, FROB_RED), COLOR_MAGENTA, COLOR_RED);

		init_pair(makeColorPair(FROB_CYAN,    FROB_RED), COLOR_CYAN,    COLOR_RED);

		init_pair(makeColorPair(FROB_WHITE,   FROB_RED), COLOR_WHITE,   COLOR_RED);

		init_pair(makeColorPair(FROB_BLACK,   FROB_GREEN), COLOR_BLACK,   COLOR_GREEN);

		init_pair(makeColorPair(FROB_RED,     FROB_GREEN), COLOR_RED,     COLOR_GREEN);

		init_pair(makeColorPair(FROB_GREEN,   FROB_GREEN), COLOR_GREEN,   COLOR_GREEN);

		init_pair(makeColorPair(FROB_YELLOW,  FROB_GREEN), COLOR_YELLOW,  COLOR_GREEN);

		init_pair(makeColorPair(FROB_BLUE,    FROB_GREEN), COLOR_BLUE,    COLOR_GREEN);

		init_pair(makeColorPair(FROB_MAGENTA, FROB_GREEN), COLOR_MAGENTA, COLOR_GREEN);

		init_pair(makeColorPair(FROB_CYAN,    FROB_GREEN), COLOR_CYAN,    COLOR_GREEN);

		init_pair(makeColorPair(FROB_WHITE,   FROB_GREEN), COLOR_WHITE,   COLOR_GREEN);

		init_pair(makeColorPair(FROB_BLACK,   FROB_YELLOW), COLOR_BLACK,   COLOR_YELLOW);

		init_pair(makeColorPair(FROB_RED,     FROB_YELLOW), COLOR_RED,     COLOR_YELLOW);

		init_pair(makeColorPair(FROB_GREEN,   FROB_YELLOW), COLOR_GREEN,   COLOR_YELLOW);

		init_pair(makeColorPair(FROB_YELLOW,  FROB_YELLOW), COLOR_YELLOW,  COLOR_YELLOW);

		init_pair(makeColorPair(FROB_BLUE,    FROB_YELLOW), COLOR_BLUE,    COLOR_YELLOW);

		init_pair(makeColorPair(FROB_MAGENTA, FROB_YELLOW), COLOR_MAGENTA, COLOR_YELLOW);

		init_pair(makeColorPair(FROB_CYAN,    FROB_YELLOW), COLOR_CYAN,    COLOR_YELLOW);

		init_pair(makeColorPair(FROB_WHITE,   FROB_YELLOW), COLOR_WHITE,   COLOR_YELLOW);

		init_pair(makeColorPair(FROB_BLACK,   FROB_BLUE), COLOR_BLACK,   COLOR_BLUE);

		init_pair(makeColorPair(FROB_RED,     FROB_BLUE), COLOR_RED,     COLOR_BLUE);

		init_pair(makeColorPair(FROB_GREEN,   FROB_BLUE), COLOR_GREEN,   COLOR_BLUE);

		init_pair(makeColorPair(FROB_YELLOW,  FROB_BLUE), COLOR_YELLOW,  COLOR_BLUE);

		init_pair(makeColorPair(FROB_BLUE,    FROB_BLUE), COLOR_BLUE,    COLOR_BLUE);

		init_pair(makeColorPair(FROB_MAGENTA, FROB_BLUE), COLOR_MAGENTA, COLOR_BLUE);

		init_pair(makeColorPair(FROB_CYAN,    FROB_BLUE), COLOR_CYAN,    COLOR_BLUE);

		init_pair(makeColorPair(FROB_WHITE,   FROB_BLUE), COLOR_WHITE,   COLOR_BLUE);

		init_pair(makeColorPair(FROB_BLACK,   FROB_MAGENTA), COLOR_BLACK,   COLOR_MAGENTA);

		init_pair(makeColorPair(FROB_RED,     FROB_MAGENTA), COLOR_RED,     COLOR_MAGENTA);

		init_pair(makeColorPair(FROB_GREEN,   FROB_MAGENTA), COLOR_GREEN,   COLOR_MAGENTA);

		init_pair(makeColorPair(FROB_YELLOW,  FROB_MAGENTA), COLOR_YELLOW,  COLOR_MAGENTA);

		init_pair(makeColorPair(FROB_BLUE,    FROB_MAGENTA), COLOR_BLUE,    COLOR_MAGENTA);

		init_pair(makeColorPair(FROB_MAGENTA, FROB_MAGENTA), COLOR_MAGENTA, COLOR_MAGENTA);

		init_pair(makeColorPair(FROB_CYAN,    FROB_MAGENTA), COLOR_CYAN,    COLOR_MAGENTA);

		init_pair(makeColorPair(FROB_WHITE,   FROB_MAGENTA), COLOR_WHITE,   COLOR_MAGENTA);

		init_pair(makeColorPair(FROB_BLACK,   FROB_CYAN), COLOR_BLACK,   COLOR_CYAN);

		init_pair(makeColorPair(FROB_RED,     FROB_CYAN), COLOR_RED,     COLOR_CYAN);

		init_pair(makeColorPair(FROB_GREEN,   FROB_CYAN), COLOR_GREEN,   COLOR_CYAN);

		init_pair(makeColorPair(FROB_YELLOW,  FROB_CYAN), COLOR_YELLOW,  COLOR_CYAN);

		init_pair(makeColorPair(FROB_BLUE,    FROB_CYAN), COLOR_BLUE,    COLOR_CYAN);

		init_pair(makeColorPair(FROB_MAGENTA, FROB_CYAN), COLOR_MAGENTA, COLOR_CYAN);

		init_pair(makeColorPair(FROB_CYAN,    FROB_CYAN), COLOR_CYAN,    COLOR_CYAN);

		init_pair(makeColorPair(FROB_WHITE,   FROB_CYAN), COLOR_WHITE,   COLOR_CYAN);

		init_pair(makeColorPair(FROB_BLACK,   FROB_WHITE), COLOR_BLACK,   COLOR_WHITE);

		init_pair(makeColorPair(FROB_RED,     FROB_WHITE), COLOR_RED,     COLOR_WHITE);

		init_pair(makeColorPair(FROB_GREEN,   FROB_WHITE), COLOR_GREEN,   COLOR_WHITE);

		init_pair(makeColorPair(FROB_YELLOW,  FROB_WHITE), COLOR_YELLOW,  COLOR_WHITE);

		init_pair(makeColorPair(FROB_BLUE,    FROB_WHITE), COLOR_BLUE,    COLOR_WHITE);

		init_pair(makeColorPair(FROB_MAGENTA, FROB_WHITE), COLOR_MAGENTA, COLOR_WHITE);

		init_pair(makeColorPair(FROB_CYAN,    FROB_WHITE), COLOR_CYAN,    COLOR_WHITE);

		init_pair(makeColorPair(FROB_WHITE,   FROB_WHITE), COLOR_WHITE,   COLOR_WHITE);

	}

}

FrobTadsApplicationCurses::~FrobTadsApplicationCurses()

{

	// Enable the cursor.

	curs_set(0);

	// Flush any pending output so we won't lose any "thanks for

	// playing" messages when "pausing prior to exit" is disabled.

	if (not this->options.exitPause) this->fGameWindow->flush();

	// Delete our windows, if we have any.

	if (this->fGameWindow != 0) delete this->fGameWindow;

	// Shut down curses.

	endwin();

	// Delete our optimization buffer.

	delete[] this->fDispBuf;

}

void

FrobTadsApplicationCurses::init()

{

	// Delete the current window, if we have one.

	if (this->fGameWindow != 0) delete this->fGameWindow;

	// Create the main window.  Make it fill the whole terminal.  We

	// initialize the dimensions to 0 in case getTermSize() is

	// unable to detect the actual size, since in curses/ncurses 0

	// for width and height actually means "fullscreen".

	unsigned width = 0;

	unsigned height = 0;

	bool sizeDetected = getTermSize(width, height);

	if (sizeDetected) {

		// Update the environment in case we're running inside

		// an old/broken terminal or are using an old/broken

		// version of curses.

#if HAVE_PUTENV

		// Note that the strings have to be static, since

		// putenv() does not always copy the string arguments

		// but points the environment to the application's

		// address space (and therefore the application would

		// segfault if the strings were not static).

		static char linesEnv[32];

		static char columnsEnv[32];

		char tmp[16];

		strcpy(linesEnv, "LINES=");

		strcpy(columnsEnv, "COLUMNS=");

		sprintf(tmp, "%u", height);

		strcat(linesEnv, tmp);

		sprintf(tmp, "%u", width);

		strcat(columnsEnv, tmp);

		// Normally, since the strings are part of the

		// environment, we would need to use putenv() only once;

		// changing the strings later would also change the

		// environment, since the strings are part of it.

		// However, not every system follows the standard, so we

		// need to putenv() the strings over and over again.

		putenv(linesEnv);

		putenv(columnsEnv);

		// Enforce the detected size upon curses.

		// TODO: Is this needed?  Or even allowed?  For now, we

		// assume it's neither.

		//COLS = width;

		//LINES = height;

#endif

	}

	// Reset curses, in case the terminal's size has changed.

	endwin();

	refresh();

	// Fixes problems with old curses versions.

	wclear(stdscr);

	// Create the window.

	this->fGameWindow = new FrobTadsWindow(height, width, 0, 0);

	// Disable scrolling.

	this->fGameWindow->enableScrolling(false);

	// Tell the window to recognize keypad keys (function keys,

	// cursor-keys, etc.) during input.

	this->fGameWindow->keypadMode(true);

	// Enable 8-bit characters during input.

	this->fGameWindow->input8bit(true);

	// Create the buffer that we use to optimize output.

	if (this->fDispBuf != 0) delete[] this->fDispBuf;

	this->fDispBuf = new chtype[this->fGameWindow->width() + 1];

	// Explicitly mark the window as touched, to work around a

	// curses color and screen corruption issue.

	this->fGameWindow->touch();

	// Fix for curses color corruption problem.  The window is

	// cleared to a color (other than black and white) which contrasts

	// with the normal background color.

	if (sizeDetected) {

		int fillcolor;

		if (this->options.bgColor == FROB_BLUE) {

			fillcolor = ossgetcolor(OSGEN_COLOR_WHITE, OSGEN_COLOR_RED, 0, 0);

		} else {

			fillcolor = ossgetcolor(OSGEN_COLOR_WHITE, OSGEN_COLOR_BLUE, 0, 0);

		}

		ossclr(0, 0, height - 1, width - 1, fillcolor);

		this->fGameWindow->flush();

	}

}

void

FrobTadsApplicationCurses::clear( int top, int left, int bottom, int right, int attrs )

{

	const chtype c = attrs | ' ';

	for (int y = top; y <= bottom; ++y) {

		for (int x = left; x <= right; ++x) {

			this->fGameWindow->printChar(y, x, c);

		}

	}

}

void

FrobTadsApplicationCurses::scrollRegionUp( int top, int left, int bottom, int right, int attrs )

{

	// Old curses versions might break when using overlapping

	// windows, so we do the scrolling by hand.

	for (int y = bottom; y > top; --y) {

		for (int x = left; x <= right; ++x) {

			const chtype c = this->fGameWindow->charAt(y-1, x);

			this->fGameWindow->printChar(y, x, c);

		}

	}

	// Clear the last line.

	const chtype c = attrs | ' ';

	for (int i = left; i <= right; ++i) this->fGameWindow->printChar(top, i, c);

	// If soft-scrolling is enabled, update the display so that we

	// have a visible scrolling-effect.

	if (this->options.softScroll) this->fGameWindow->flush();

}

void

FrobTadsApplicationCurses::scrollRegionDown( int top, int left, int bottom, int right, int attrs )

{

	// This works like scrollRegionUp(), just the other way around.

	for (int y = top; y < bottom; ++y) {

		for (int x = left; x <= right; ++x) {

			this->fGameWindow->printChar(y, x, this->fGameWindow->charAt(y+1, x));

		}

	}

	const chtype c = attrs | ' ';

	for (int i = left; i <= right; ++i) this->fGameWindow->printChar(bottom, i, c);

	if (this->options.softScroll) this->fGameWindow->flush();

}

int

FrobTadsApplicationCurses::getRawChar( bool cursorVisible, int timeout )

{

	// The character we read.

	int c;

	// Tell osgen to check if it should redraw the screen.

	osssb_redraw_if_needed();

	// Some curses versions don't automatically update the display

	// prior to input, so we must explicitly request it.

	this->fGameWindow->flush();

	// Prepare for timed input.

	this->fGameWindow->setTimeout(timeout);

	this->fRemainingTimeout = timeout;

	// Enable the cursor, if needed.  We won't enable it if the

	// timeout is very small, even if the caller requested it.

	// "Small" means under 1 second, which is what most terminals

	// use for a cursor blink.

	if (cursorVisible and (timeout > 1000 or timeout < 1)) curs_set(1);

	// On some systems, ncurses is configured to supply its own

	// SIGWINCH handler.  If this is the case, getch() returns

	// KEY_RESIZE when the terminal has been resized.  We can't rely

	// on this behavior to handle screen resizes, but we must still

	// recognize this return code; here we simply ignore it.  Note

	// that curses doesn't know anything about KEY_RESIZE; it's an

	// ncurses thing.  We only check for it if it is defined.

#ifdef KEY_RESIZE

	while ((c = this->fGameWindow->getChar()) == KEY_RESIZE)

		;

#else

	c = this->fGameWindow->getChar();

#endif

	this->fRemainingTimeout = 0;

	// Some terminals don't return KEY_BACKSPACE for the

	// backspace-key, but some opaque platform-specific code.  If

	// this is the case, map it to KEY_BACKSPACE.

	if (c == erasechar()) c = KEY_BACKSPACE;

	// Similarly for KEY_DL.

	if (c == killchar()) c = KEY_DL;

	curs_set(0);

	return c;