/*
** SCCS ID:	@(#)cio.c	2.10	1/22/25
**
** @file	cio.c
**
** @author	Warren R. Carithers
**
** Based on:  c_io.c 1.13 (Ken Reek, Jon Coles, Warren R. Carithers)
**
** Console I/O routines
**
**  This module implements a simple set of input and output routines
**  for the console screen and keyboard on the machines in the DSL.
**  Refer to the header file comments for complete details.
**
** Naming conventions:
**
**  Externally-visible functions have names beginning with the
**  characters "cio_".
**
*/

#include <cio.h>
#include <lib.h>
#include <support.h>
#include <x86/arch.h>
#include <x86/pic.h>
#include <x86/ops.h>

/*
** Bit masks for the lower five and eight bits of a value
*/
#define	BMASK5		0x1f
#define	BMASK8		0xff

/*
** Video parameters
*/
#define	SCREEN_MIN_X	0
#define	SCREEN_MIN_Y	0
#define	SCREEN_X_SIZE	80
#define	SCREEN_Y_SIZE	25
#define	SCREEN_MAX_X	( SCREEN_X_SIZE - 1 )
#define	SCREEN_MAX_Y	( SCREEN_Y_SIZE - 1 )

/*
** Video state
*/
static unsigned int scroll_min_x, scroll_min_y;
static unsigned int scroll_max_x, scroll_max_y;
static unsigned int curr_x, curr_y;
static unsigned int min_x, min_y;
static unsigned int max_x, max_y;

// pointer to input notification function
static void (*notify)(int);

#ifdef  SA_DEBUG
#include <stdio.h>
#define cio_putchar   putchar
#define cio_puts(x)   fputs( x, stdout )
#endif


/*
** VGA definitions.
*/

// calculate the memory address of a specific character position
// within VGA memory
#define VIDEO_ADDR(x,y) ( unsigned short * ) \
	( VID_BASE_ADDR + 2 * ( (y) * SCREEN_X_SIZE + (x) ) )

// port addresses
#define	VGA_CTRL_IX_ADDR		0x3d4
#	define	VGA_CTRL_CUR_HIGH	0x0e	// cursor location, high byte
#	define	VGA_CTRL_CUR_LOW	0x0f	// cursor location, low byte
#define	VGA_CTRL_IX_DATA		0x3d5

// attribute bits
#define	VGA_ATT_BBI		0x80	// blink, or background intensity
#define	VGA_ATT_BGC		0x70	// background color
#define	VGA_ATT_FICS	0x80	// foreground intensity or char font select
#define	VGA_ATT_FGC		0x70	// foreground color

// color selections
#define	VGA_BG_BLACK	0x0000	// background colors
#define	VGA_BG_BLUE		0x1000
#define	VGA_BG_GREEN	0x2000
#define	VGA_BG_CYAN		0x3000
#define	VGA_BG_RED		0x4000
#define	VGA_BG_MAGENTA	0x5000
#define	VGA_BG_BROWN	0x6000
#define	VGA_BG_WHITE	0x7000

#define	VGA_FG_BLACK	0x0000	// foreground colors
#define	VGA_FG_BLUE		0x0100
#define	VGA_FG_GREEN	0x0200
#define	VGA_FG_CYAN		0x0300
#define	VGA_FG_RED		0x0400
#define	VGA_FG_MAGENTA	0x0500
#define	VGA_FG_BROWN	0x0600
#define	VGA_FG_WHITE	0x0700

// color combinations
#define	VGA_WHITE_ON_BLACK		(VGA_FG_WHITE | VGA_BG_BLACK)
#define	VGA_BLACK_ON_WHITE		(VGA_FG_BLACK | VGA_BG_WHITE)

/*
** Internal support routines.
*/

/*
** setcursor: set the cursor location (screen coordinates)
*/
static void setcursor( void ) {
	unsigned addr;
	unsigned int y = curr_y;

	if( y > scroll_max_y ) {
		y = scroll_max_y;
	}

	addr = (unsigned)( y * SCREEN_X_SIZE + curr_x );

	outb( VGA_CTRL_IX_ADDR, VGA_CTRL_CUR_HIGH );
	outb( VGA_CTRL_IX_DATA, ( addr >> 8 ) & BMASK8 );
	outb( VGA_CTRL_IX_ADDR, VGA_CTRL_CUR_LOW );
	outb( VGA_CTRL_IX_DATA, addr & BMASK8 );
}

/*
** putchar_at: physical output to the video memory
*/
static void putchar_at( unsigned int x, unsigned int y, unsigned int c ) {
	/*
	** If x or y is too big or small, don't do any output.
	*/
	if( x <= max_x && y <= max_y ) {
		unsigned short *addr = VIDEO_ADDR( x, y );

		/*
		** The character may have attributes associated with it; if
		** so, use those, otherwise use white on black.
		*/
		c &= 0xffff;	// keep only the lower bytes
		if( c > BMASK8 ) {
			*addr = (unsigned short)c;
		} else {
			*addr = (unsigned short)c | VGA_WHITE_ON_BLACK;
		}
	}
}

/*
** Globally-visible support routines.
*/

/*
** Set the scrolling region
*/
void cio_setscroll( unsigned int s_min_x, unsigned int s_min_y,
					  unsigned int s_max_x, unsigned int s_max_y ) {
	scroll_min_x = bound( min_x, s_min_x, max_x );
	scroll_min_y = bound( min_y, s_min_y, max_y );
	scroll_max_x = bound( scroll_min_x, s_max_x, max_x );
	scroll_max_y = bound( scroll_min_y, s_max_y, max_y );
	curr_x = scroll_min_x;
	curr_y = scroll_min_y;
	setcursor();
}

/*
** Cursor movement in the scroll region
*/
void cio_moveto( unsigned int x, unsigned int y ) {
	curr_x = bound( scroll_min_x, x + scroll_min_x, scroll_max_x );
	curr_y = bound( scroll_min_y, y + scroll_min_y, scroll_max_y );
	setcursor();
}

/*
** The putchar family
*/
void cio_putchar_at( unsigned int x, unsigned int y, unsigned int c ) {
	if( ( c & 0x7f ) == '\n' ) {
		unsigned int limit;

		/*
		** If we're in the scroll region, don't let this loop
		** leave it. If we're not in the scroll region, don't
		** let this loop enter it.
		*/
		if( x > scroll_max_x ) {
			limit = max_x;
		}
		else if( x >= scroll_min_x ) {
			limit = scroll_max_x;
		}
		else {
			limit = scroll_min_x - 1;
		}
		while( x <= limit ) {
			putchar_at( x, y, ' ' );
			x += 1;
		}
	}
	else {
		putchar_at( x, y, c );
	}
}

#ifndef SA_DEBUG
void cio_putchar( unsigned int c ) {
	/*
	** If we're off the bottom of the screen, scroll the window.
	*/
	if( curr_y > scroll_max_y ) {
		cio_scroll( curr_y - scroll_max_y );
		curr_y = scroll_max_y;
	}

	switch( c & BMASK8 ) {
	case '\n':
		/*
		** Erase to the end of the line, then move to new line
		** (actual scroll is delayed until next output appears).
		*/
		while( curr_x <= scroll_max_x ) {
			putchar_at( curr_x, curr_y, ' ' );
			curr_x += 1;
		}
		curr_x = scroll_min_x;
		curr_y += 1;
		break;

	case '\r':
		curr_x = scroll_min_x;
		break;

	default:
		putchar_at( curr_x, curr_y, c );
		curr_x += 1;
		if( curr_x > scroll_max_x ) {
			curr_x = scroll_min_x;
			curr_y += 1;
		}
		break;
	}
	setcursor();
}
#endif

/*
** The puts family
*/
void cio_puts_at( unsigned int x, unsigned int y, const char *str ) {
	unsigned int ch;

	while( (ch = *str++) != '\0' && x <= max_x ) {
		cio_putchar_at( x, y, ch );
		x += 1;
	}
}

#ifndef SA_DEBUG
void cio_puts( const char *str ) {
	unsigned int ch;

	while( (ch = *str++) != '\0' ) {
		cio_putchar( ch );
	}
}
#endif

/*
** Write a "sized" buffer (like cio_puts(), but no NUL)
*/
void cio_write( const char *buf, int length ) {
	for( int i = 0; i < length; ++i ) {
		cio_putchar( buf[i] );
	}
}

void cio_clearscroll( void ) {
	unsigned int nchars = scroll_max_x - scroll_min_x + 1;
	unsigned int l;
	unsigned int c;

	for( l = scroll_min_y; l <= scroll_max_y; l += 1 ) {
		unsigned short *to = VIDEO_ADDR( scroll_min_x, l );

		for( c = 0; c < nchars; c += 1 ) {
			*to++ = ' ' | 0x0700;
		}
	}
}

void cio_clearscreen( void ) {
	unsigned short *to = VIDEO_ADDR( min_x, min_y );
	unsigned int    nchars = ( max_y - min_y + 1 ) * ( max_x - min_x + 1 );

	while( nchars > 0 ) {
		*to++ = ' ' | 0x0700;
		nchars -= 1;
	}
}


void cio_scroll( unsigned int lines ) {
	unsigned short *from;
	unsigned short *to;
	int nchars = scroll_max_x - scroll_min_x + 1;
	int line, c;

	/*
	** If # of lines is the whole scrolling region or more, just clear.
	*/
	if( lines > scroll_max_y - scroll_min_y ) {
		cio_clearscroll();
		curr_x = scroll_min_x;
		curr_y = scroll_min_y;
		setcursor();
		return;
	}

	/*
	** Must copy it line by line.
	*/
	for( line = scroll_min_y; line <= scroll_max_y - lines; line += 1 ) {
		from = VIDEO_ADDR( scroll_min_x, line + lines );
		to = VIDEO_ADDR( scroll_min_x, line );
		for( c = 0; c < nchars; c += 1 ) {
			*to++ = *from++;
		}
	}

	for( ; line <= scroll_max_y; line += 1 ) {
		to = VIDEO_ADDR( scroll_min_x, line );
		for( c = 0; c < nchars; c += 1 ) {
			*to++ = ' ' | 0x0700;
		}
	}
}

static int mypad( int x, int y, int extra, int padchar ) {
	while( extra > 0 ) {
		if( x != -1 || y != -1 ) {
			cio_putchar_at( x, y, padchar );
			x += 1;
		}
		else {
			cio_putchar( padchar );
		}
		extra -= 1;
	}
	return x;
}

static int mypadstr( int x, int y, char *str, int len, int width,
				   int leftadjust, int padchar ) {
	int extra;

	if( len < 0 ) {
		len = strlen( str );
	}
	extra = width - len;
	if( extra > 0 && !leftadjust ) {
		x = mypad( x, y, extra, padchar );
	}
	if( x != -1 || y != -1 ) {
		cio_puts_at( x, y, str );
		x += len;
	}
	else {
		cio_puts( str );
	}
	if( extra > 0 && leftadjust ) {
		x = mypad( x, y, extra, padchar );
	}
	return x;
}

static void do_printf( int x, int y, char **f ) {
	char *fmt = *f;
	int  *ap;
	char buf[ 12 ];
	char ch;
	char *str;
	int  leftadjust;
	int  width;
	int  len;
	int  padchar;

	/*
	** Get characters from the format string and process them
	*/

	ap = (int *)( f + 1 );

	while( (ch = *fmt++) != '\0' ) {

		/*
		** Is it the start of a format code?
		*/

		if( ch == '%' ) {

			/*
			** Yes, get the padding and width options (if there).
			** Alignment must come at the beginning, then fill,
			** then width.
			*/

			leftadjust = 0;
			padchar = ' ';
			width = 0;

			ch = *fmt++;

			if( ch == '-' ) {
				leftadjust = 1;
				ch = *fmt++;
			}

			if( ch == '0' ) {
				padchar = '0';
				ch = *fmt++;
			}

			while( ch >= '0' && ch <= '9' ) {
				width *= 10;
				width += ch - '0';
				ch = *fmt++;
			}

			/*
			** What data type do we have?
			*/
			switch( ch ) {

			case 'c':
				// ch = *( (int *)ap )++;
				ch = *ap++;
				buf[ 0 ] = ch;
				buf[ 1 ] = '\0';
				x = mypadstr( x, y, buf, 1, width, leftadjust, padchar );
				break;

			case 'd':
				// len = cvtdec( buf, *( (int *)ap )++ );
				len = cvtdec( buf, *ap++ );
				x = mypadstr( x, y, buf, len, width, leftadjust, padchar );
				break;

			case 's':
				// str = *( (char **)ap )++;
				str = (char *) (*ap++);
				x = mypadstr( x, y, str, -1, width, leftadjust, padchar );
				break;

			case 'x':
				// len = cvthex( buf, *( (int *)ap )++ );
				len = cvthex( buf, *ap++ );
				x = mypadstr( x, y, buf, len, width, leftadjust, padchar );
				break;

			case 'o':
				// len = cvtoct( buf, *( (int *)ap )++ );
				len = cvtoct( buf, *ap++ );
				x = mypadstr( x, y, buf, len, width, leftadjust, padchar );
				break;

			case 'u':
				len = cvtuns( buf, *ap++ );
				x = mypadstr( x, y, buf, len, width, leftadjust, padchar );
				break;

			}
		} else {

			/*
			** No - just print it normally.
			*/

			if( x != -1 || y != -1 ) {
				cio_putchar_at( x, y, ch );
				switch( ch ) {
				case '\n':
					y += 1;
					/* FALL THRU */

				case '\r':
					x = scroll_min_x;
					break;

				default:
					x += 1;
				}
			}
			else {
				cio_putchar( ch );
			}
		}
	}
}

void cio_printf_at( unsigned int x, unsigned int y, char *fmt, ... ) {
	do_printf( x, y, &fmt );
}

void cio_printf( char *fmt, ... ) {
	do_printf( -1, -1, &fmt );
}

/*
** These are the "standard" IBM AT "Set 1" keycodes.
*/

static unsigned char scan_code[ 2 ][ 128 ] = {
	{   // unshifted characters
/* 00-07 */ '\377', '\033', '1',    '2',    '3',    '4',    '5',    '6',
/* 08-0f */ '7',    '8',    '9',    '0',    '-',    '=',    '\b',   '\t',
/* 10-17 */ 'q',    'w',    'e',    'r',    't',    'y',    'u',    'i',
/* 18-1f */ 'o',    'p',    '[',    ']',    '\n',   '\377', 'a',    's',
/* 20-27 */ 'd',    'f',    'g',    'h',    'j',    'k',    'l',    ';',
/* 28-2f */ '\'',   '`',    '\377', '\\',   'z',    'x',    'c',    'v',
/* 30-37 */ 'b',    'n',    'm',    ',',    '.',    '/',    '\377', '*',
/* 38-3f */ '\377', ' ',    '\377', '\377', '\377', '\377', '\377', '\377',
/* 40-47 */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '7',
/* 48-4f */ '8',    '9',    '-',    '4',    '5',    '6',    '+',    '1',
/* 50-57 */ '2',    '3',    '0',    '.',    '\377', '\377', '\377', '\377',
/* 58-5f */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377',
/* 60-67 */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377',
/* 68-6f */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377',
/* 70-77 */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377',
/* 78-7f */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377'
	},

	{   // shifted characters
/* 00-07 */ '\377', '\033', '!',    '@',    '#',    '$',    '%',    '^',
/* 08-0f */ '&',    '*',    '(',    ')',    '_',    '+',    '\b',   '\t',
/* 10-17 */ 'Q',    'W',    'E',    'R',    'T',    'Y',    'U',    'I',
/* 18-1f */ 'O',    'P',    '{',    '}',    '\n',   '\377', 'A',    'S',
/* 20-27 */ 'D',    'F',    'G',    'H',    'J',    'K',    'L',    ':',
/* 28-2f */ '"',    '~',    '\377', '|',    'Z',    'X',    'C',    'V',
/* 30-37 */ 'B',    'N',    'M',    '<',    '>',    '?',    '\377', '*',
/* 38-3f */ '\377', ' ',    '\377', '\377', '\377', '\377', '\377', '\377',
/* 40-47 */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '7',
/* 48-4f */ '8',    '9',    '-',    '4',    '5',    '6',    '+',    '1',
/* 50-57 */ '2',    '3',    '0',    '.',    '\377', '\377', '\377', '\377',
/* 58-5f */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377',
/* 60-67 */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377',
/* 68-6f */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377',
/* 70-77 */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377',
/* 78-7f */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377'
	}
};

/*
** Scan code masks
*/

// 'release' bit
#define	REL_BIT		0x80
#define	CODE_BITS	0x7f

#define	IS_PRESS(c)		(((c) & REL_BIT) == 0)
#define	IS_RELEASE(c)	(((c) & REL_BIT) != 0)

/*
** Scan codes for some special characters
*/

// escape code - followed by another code byte
#define	SCAN_ESC	0xe0

// shift keys:  press, release
#define	L_SHIFT_DN	0x2a
#define	R_SHIFT_DN	0x36
#define	L_SHIFT_UP	0xaa
#define	R_SHIFT_UP	0xb6

// control keys
#define	L_CTRL_DN	0x1d
#define	L_CTRL_UP	0x9d

/*
** I/O communication constants
*/
#define	KBD_DATA	0x60
#define	KBD_STATUS	0x64
#define	READY		0x1

/*
** Circular buffer for input characters.  Characters are inserted at
** next_space, and are removed at next_char.  Buffer is empty if
** these are equal.
*/
#define	C_BUFSIZE	200

static char input_buffer[ C_BUFSIZE ];
static volatile char *next_char = input_buffer;
static volatile char *next_space = input_buffer;

static volatile char *increment( volatile char *pointer ) {
	if( ++pointer >= input_buffer + C_BUFSIZE ) {
		pointer = input_buffer;
	}
	return pointer;
}

static int input_scan_code( int code ) {
	static  int shift = 0;
	static  int ctrl_mask = BMASK8;
	int rval = -1;

	/*
	** Do the shift processing
	*/
	code &= BMASK8;
	switch( code ) {
	case L_SHIFT_DN:
	case R_SHIFT_DN:
		shift = 1;
		break;

	case L_SHIFT_UP:
	case R_SHIFT_UP:
		shift = 0;
		break;

	case L_CTRL_DN:
		ctrl_mask = BMASK5;
		break;

	case L_CTRL_UP:
		ctrl_mask = BMASK8;
		break;

	default:
		/*
		** Process ordinary characters only on the press (to handle
		** autorepeat).  Ignore undefined scan codes.
		*/
		if( IS_PRESS(code) ) {
			code = scan_code[ shift ][ (int)code ];
			if( code != '\377' ) {
				volatile char   *next = increment( next_space );

				/*
				** Store character only if there's room
				*/
				rval = code & ctrl_mask;
				if( next != next_char ) {
					*next_space = code & ctrl_mask;
					next_space = next;
				}
			}
		}
	}
	return( rval );
}

static void keyboard_isr( int vector, int code ) {

	int data = inb( KBD_DATA );
	int val  = input_scan_code( data );

	// if there is a notification function, call it
	if( val != -1 && notify )
		notify( val );

	outb( PIC1_CMD, PIC_EOI );
}

int cio_getchar( void ) {
	char    c;
	int interrupts_enabled = r_eflags() & EFL_IF;

	while( next_char == next_space ) {
		if( !interrupts_enabled ) {
			/*
			** Must read the next keystroke ourselves.
			*/
			while( ( inb( KBD_STATUS ) & READY ) == 0 ) {
				;
			}
			(void) input_scan_code( inb( KBD_DATA ) );
		}
	}

	c = *next_char & BMASK8;
	next_char = increment( next_char );
	if( c != EOT ) {
		cio_putchar( c );
	}
	return c;
}

int cio_gets( char *buffer, unsigned int size ) {
	char    ch;
	int count = 0;

	while( size > 1 ) {
		ch = cio_getchar();
		if( ch == EOT ) {
			break;
		}
		*buffer++ = ch;
		count += 1;
		size -= 1;
		if( ch == '\n' ) {
			break;
		}
	}
	*buffer = '\0';
	return count;
}

int cio_input_queue( void ) {
	int n_chars = next_space - next_char;

	if( n_chars < 0 ) {
		n_chars += C_BUFSIZE;
	}
	return n_chars;
}

/*
** Initialization routines
*/
void cio_init( void (*fcn)(int) ) {
	/*
	** Screen dimensions
	*/
	min_x  = SCREEN_MIN_X;  
	min_y  = SCREEN_MIN_Y;
	max_x  = SCREEN_MAX_X;
	max_y  = SCREEN_MAX_Y;

	/*
	** Scrolling region
	*/
	scroll_min_x = SCREEN_MIN_X;
	scroll_min_y = SCREEN_MIN_Y;
	scroll_max_x = SCREEN_MAX_X;
	scroll_max_y = SCREEN_MAX_Y;

	/*
	** Initial cursor location
	*/
	curr_y = min_y;
	curr_x = min_x;
	setcursor();

	/*
	** Notification function (or NULL)
	*/
	notify = fcn;

	/*
	** Set up the interrupt handler for the keyboard
	*/
	install_isr( VEC_KBD, keyboard_isr );
}

#ifdef SA_DEBUG
int main() {
	cio_printf( "%d\n", 123 );
	cio_printf( "%d\n", -123 );
	cio_printf( "%d\n", 0x7fffffff );
	cio_printf( "%d\n", 0x80000001 );
	cio_printf( "%d\n", 0x80000000 );
	cio_printf( "x%14dy\n", 0x80000000 );
	cio_printf( "x%-14dy\n", 0x80000000 );
	cio_printf( "x%014dy\n", 0x80000000 );
	cio_printf( "x%-014dy\n", 0x80000000 );
	cio_printf( "%s\n", "xyz" );
	cio_printf( "|%10s|\n", "xyz" );
	cio_printf( "|%-10s|\n", "xyz" );
	cio_printf( "%c\n", 'x' );
	cio_printf( "|%4c|\n", 'y' );
	cio_printf( "|%-4c|\n", 'y' );
	cio_printf( "|%04c|\n", 'y' );
	cio_printf( "|%-04c|\n", 'y' );
	cio_printf( "|%3d|\n", 5 );
	cio_printf( "|%3d|\n", 54321 );
	cio_printf( "%x\n", 0x123abc );
	cio_printf( "|%04x|\n", 20 );
	cio_printf( "|%012x|\n", 0xfedcba98 );
	cio_printf( "|%-012x|\n", 0x76543210 );
}

int curr_x, curr_y, max_x, max_y;
#endif