<?php declare(strict_types=1);

namespace Aviat\Kilo;

use FFI;

use Aviat\Kilo\Enum\{
	C,
	Color,
	Highlight,
};

// ----------------------------------------------------------------------------
// ! Terminal size
// ----------------------------------------------------------------------------

/**
 * @TODO fix
 */
function get_cursor_position()
{
	write_stdout("\x1b[999C\x1b[999B");
	write_stdout("\x1b[6n");

	$rows = 0;
	$cols = 0;

	$buffer = read_stdout();

	$res = sscanf($buffer, '\x1b[%d;%dR', $rows, $cols);

	if ($res === -1 || $buffer[0] !== '\x1b' || $buffer[1] !== '[')
	{
		die('Failed to get screen size');
	}

	return [$rows, $cols];
}

function get_window_size()
{
	$ffi = get_ffi();

	$ws = $ffi->new('struct winsize');
	$res = $ffi->ioctl(C::STDOUT_FILENO, C::TIOCGWINSZ, FFI::addr($ws));

	if ($res === -1 || $ws->ws_col === 0)
	{
		return get_cursor_position();
	}

	return [$ws->ws_row, $ws->ws_col];
}

// ----------------------------------------------------------------------------
// ! C function/macro equivalents
// ----------------------------------------------------------------------------

/**
 * Do bit twiddling to convert a letter into
 * its Ctrl-letter equivalent ordinal ascii value
 *
 * @param string $char
 * @return int
 */
function ctrl_key(string $char): int
{
	if ( ! is_ascii($char))
	{
		return -1;
	}

	// b1,100,001 (a) & b0,011,111 (0x1f) = b0,000,001 (SOH)
	// b1,100,010 (b) & b0,011,111 (0x1f) = b0,000,010 (STX)
	// ...and so on
	return ord($char) & 0x1f;
}

/**
 * Does the one-character string contain an ascii ordinal value?
 *
 * @param string $single_char
 * @return bool
 */
function is_ascii(string $single_char): bool
{
	if (strlen($single_char) > 1)
	{
		return FALSE;
	}

	return ord($single_char) < 0x80;
}

/**
 * Does the one-character string contain an ascii control character?
 *
 * @param string $char
 * @return bool
 */
function is_cntrl(string $char): bool
{
	$c = ord($char);
	return is_ascii($char) && ( $c < 0x20 || $c === 0x7f );
}

/**
 * Does the one-character string contain an ascii number?
 *
 * @param string $char
 * @return bool
 */
function is_digit(string $char): bool
{
	$c = ord($char);
	return is_ascii($char) && ( $c > 0x2f && $c < 0x3a );
}

/**
 * Does the one-character string contain ascii whitespace?
 *
 * @param string $char
 * @return bool
 */
function is_space(string $char): bool
{
	$ws = [' ', "\t", "\n", "\r", "\xa", "\xb", "\xc"];
	return is_ascii($char) && in_array($char, $ws, TRUE);
}

// ----------------------------------------------------------------------------
// ! Helper functions
// ----------------------------------------------------------------------------

/**
 * A 'singleton' function to replace a global variable
 *
 * @return FFI
 */
function get_ffi(): FFI
{
	static $ffi;

	if ($ffi === NULL)
	{
		$ffi = FFI::load(__DIR__ . '/ffi.h');
	}

	return $ffi;
}

/**
 * Does the one-character string contain a character that separates tokens?
 *
 * @param string $char
 * @return bool
 */
function is_separator(string $char): bool
{
	if ( ! is_ascii($char))
	{
		return FALSE;
	}

	// `strpos` is used instead of `strchr`/`strstr` as we don't care about the actual match
	// while `strchr` would match the C version, it also returns the match
	$isSep = (strpos(',.()+-/*=~%<>[];', $char) !== FALSE);

	return is_space($char) || $char === "\0" || $isSep;
}

/**
 * Pull input from the stdin stream.
 *
 * @param int $len
 * @return string
 */
function read_stdin(int $len = 128): string
{
	$handle = fopen('php://stdin', 'rb');
	$input = fread($handle, $len);
	fclose($handle);

	return $input;
}

/**
 * Write to the stdout stream
 *
 * @param string $str
 * @param int|NULL $len
 * @return int
 */
function write_stdout(string $str, int $len = NULL): int
{
	$handle = fopen('php://stdout', 'ab');
	$res = (is_int($len))
		? fwrite($handle, $str, $len)
		: fwrite($handle, $str);

	fclose($handle);

	return $res;
}

function read_stdout(int $len = 128): string
{
	$handle = fopen('php://stdout', 'rb');
	$input = fread($handle, $len);

	$input = rtrim($input);
	fclose($handle);

	return $input;
}

/**
 * Replaces a slice of an array with the same value
 *
 * @param array $array The array to update
 * @param int $offset The index of the first location to update
 * @param int $length The number of indices to update
 * @param mixed $value The value to replace in the range
 */
function array_replace_range(array &$array, int $offset, int $length, $value):void
{
	if ($length === 1)
	{
		$array[$offset] = $value;
		return;
	}

	$replacement = array_fill(0, $length, $value);
	array_splice($array, $offset, $length, $replacement);

	/* $end = $offset + $length;
	for ($i = $offset; $i < $end; $i++)
	{
		$array[$i] = $value;
	} */
}

function str_contains(string $haystack, string $str, ?int $offset = NULL): bool
{
	return ($offset !== NULL)
		? strpos($haystack, $str, $offset) !== FALSE
		: strpos($haystack, $str) !== FALSE;
}

/**
 * Get the ASCII color escape number for the specified syntax type
 *
 * @param int $hl
 * @return int
 */
function syntax_to_color(int $hl): int
{
	$map = [
		Highlight::COMMENT => Color::FG_CYAN,
		Highlight::ML_COMMENT => Color::FG_BRIGHT_BLACK,
		Highlight::KEYWORD1 => Color::FG_YELLOW,
		Highlight::KEYWORD2 => Color::FG_GREEN,
		Highlight::STRING => Color::FG_MAGENTA,
		Highlight::NUMBER => Color::FG_RED,
		Highlight::OPERATOR => Color::FG_BRIGHT_GREEN,
		Highlight::VARIABLE => Color::FG_BRIGHT_CYAN,
		Highlight::DELIMITER => Color::FG_BLUE,
		Highlight::INVALID => Color::BG_BRIGHT_RED,
		Highlight::MATCH => Color::INVERT,
	];

	return (array_key_exists($hl, $map))
		? $map[$hl]
		: Color::FG_WHITE;
}

/**
 * Replace tabs with the specified number of spaces.
 *
 * @param string $str
 * @param int? $number
 * @return string
 */
function tabs_to_spaces(string $str, ?int $number = KILO_TAB_STOP): string
{
	return str_replace("\t", str_repeat(' ', $number), $str);
}

/**
 * Use 'token_get_all' to get the tokens for a file,
 * organized by row number
 *
 * @param string $code
 * @return array
 */
function get_php_tokens(string $code): array
{
	$rawTokens = token_get_all($code);
	$tokens = [];
	$lineNum = 1;
	$line = [];
	foreach($rawTokens as $t)
	{
		if (is_array($t))
		{
			[$type, $rawChar, $currentLine] = $t;
			$char = tabs_to_spaces($rawChar);

			$current = [
				'type' => $type,
				'typeName' => token_name($type),
				'char' => $char,
				'line' => $currentLine,
			];

			if ($char === "\n")
			{
				$line[] = $current;
				$tokens[$lineNum] = $line;
				$lineNum++;
				$line = [];
			}

			// Only return the first line of a multi-line token for this line array
			if ($char !== "\n" && strpos($char, "\n") !== FALSE)
			{
				$chars = explode("\n", $char);
				$current['original'] = [
					'string' => $char,
					'lines' => $chars,
				];
				$current['char'] = array_shift($chars);

				// Add new lines for additional newline characters
				$nextLine = $currentLine;
				foreach ($chars as $char)
				{
					$nextLine++;

					if ( ! array_key_exists($nextLine, $tokens))
					{
						$tokens[$nextLine] = [];
					}

					$tokens[$nextLine][] = [
						'type' => -1,
						'typeName' => 'RAW',
						'char' => $char,
					];
				}
			}

			if ($currentLine !== $lineNum)
			{
				$existing = $tokens[$lineNum] ?? [];
				$tokens[$lineNum] = array_merge($existing, $line);

				$lineNum = $currentLine;
				$line = [];
			}

			$line[] = $current;
		}
		else if (is_string($t))
		{
			// Simple characters, usually delimiters or single character operators
			$line[] = [
				'type' => -1,
				'typeName' => 'RAW',
				'char' => tabs_to_spaces($t),
			];
		}
	}

	$tokens[$lineNum] = array_merge($tokens[$lineNum] ?? [], $line);

	ksort($tokens);

	return $tokens;
}

/**
 * Generate/Get the syntax highlighting objects
 *
 * @return array
 */
function get_file_syntax_map(): array
{
	static $db = [];

	if (count($db) === 0)
	{
		$db = [
			Syntax::new(
				'C',
				['.c', '.h', '.cpp'],
				[
					'continue', 'typedef', 'switch', 'return', 'static', 'while', 'break', 'struct',
					'union', 'class', 'else', 'enum', 'for', 'case', 'if',
				],
				[
					'#include', 'unsigned', '#define', '#ifndef', 'double', 'signed', '#endif',
					'#ifdef', 'float', '#error', '#undef', 'long', 'char', 'int', 'void', '#if',
				],
				'//',
				'/*',
				'*/',
				Syntax::HIGHLIGHT_NUMBERS | Syntax::HIGHLIGHT_STRINGS,
			),
			Syntax::new(
				'CSS',
				['.css', '.less', '.sass', 'scss'],
				[],
				[],
				'',
				'/*',
				'*/',
				Syntax::HIGHLIGHT_NUMBERS | Syntax::HIGHLIGHT_STRINGS,
			),
			Syntax::new(
				'JavaScript',
				['.js', '.jsx', '.ts', '.tsx', '.jsm', '.mjs', '.es'],
				[
					'instanceof',
					'continue',
					'debugger',
					'function',
					'default',
					'extends',
					'finally',
					'delete',
					'export',
					'import',
					'return',
					'switch',
					'typeof',
					'break',
					'catch',
					'class',
					'const',
					'super',
					'throw',
					'while',
					'yield',
					'case',
					'else',
					'this',
					'void',
					'with',
					'from',
					'for',
					'new',
					'try',
					'var',
					'do',
					'if',
					'in',
					'as',
				],
				[
					'=>', 'Number', 'String', 'Object', 'Math', 'JSON', 'Boolean',
				],
				'//',
				'/*',
				'*/',
				Syntax::HIGHLIGHT_NUMBERS | Syntax::HIGHLIGHT_STRINGS,
			),
			Syntax::new(
				'PHP',
				['.php', 'kilo'],
				[
					'?php', '$this', '__halt_compiler', 'abstract', 'and', 'array', 'as', 'break',
					'callable', 'case', 'catch', 'class', 'clone', 'const', 'continue', 'declare',
					'default', 'die', 'do', 'echo', 'else', 'elseif', 'empty', 'enddeclare', 'endfor',
					'endforeach', 'endif', 'endswitch', 'endwhile', 'eval', 'exit', 'extends',
					'final', 'finally', 'for', 'foreach', 'function', 'global', 'goto', 'if', 'implements',
					'include', 'include_once', 'instanceof', 'insteadof', 'interface', 'isset', 'list',
					'namespace', 'new', 'or', 'print', 'private', 'protected', 'public', 'require', 'require_once',
					'return', 'static', 'switch', 'throw', 'trait', 'try', 'unset', 'use', 'var', 'while', 'xor',
					'yield', 'yield from', '__CLASS__', '__DIR__', '__FILE__', '__FUNCTION__', '__LINE__',
					'__METHOD__', '__NAMESPACE__', '__TRAIT__',
				],
				[
					'int', 'float', 'bool', 'string', 'true', 'TRUE', 'false', 'FALSE', 'null', 'NULL',
					'void', 'iterable', 'object', 'strict_types'
				],
				'//',
				'/*',
				'*/',
				Syntax::HIGHLIGHT_NUMBERS | Syntax::HIGHLIGHT_STRINGS,
			),
			Syntax::new(
				'Rust',
				['.rs'],
				[
					'continue', 'return', 'static', 'struct', 'unsafe', 'break', 'const', 'crate',
					'extern', 'match', 'super', 'trait', 'where', 'else', 'enum', 'false', 'impl',
					'loop', 'move', 'self', 'type', 'while', 'for', 'let', 'mod', 'pub', 'ref', 'true',
					'use', 'mut', 'as', 'fn', 'if', 'in',
				],
				[
					'DoubleEndedIterator',
					'ExactSizeIterator',
					'IntoIterator',
					'PartialOrd',
					'PartialEq',
					'Iterator',
					'ToString',
					'Default',
					'ToOwned',
					'Extend',
					'FnOnce',
					'Option',
					'String',
					'AsMut',
					'AsRef',
					'Clone',
					'Debug',
					'FnMut',
					'Sized',
					'Unpin',
					'array',
					'isize',
					'usize',
					'&str',
					'Copy',
					'Drop',
					'From',
					'Into',
					'None',
					'Self',
					'Send',
					'Some',
					'Sync',
					'Sync',
					'bool',
					'char',
					'i128',
					'u128',
					'Box',
					'Err',
					'Ord',
					'Vec',
					'dyn',
					'f32',
					'f64',
					'i16',
					'i32',
					'i64',
					'str',
					'u16',
					'u32',
					'u64',
					'Eq',
					'Fn',
					'Ok',
					'i8',
					'u8',
				],
				'//',
				'/*',
				'*/',
				Syntax::HIGHLIGHT_NUMBERS | Syntax::HIGHLIGHT_STRINGS,
			),
		];
	}

	return $db;
}