<?php

/**
 * This file is part of the CodeIgniter 4 framework.
 *
 * (c) CodeIgniter Foundation <admin@codeigniter.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace CodeIgniter\CLI;

use CodeIgniter\CLI\Exceptions\CLIException;
use Config\Services;
use Throwable;

/**
 * Set of static methods useful for CLI request handling.
 *
 * Portions of this code were initially from the FuelPHP Framework,
 * version 1.7.x, and used here under the MIT license they were
 * originally made available under. Reference: http://fuelphp.com
 *
 * Some of the code in this class is Windows-specific, and not
 * possible to test using travis-ci. It has been phpunit-annotated
 * to prevent messing up code coverage.
 *
 * Some of the methods require keyboard input, and are not unit-testable
 * as a result: input() and prompt().
 * validate() is internal, and not testable if prompt() isn't.
 * The wait() method is mostly testable, as long as you don't give it
 * an argument of "0".
 * These have been flagged to ignore for code coverage purposes.
 */
class CLI
{
	/**
	 * Is the readline library on the system?
	 *
	 * @var boolean
	 */
	public static $readline_support = false;

	/**
	 * The message displayed at prompts.
	 *
	 * @var string
	 */
	public static $wait_msg = 'Press any key to continue...';

	/**
	 * Has the class already been initialized?
	 *
	 * @var boolean
	 */
	protected static $initialized = false;

	/**
	 * Foreground color list
	 *
	 * @var array
	 */
	protected static $foreground_colors = [
		'black'        => '0;30',
		'dark_gray'    => '1;30',
		'blue'         => '0;34',
		'dark_blue'    => '0;34',
		'light_blue'   => '1;34',
		'green'        => '0;32',
		'light_green'  => '1;32',
		'cyan'         => '0;36',
		'light_cyan'   => '1;36',
		'red'          => '0;31',
		'light_red'    => '1;31',
		'purple'       => '0;35',
		'light_purple' => '1;35',
		'yellow'       => '0;33',
		'light_yellow' => '1;33',
		'light_gray'   => '0;37',
		'white'        => '1;37',
	];

	/**
	 * Background color list
	 *
	 * @var array
	 */
	protected static $background_colors = [
		'black'      => '40',
		'red'        => '41',
		'green'      => '42',
		'yellow'     => '43',
		'blue'       => '44',
		'magenta'    => '45',
		'cyan'       => '46',
		'light_gray' => '47',
	];

	/**
	 * List of array segments.
	 *
	 * @var array
	 */
	protected static $segments = [];

	/**
	 * @var array
	 */
	protected static $options = [];

	/**
	 * Helps track internally whether the last
	 * output was a "write" or a "print" to
	 * keep the output clean and as expected.
	 *
	 * @var string|null
	 */
	protected static $lastWrite;

	/**
	 * Height of the CLI window
	 *
	 * @var integer|null
	 */
	protected static $height;

	/**
	 * Width of the CLI window
	 *
	 * @var integer|null
	 */
	protected static $width;

	/**
	 * Whether the current stream supports colored output.
	 *
	 * @var boolean
	 */
	protected static $isColored = false;

	//--------------------------------------------------------------------

	/**
	 * Static "constructor".
	 */
	public static function init()
	{
		if (is_cli())
		{
			// Readline is an extension for PHP that makes interactivity with PHP
			// much more bash-like.
			// http://www.php.net/manual/en/readline.installation.php
			static::$readline_support = extension_loaded('readline');

			// clear segments & options to keep testing clean
			static::$segments = [];
			static::$options  = [];

			// Check our stream resource for color support
			static::$isColored = static::hasColorSupport(STDOUT);

			static::parseCommandLine();

			static::$initialized = true;
		}
		else
		{
			// If the command is being called from a controller
			// we need to define STDOUT ourselves
			// @codeCoverageIgnoreStart
			define('STDOUT', 'php://output');
			// @codeCoverageIgnoreEnd
		}
	}

	//--------------------------------------------------------------------

	/**
	 * Get input from the shell, using readline or the standard STDIN
	 *
	 * Named options must be in the following formats:
	 * php index.php user -v --v -name=John --name=John
	 *
	 * @param  string $prefix
	 * @return string
	 *
	 * @codeCoverageIgnore
	 */
	public static function input(string $prefix = null): string
	{
		if (static::$readline_support)
		{
			return readline($prefix);
		}

		echo $prefix;

		return fgets(STDIN);
	}

	//--------------------------------------------------------------------

	/**
	 * Asks the user for input.
	 *
	 * Usage:
	 *
	 * // Takes any input
	 * $color = CLI::prompt('What is your favorite color?');
	 *
	 * // Takes any input, but offers default
	 * $color = CLI::prompt('What is your favourite color?', 'white');
	 *
	 * // Will validate options with the in_list rule and accept only if one of the list
	 * $color = CLI::prompt('What is your favourite color?', array('red','blue'));
	 *
	 * // Do not provide options but requires a valid email
	 * $email = CLI::prompt('What is your email?', null, 'required|valid_email');
	 *
	 * @param string       $field      Output "field" question
	 * @param string|array $options    String to a default value, array to a list of options (the first option will be the default value)
	 * @param string       $validation Validation rules
	 *
	 * @return string The user input
	 *
	 * @codeCoverageIgnore
	 */
	public static function prompt(string $field, $options = null, string $validation = null): string
	{
		$extraOutput = '';
		$default     = '';

		if (is_string($options))
		{
			$extraOutput = ' [' . static::color($options, 'white') . ']';
			$default     = $options;
		}

		if (is_array($options) && $options)
		{
			$opts               = $options;
			$extraOutputDefault = static::color($opts[0], 'white');

			unset($opts[0]);

			if (empty($opts))
			{
				$extraOutput = $extraOutputDefault;
			}
			else
			{
				$extraOutput = ' [' . $extraOutputDefault . ', ' . implode(', ', $opts) . ']';
				$validation .= '|in_list[' . implode(',', $options) . ']';

				$validation = trim($validation, '|');
			}

			$default = $options[0];
		}

		static::fwrite(STDOUT, $field . $extraOutput . ': ');

		// Read the input from keyboard.
		$input = trim(static::input()) ?: $default;

		if (isset($validation))
		{
			while (! static::validate($field, $input, $validation))
			{
				$input = static::prompt($field, $options, $validation);
			}
		}

		return empty($input) ? '' : $input;
	}

	//--------------------------------------------------------------------

	/**
	 * Validate one prompt "field" at a time
	 *
	 * @param string $field Prompt "field" output
	 * @param string $value Input value
	 * @param string $rules Validation rules
	 *
	 * @return boolean
	 *
	 * @codeCoverageIgnore
	 */
	protected static function validate(string $field, string $value, string $rules): bool
	{
		$label      = $field;
		$field      = 'temp';
		$validation = Services::validation(null, false);
		$validation->setRule($field, $label, $rules);
		$validation->run([$field => $value]);

		if ($validation->hasError($field))
		{
			static::error($validation->getError($field));

			return false;
		}

		return true;
	}

	//--------------------------------------------------------------------

	/**
	 * Outputs a string to the CLI without any surrounding newlines.
	 * Useful for showing repeating elements on a single line.
	 *
	 * @param string      $text
	 * @param string|null $foreground
	 * @param string|null $background
	 */
	public static function print(string $text = '', string $foreground = null, string $background = null)
	{
		if ($foreground || $background)
		{
			$text = static::color($text, $foreground, $background);
		}

		static::$lastWrite = null;

		static::fwrite(STDOUT, $text);
	}

	/**
	 * Outputs a string to the cli on it's own line.
	 *
	 * @param string $text       The text to output
	 * @param string $foreground
	 * @param string $background
	 */
	public static function write(string $text = '', string $foreground = null, string $background = null)
	{
		if ($foreground || $background)
		{
			$text = static::color($text, $foreground, $background);
		}

		if (static::$lastWrite !== 'write')
		{
			$text              = PHP_EOL . $text;
			static::$lastWrite = 'write';
		}

		static::fwrite(STDOUT, $text . PHP_EOL);
	}

	//--------------------------------------------------------------------

	/**
	 * Outputs an error to the CLI using STDERR instead of STDOUT
	 *
	 * @param string      $text       The text to output, or array of errors
	 * @param string      $foreground
	 * @param string|null $background
	 */
	public static function error(string $text, string $foreground = 'light_red', string $background = null)
	{
		// Check color support for STDERR
		$stdout            = static::$isColored;
		static::$isColored = static::hasColorSupport(STDERR);

		if ($foreground || $background)
		{
			$text = static::color($text, $foreground, $background);
		}

		static::fwrite(STDERR, $text . PHP_EOL);

		// return STDOUT color support
		static::$isColored = $stdout;
	}

	//--------------------------------------------------------------------

	/**
	 * Beeps a certain number of times.
	 *
	 * @param integer $num The number of times to beep
	 */
	public static function beep(int $num = 1)
	{
		echo str_repeat("\x07", $num);
	}

	//--------------------------------------------------------------------

	/**
	 * Waits a certain number of seconds, optionally showing a wait message and
	 * waiting for a key press.
	 *
	 * @param integer $seconds   Number of seconds
	 * @param boolean $countdown Show a countdown or not
	 */
	public static function wait(int $seconds, bool $countdown = false)
	{
		if ($countdown === true)
		{
			$time = $seconds;

			while ($time > 0)
			{
				static::fwrite(STDOUT, $time . '... ');
				sleep(1);
				$time --;
			}
			static::write();
		}
		else
		{
			if ($seconds > 0)
			{
				sleep($seconds);
			}
			else
			{
				// this chunk cannot be tested because of keyboard input
				// @codeCoverageIgnoreStart
				static::write(static::$wait_msg);
				static::input();
				// @codeCoverageIgnoreEnd
			}
		}
	}

	//--------------------------------------------------------------------

	/**
	 * if operating system === windows
	 *
	 * @return boolean
	 */
	public static function isWindows(): bool
	{
		return stripos(PHP_OS, 'WIN') === 0;
	}

	//--------------------------------------------------------------------

	/**
	 * Enter a number of empty lines
	 *
	 * @param integer $num Number of lines to output
	 *
	 * @return void
	 */
	public static function newLine(int $num = 1)
	{
		// Do it once or more, write with empty string gives us a new line
		for ($i = 0; $i < $num; $i ++)
		{
			static::write();
		}
	}

	//--------------------------------------------------------------------

	/**
	 * Clears the screen of output
	 *
	 * @return void
	 *
	 * @codeCoverageIgnore
	 */
	public static function clearScreen()
	{
		// Unix systems, and Windows with VT100 Terminal support (i.e. Win10)
		// can handle CSI sequences. For lower than Win10 we just shove in 40 new lines.
		static::isWindows() && ! static::streamSupports('sapi_windows_vt100_support', STDOUT)
			? static::newLine(40)
			: static::fwrite(STDOUT, "\033[H\033[2J");
	}

	//--------------------------------------------------------------------

	/**
	 * Returns the given text with the correct color codes for a foreground and
	 * optionally a background color.
	 *
	 * @param string $text       The text to color
	 * @param string $foreground The foreground color
	 * @param string $background The background color
	 * @param string $format     Other formatting to apply. Currently only 'underline' is understood
	 *
	 * @return string    The color coded string
	 */
	public static function color(string $text, string $foreground, string $background = null, string $format = null): string
	{
		if (! static::$isColored)
		{
			return $text;
		}

		if (! array_key_exists($foreground, static::$foreground_colors))
		{
			throw CLIException::forInvalidColor('foreground', $foreground);
		}

		if ($background !== null && ! array_key_exists($background, static::$background_colors))
		{
			throw CLIException::forInvalidColor('background', $background);
		}

		$string = "\033[" . static::$foreground_colors[$foreground] . 'm';

		if ($background !== null)
		{
			$string .= "\033[" . static::$background_colors[$background] . 'm';
		}

		if ($format === 'underline')
		{
			$string .= "\033[4m";
		}

		// Detect if color method was already in use with this text
		if (strpos($text, "\033[0m") !== false)
		{
			// Split the text into parts so that we can see
			// if any part missing the color definition
			$chunks = mb_split("\\033\[0m", $text);
			// Reset text
			$text = '';

			foreach ($chunks as $chunk)
			{
				if ($chunk === '')
				{
					continue;
				}

				// If chunk doesn't have colors defined we need to add them
				if (strpos($chunk, "\033[") === false)
				{
					$chunk = static::color($chunk, $foreground, $background, $format);
					// Add color reset before chunk and clear end of the string
					$text .= rtrim("\033[0m" . $chunk, "\033[0m");
				}
				else
				{
					$text .= $chunk;
				}
			}
		}

		return $string . $text . "\033[0m";
	}

	//--------------------------------------------------------------------

	/**
	 * Get the number of characters in string having encoded characters
	 * and ignores styles set by the color() function
	 *
	 * @param string $string
	 *
	 * @return integer
	 */
	public static function strlen(?string $string): int
	{
		if (is_null($string))
		{
			return 0;
		}

		foreach (static::$foreground_colors as $color)
		{
			$string = strtr($string, ["\033[" . $color . 'm' => '']);
		}

		foreach (static::$background_colors as $color)
		{
			$string = strtr($string, ["\033[" . $color . 'm' => '']);
		}

		$string = strtr($string, ["\033[4m" => '', "\033[0m" => '']);

		return mb_strwidth($string);
	}

	//--------------------------------------------------------------------

	/**
	 * Checks whether the current stream resource supports or
	 * refers to a valid terminal type device.
	 *
	 * @param string   $function
	 * @param resource $resource
	 *
	 * @return boolean
	 */
	public static function streamSupports(string $function, $resource): bool
	{
		if (ENVIRONMENT === 'testing')
		{
			// In the current setup of the tests we cannot fully check
			// if the stream supports the function since we are using
			// filtered streams.
			return function_exists($function);
		}

		// @codeCoverageIgnoreStart
		return function_exists($function) && @$function($resource);
		// @codeCoverageIgnoreEnd
	}

	//--------------------------------------------------------------------

	/**
	 * Returns true if the stream resource supports colors.
	 *
	 * This is tricky on Windows, because Cygwin, Msys2 etc. emulate pseudo
	 * terminals via named pipes, so we can only check the environment.
	 *
	 * Reference: https://github.com/composer/xdebug-handler/blob/master/src/Process.php
	 *
	 * @param resource $resource
	 *
	 * @return boolean
	 */
	public static function hasColorSupport($resource): bool
	{
		// Follow https://no-color.org/
		if (isset($_SERVER['NO_COLOR']) || getenv('NO_COLOR') !== false)
		{
			return false;
		}

		if (getenv('TERM_PROGRAM') === 'Hyper')
		{
			return true;
		}

		if (static::isWindows())
		{
			// @codeCoverageIgnoreStart
			return static::streamSupports('sapi_windows_vt100_support', $resource)
				|| isset($_SERVER['ANSICON'])
				|| getenv('ANSICON') !== false
				|| getenv('ConEmuANSI') === 'ON'
				|| getenv('TERM') === 'xterm';
			// @codeCoverageIgnoreEnd
		}

		return static::streamSupports('stream_isatty', $resource);
	}

	//--------------------------------------------------------------------

	/**
	 * Attempts to determine the width of the viewable CLI window.
	 *
	 * @param integer $default
	 *
	 * @return integer
	 */
	public static function getWidth(int $default = 80): int
	{
		if (\is_null(static::$width))
		{
			static::generateDimensions();
		}

		return static::$width ?: $default;
	}

	//--------------------------------------------------------------------

	/**
	 * Attempts to determine the height of the viewable CLI window.
	 *
	 * @param integer $default
	 *
	 * @return integer
	 */
	public static function getHeight(int $default = 32): int
	{
		if (\is_null(static::$height))
		{
			static::generateDimensions();
		}

		return static::$height ?: $default;
	}

	//--------------------------------------------------------------------

	/**
	 * Populates the CLI's dimensions.
	 *
	 * @return void
	 */
	public static function generateDimensions()
	{
		try
		{
			if (static::isWindows())
			{
				// Shells such as `Cygwin` and `Git bash` returns incorrect values
				// when executing `mode CON`, so we use `tput` instead
				// @codeCoverageIgnoreStart
				if (($shell = getenv('SHELL')) && preg_match('/(?:bash|zsh)(?:\.exe)?$/', $shell) || getenv('TERM'))
				{
					static::$height = (int) exec('tput lines');
					static::$width  = (int) exec('tput cols');
				}
				else
				{
					$return = -1;
					$output = [];
					exec('mode CON', $output, $return);

					if ($return === 0 && $output)
					{
						// Look for the next lines ending in ": <number>"
						// Searching for "Columns:" or "Lines:" will fail on non-English locales
						if (preg_match('/:\s*(\d+)\n[^:]+:\s*(\d+)\n/', implode("\n", $output), $matches))
						{
							static::$height = (int) $matches[1];
							static::$width  = (int) $matches[2];
						}
					}
				}
				// @codeCoverageIgnoreEnd
			}
			else
			{
				if (($size = exec('stty size')) && preg_match('/(\d+)\s+(\d+)/', $size, $matches))
				{
					static::$height = (int) $matches[1];
					static::$width  = (int) $matches[2];
				}
				else
				{
					// @codeCoverageIgnoreStart
					static::$height = (int) exec('tput lines');
					static::$width  = (int) exec('tput cols');
					// @codeCoverageIgnoreEnd
				}
			}
		}
		// @codeCoverageIgnoreStart
		catch (Throwable $e)
		{
			// Reset the dimensions so that the default values will be returned later.
			// Then let the developer know of the error.
			static::$height = null;
			static::$width  = null;
			log_message('error', $e->getMessage());
		}
		// @codeCoverageIgnoreEnd
	}

	//--------------------------------------------------------------------

	/**
	 * Displays a progress bar on the CLI. You must call it repeatedly
	 * to update it. Set $thisStep = false to erase the progress bar.
	 *
	 * @param integer|boolean $thisStep
	 * @param integer         $totalSteps
	 */
	public static function showProgress($thisStep = 1, int $totalSteps = 10)
	{
		static $inProgress = false;

		// restore cursor position when progress is continuing.
		if ($inProgress !== false && $inProgress <= $thisStep)
		{
			static::fwrite(STDOUT, "\033[1A");
		}
		$inProgress = $thisStep;

		if ($thisStep !== false)
		{
			// Don't allow div by zero or negative numbers....
			$thisStep   = abs($thisStep);
			$totalSteps = $totalSteps < 1 ? 1 : $totalSteps;

			$percent = (int) (($thisStep / $totalSteps) * 100);
			$step    = (int) round($percent / 10);

			// Write the progress bar
			static::fwrite(STDOUT, "[\033[32m" . str_repeat('#', $step) . str_repeat('.', 10 - $step) . "\033[0m]");
			// Textual representation...
			static::fwrite(STDOUT, sprintf(' %3d%% Complete', $percent) . PHP_EOL);
		}
		else
		{
			static::fwrite(STDOUT, "\007");
		}
	}

	//--------------------------------------------------------------------

	/**
	 * Takes a string and writes it to the command line, wrapping to a maximum
	 * width. If no maximum width is specified, will wrap to the window's max
	 * width.
	 *
	 * If an int is passed into $pad_left, then all strings after the first
	 * will padded with that many spaces to the left. Useful when printing
	 * short descriptions that need to start on an existing line.
	 *
	 * @param string  $string
	 * @param integer $max
	 * @param integer $padLeft
	 *
	 * @return string
	 */
	public static function wrap(string $string = null, int $max = 0, int $padLeft = 0): string
	{
		if (empty($string))
		{
			return '';
		}

		if ($max === 0)
		{
			$max = CLI::getWidth();
		}

		if (CLI::getWidth() < $max)
		{
			$max = CLI::getWidth();
		}

		$max = $max - $padLeft;

		$lines = wordwrap($string, $max, PHP_EOL);

		if ($padLeft > 0)
		{
			$lines = explode(PHP_EOL, $lines);

			$first = true;

			array_walk($lines, function (&$line, $index) use ($padLeft, &$first) {
				if (! $first)
				{
					$line = str_repeat(' ', $padLeft) . $line;
				}
				else
				{
					$first = false;
				}
			});

			$lines = implode(PHP_EOL, $lines);
		}

		return $lines;
	}

	//--------------------------------------------------------------------
	//--------------------------------------------------------------------
	// Command-Line 'URI' support
	//--------------------------------------------------------------------

	/**
	 * Parses the command line it was called from and collects all
	 * options and valid segments.
	 */
	protected static function parseCommandLine()
	{
		$args = $_SERVER['argv'] ?? [];
		array_shift($args); // scrap invoking program
		$optionValue = false;

		foreach ($args as $i => $arg)
		{
			// If there's no "-" at the beginning, then
			// this is probably an argument or an option value
			if (mb_strpos($arg, '-') !== 0)
			{
				if ($optionValue)
				{
					// We have already included this in the previous
					// iteration, so reset this flag
					$optionValue = false;
				}
				else
				{
					// Yup, it's a segment
					static::$segments[] = $arg;
				}

				continue;
			}

			$arg   = ltrim($arg, '-');
			$value = null;

			if (isset($args[$i + 1]) && mb_strpos($args[$i + 1], '-') !== 0)
			{
				$value       = $args[$i + 1];
				$optionValue = true;
			}

			static::$options[$arg] = $value;
		}
	}

	//--------------------------------------------------------------------

	/**
	 * Returns the command line string portions of the arguments, minus
	 * any options, as a string. This is used to pass along to the main
	 * CodeIgniter application.
	 *
	 * @return string
	 */
	public static function getURI(): string
	{
		return implode('/', static::$segments);
	}

	//--------------------------------------------------------------------

	/**
	 * Returns an individual segment.
	 *
	 * This ignores any options that might have been dispersed between
	 * valid segments in the command:
	 *
	 *  // segment(3) is 'three', not '-f' or 'anOption'
	 *  > php spark one two -f anOption three
	 *
	 * **IMPORTANT:** The index here is one-based instead of zero-based.
	 *
	 * @param integer $index
	 *
	 * @return mixed|null
	 */
	public static function getSegment(int $index)
	{
		if (! isset(static::$segments[$index - 1]))
		{
			return null;
		}

		return static::$segments[$index - 1];
	}

	//--------------------------------------------------------------------

	/**
	 * Returns the raw array of segments found.
	 *
	 * @return array
	 */
	public static function getSegments(): array
	{
		return static::$segments;
	}

	//--------------------------------------------------------------------

	/**
	 * Gets a single command-line option. Returns TRUE if the option
	 * exists, but doesn't have a value, and is simply acting as a flag.
	 *
	 * @param string $name
	 *
	 * @return boolean|mixed|null
	 */
	public static function getOption(string $name)
	{
		if (! array_key_exists($name, static::$options))
		{
			return null;
		}

		// If the option didn't have a value, simply return TRUE
		// so they know it was set, otherwise return the actual value.
		$val = static::$options[$name] === null ? true : static::$options[$name];

		return $val;
	}

	//--------------------------------------------------------------------

	/**
	 * Returns the raw array of options found.
	 *
	 * @return array
	 */
	public static function getOptions(): array
	{
		return static::$options;
	}

	//--------------------------------------------------------------------

	/**
	 * Returns the options as a string, suitable for passing along on
	 * the CLI to other commands.
	 *
	 * @param boolean $useLongOpts Use '--' for long options?
	 * @param boolean $trim        Trim final string output?
	 *
	 * @return string
	 */
	public static function getOptionString(bool $useLongOpts = false, bool $trim = false): string
	{
		if (empty(static::$options))
		{
			return '';
		}

		$out = '';

		foreach (static::$options as $name => $value)
		{
			if ($useLongOpts && mb_strlen($name) > 1)
			{
				$out .= "--{$name} ";
			}
			else
			{
				$out .= "-{$name} ";
			}

			// If there's a space, we need to group
			// so it will pass correctly.
			if (mb_strpos($value, ' ') !== false)
			{
				$out .= '"' . $value . '" ';
			}
			elseif ($value !== null)
			{
				$out .= "{$value} ";
			}
		}

		return $trim ? trim($out) : $out;
	}

	//--------------------------------------------------------------------

	/**
	 * Returns a well formatted table
	 *
	 * @param array $tbody List of rows
	 * @param array $thead List of columns
	 *
	 * @return void
	 */
	public static function table(array $tbody, array $thead = [])
	{
		// All the rows in the table will be here until the end
		$tableRows = [];

		// We need only indexes and not keys
		if (! empty($thead))
		{
			$tableRows[] = array_values($thead);
		}

		foreach ($tbody as $tr)
		{
			$tableRows[] = array_values($tr);
		}

		// Yes, it really is necessary to know this count
		$totalRows = count($tableRows);

		// Store all columns lengths
		// $all_cols_lengths[row][column] = length
		$allColsLengths = [];

		// Store maximum lengths by column
		// $max_cols_lengths[column] = length
		$maxColsLengths = [];

		// Read row by row and define the longest columns
		for ($row = 0; $row < $totalRows; $row ++)
		{
			$column = 0; // Current column index
			foreach ($tableRows[$row] as $col)
			{
				// Sets the size of this column in the current row
				$allColsLengths[$row][$column] = static::strlen($col);

				// If the current column does not have a value among the larger ones
				// or the value of this is greater than the existing one
				// then, now, this assumes the maximum length
				if (! isset($maxColsLengths[$column]) || $allColsLengths[$row][$column] > $maxColsLengths[$column])
				{
					$maxColsLengths[$column] = $allColsLengths[$row][$column];
				}

				// We can go check the size of the next column...
				$column ++;
			}
		}

		// Read row by row and add spaces at the end of the columns
		// to match the exact column length
		for ($row = 0; $row < $totalRows; $row ++)
		{
			$column = 0;
			foreach ($tableRows[$row] as $col)
			{
				$diff = $maxColsLengths[$column] - static::strlen($col);
				if ($diff)
				{
					$tableRows[$row][$column] = $tableRows[$row][$column] . str_repeat(' ', $diff);
				}
				$column ++;
			}
		}

		$table = '';

		// Joins columns and append the well formatted rows to the table
		for ($row = 0; $row < $totalRows; $row ++)
		{
			// Set the table border-top
			if ($row === 0)
			{
				$cols = '+';
				foreach ($tableRows[$row] as $col)
				{
					$cols .= str_repeat('-', static::strlen($col) + 2) . '+';
				}
				$table .= $cols . PHP_EOL;
			}

			// Set the columns borders
			$table .= '| ' . implode(' | ', $tableRows[$row]) . ' |' . PHP_EOL;

			// Set the thead and table borders-bottom
			if (isset($cols) && ($row === 0 && ! empty($thead) || $row + 1 === $totalRows))
			{
				$table .= $cols . PHP_EOL;
			}
		}

		static::write($table);
	}

	//--------------------------------------------------------------------

	/**
	 * While the library is intended for use on CLI commands,
	 * commands can be called from controllers and elsewhere
	 * so we need a way to allow them to still work.
	 *
	 * For now, just echo the content, but look into a better
	 * solution down the road.
	 *
	 * @param resource $handle
	 * @param string   $string
	 *
	 * @return void
	 */
	protected static function fwrite($handle, string $string)
	{
		if (! is_cli())
		{
			// @codeCoverageIgnoreStart
			echo $string;
			return;
			// @codeCoverageIgnoreEnd
		}

		fwrite($handle, $string);
	}
}

// Ensure the class is initialized. Done outside of code coverage
// @codeCoverageIgnoreStart
CLI::init();
// @codeCoverageIgnoreEnd
