updater

<?php
final class Updater
{
    const VERSION = '0.1.5';
    const LAYOUT_SIZE = 70;
    const BOX_STYLES = [
        //                      0    1    2    3    4    5    6    7
        'thin'             => ["┌", "┐", "└", "┘", "─", "│", "├", "┤"],
        'doubled'          => ["╔", "╗", "╚", "╝", "═", "║", "╠", "╣"],
    ];

    const LOCAL_VERSION_LIST = __DIR__.'/tmp/versionList.php';
    const LOCAL_VERSION_FILE = __DIR__.'/galastri/VERSION';

    const REMOTE_VERSION_LIST = 'https://raw.githubusercontent.com/andregalastri/galastri-framework-updates/main/versionList.php';
    
    const LOCAL_TMP_PATH = __DIR__.'/tmp';
    const LOCAL_PACKAGE_PATH = __DIR__.'/tmp/packages';
    const LOCAL_BACKUP_PATH = __DIR__.'/tmp/backup';
    const LOCAL_WORKING_FOLDER = __DIR__.'/tmp/working';

    const REMOTE_PACKAGE_URL = 'https://github.com/andregalastri/galastri-framework-updates/raw/main/updates';

    private static bool $restoreBackupStatus;
    
    /**
     * This is a singleton class, the __construct() method is private to avoid users to instanciate
     * it.
     *
     * @return void
     */
    private function __construct()
    {
    }
    
    /**
     * prepare
     *
     * @return void
     */
    private static function prepare()
    {
        self::isWritable(__DIR__);
        self::isWritable(__DIR__.'/galastri');

        if (!file_exists(self::LOCAL_VERSION_FILE)) {
            self::drawMessageBox(Language::text('NO_VERSION_FILE', 0), Language::text('NO_VERSION_FILE', 1));
            self::pressEnterToContinue();
            exit;
        }

        if (!file_exists(self::LOCAL_TMP_PATH)) {
            mkdir(self::LOCAL_TMP_PATH);
        }

        self::isWritable(self::LOCAL_TMP_PATH);

        if (!file_exists(self::LOCAL_BACKUP_PATH)) {
            mkdir(self::LOCAL_BACKUP_PATH);
        }

        self::isWritable(self::LOCAL_BACKUP_PATH);

        if (!file_exists(self::LOCAL_PACKAGE_PATH)) {
            mkdir(self::LOCAL_PACKAGE_PATH);
        }

        self::isWritable(self::LOCAL_PACKAGE_PATH);

        self::$restoreBackupStatus = false;
    }
    
    /**
     * isWritable
     *
     * @param  mixed $fileOrDirectory
     * @return void
     */
    private static function isWritable($fileOrDirectory): void
    {
        if (!is_writable($fileOrDirectory)) {
            self::drawMessageBox(Language::text('NO_WRITTING_PERMISION', 0), '', $fileOrDirectory, '', Language::text('NO_WRITTING_PERMISION', 1));
            self::pressEnterToContinue();
            exit;
        }
    }
    
    /**
     * execute
     *
     * @return void
     */
    public static function execute(): void
    {
        self::prepare();
        
        do {
            self::drawMainWindow();
            $option = readline(Language::text('CHOOSE_A_OPTION', 0));
            echo "\n\n\n";

            switch($option) {
                case 0:
                    self::drawMessageBox(Language::text('EXIT', 0), Language::text('EXIT', 1));
                    self::wait(1, false);
                    exit();

                case 1:
                    self::checkUpdates();
                    break;

                case 2:
                    self::checkBackups();
                    break;

                default:
                    self::drawMessageBox(Language::text('MAIN_INVALID_OPTION', 0).$option.Language::text('MAIN_INVALID_OPTION', 1));
                    self::pressEnterToContinue();
            }
        } while($option != 0);
    }

    
    /**
     * checkBackups
     *
     * @return void
     */
    private static function checkBackups(): void
    {
        $backupList = [];

        foreach(array_reverse(glob(self::LOCAL_BACKUP_PATH.'/*', GLOB_ONLYDIR)) as $key => $backupPath) {
            $backupName = str_replace(self::LOCAL_BACKUP_PATH.'/', '', $backupPath);
            $backupData = explode('_', $backupName);
            $date = (\Datetime::createFromFormat('YmdHis', $backupData[0]))->format('Y-m-d, H:i:s');
            $backupLabel = ($key+1).'. '.self::stringpad($date, 15, ' ').' | v'.$backupData[1];

            $backupList[] = [
                'path' => $backupPath,
                'label' => $backupLabel,
            ];
        }

        if (count($backupList) <= 0) {
            self::drawMessageBox(Language::text('NO_BACKUP_FOUND', 0), ':(');
        } else {
            do {
                self::drawBackupWindow($backupList);

                echo Language::text('CHOOSE_BACKUP_RESTORATION', 0);
                $key = readline(Language::text('CHOOSE_BACKUP_RESTORATION', 1));

                if ($key == 0) {
                    self::drawMessageBox(Language::text('CANCEL_BACKUP_RESTORATION', 0), Language::text('CANCEL_BACKUP_RESTORATION', 1));
                } else {
                    if (array_key_exists($key-1, $backupList)) {
                        self::drawMessageBox(Language::text('CONFIRM_BACKUP_RESTORAION', 0), '', $backupList[$key-1]['label']);
                        $confirm = readline(Language::text('CONFIRM_BACKUP_RESTORAION', 1));

                        switch($confirm){
                            case 'y':
                            case 'Y':
                            case 's':
                            case 'S':
                                self::executeRestore($backupList, $key-1);
                                break;
                            
                            default:
                                self::drawMessageBox(Language::text('CANCEL_BACKUP_RESTORATION', 0), Language::text('CANCEL_BACKUP_RESTORATION', 1));
                        }
                        self::$restoreBackupStatus = true;
                    } else {
                        self::drawMessageBox(Language::text('INVALID_BACKUP_OPTION', 0));
                        self::pressEnterToContinue();
                    }
                }
            } while($key != 0 and self::$restoreBackupStatus != true);
        }
        self::pressEnterToContinue();
    }
    
    /**
     * checkUpdates
     *
     * @return void
     */
    private static function checkUpdates(): void
    {
        $currentVersion = trim(file_get_contents(self::LOCAL_VERSION_FILE));
        
        self::drawMessageBox(Language::text('CHECKING_UPDATES', 0));
        
        file_put_contents(self::LOCAL_VERSION_LIST, file_get_contents(self::REMOTE_VERSION_LIST));

        $versionList = require(self::LOCAL_VERSION_LIST);
        $versionPosition = array_search($currentVersion, $versionList);

        if ($versionPosition === false) {
            self::drawMessageBox(
                Language::text('INVALID_VERSION', 0).$currentVersion.Language::text('INVALID_VERSION', 1),
                ':(',
                '',
                Language::text('INVALID_VERSION', 2)
            );
        } else {
            if ($versionPosition == array_key_last($versionList)) {
                self::drawMessageBox(
                    Language::text('UP_TO_DATE_VERSION', 0),
                    '',
                    Language::text('UP_TO_DATE_VERSION', 1).$currentVersion.Language::text('UP_TO_DATE_VERSION', 2),
                    ':D'
                );
            } else {
                self::wait(2, false);
                $packageQty = 0;

                foreach ($versionList as $i => $version) {
                    if ($i <= $versionPosition) continue;
                    $packageQty++;
                    $lastVersion = $version;
                }

                self::drawUpdateWindow($currentVersion, $packageQty, $lastVersion);
                $option = readline(Language::text('CONFIRM_UPDATE', 0));

                switch($option){
                    case 'y':
                    case 'Y':
                    case 's':
                    case 'S':
                        self::executeUpdate($versionList, $versionPosition, $packageQty);
                        break;
                    
                    default:
                        self::drawMessageBox(Language::text('CANCEL_UPDATE', 0), Language::text('CANCEL_UPDATE', 1));
                }
            }
        }
        self::pressEnterToContinue();
    }
    
    /**
     * executeRestore
     *
     * @param  mixed $backupPath
     * @return void
     */
    private static function executeRestore(array $backupList, int $restorePoint)
    {
        self::drawMessageBox(Language::text('RESTORING_BACKUP', 0));
        self::wait(5, true, false);
        echo "\n";

        self::draw('doubled', 'top');

        foreach($backupList as $backupPoint => $backupData) {
            if ($backupPoint <= $restorePoint) {
                $backupFolder = $backupData['path'];

                self::text('doubled', Language::text('RESTORING_BACKUP_PROCESS', 0).$backupData['label']);

                $currentVersion = trim(file_get_contents(self::LOCAL_VERSION_FILE));

                $workingFiles = require($backupFolder.'/changes/deleted-files.php');
                foreach($workingFiles as $file) {
                    self::copyFile($backupFolder.'/'.$file, __DIR__.'/'.$file);
                }

                $workingFiles = require($backupFolder.'/changes/new-files.php');
                foreach($workingFiles as $file) {
                    unlink(__DIR__.'/'.$file);
                }

                $workingFiles = require($backupFolder.'/changes/modified-files.php');
                foreach($workingFiles as $file) {
                    self::copyFile($backupFolder.'/'.$file, __DIR__.'/'.$file);
                }

                self::deleteAll($backupFolder);
            }
        }
        self::draw('doubled', 'bottom');
        self::wait(2, false, false);
        echo "\n";


        self::drawMessageBox(Language::text('BACKUP_RESTORED', 0));
    }
    
    /**
     * executeUpdate
     *
     * @param  mixed $versionList
     * @param  mixed $versionPosition
     * @param  mixed $packageQty
     * @return void
     */
    private static function executeUpdate(array $versionList, int $versionPosition, int $packageQty): void
    {
        self::drawMessageBox(Language::text('STARTING_UPDATE', 0));
        self::wait(5, true, false);
        echo "\n";

        $packageNumber = 1;
        $lastVersion = '';

        self::draw('doubled', 'top');
        foreach ($versionList as $i => $version) {
            $currentVersion = trim(file_get_contents(self::LOCAL_VERSION_FILE));

            if ($i <= $versionPosition) continue;

            if ($packageNumber > 1) {
                self::draw('doubled', 'line');
            }

            if (!file_exists(self::LOCAL_WORKING_FOLDER)) {
                mkdir(self::LOCAL_WORKING_FOLDER);
            }

            $packageTarFile = $version.'.tar';
            $packageTarPath = self::LOCAL_WORKING_FOLDER.'/'.$packageTarFile;

            self::text('doubled', Language::text('UPDATE_PROCESS', 0).$version.'" ('.$packageNumber.'/'.$packageQty.')');
            file_put_contents($packageTarPath, file_get_contents(self::REMOTE_PACKAGE_URL.'/'.$packageTarFile));

            self::text('doubled', Language::text('UPDATE_PROCESS', 1));
            (new \PharData($packageTarPath))->extractTo(self::LOCAL_WORKING_FOLDER);
            unlink($packageTarPath);

            $packageFolder = self::LOCAL_PACKAGE_PATH.'/'.$version;

            if (file_exists($packageFolder)) {
                self::deleteAll($packageFolder);
            }
            self::copyDirectory(self::LOCAL_WORKING_FOLDER.'/'.$version, self::LOCAL_PACKAGE_PATH.'/'.$version);
            self::deleteAll(self::LOCAL_WORKING_FOLDER);

            $backupFolder = self::LOCAL_BACKUP_PATH.'/'.date('YmdHis_').$currentVersion;

            if (!file_exists($backupFolder)) {
                mkdir($backupFolder);
            }

            self::copyFile($packageFolder.'/deleted-files.php', $backupFolder.'/changes/deleted-files.php');
            self::copyFile($packageFolder.'/new-files.php', $backupFolder.'/changes/new-files.php');
            self::copyFile($packageFolder.'/modified-files.php', $backupFolder.'/changes/modified-files.php');

            self::text('doubled', Language::text('UPDATE_PROCESS', 2));

            $workingFiles = require($packageFolder.'/deleted-files.php');
            foreach($workingFiles as $file) {
                self::copyFile(__DIR__.'/'.$file, $backupFolder.'/'.$file);
                unlink(__DIR__.'/'.$file);
            }

            $workingFiles = require($packageFolder.'/new-files.php');
            foreach($workingFiles as $file) {
                self::copyFile($packageFolder.'/'.$file, __DIR__.'/'.$file);
            }

            $workingFiles = require($packageFolder.'/modified-files.php');
            foreach($workingFiles as $file) {
                self::copyFile(__DIR__.'/'.$file, $backupFolder.'/'.$file);
                self::copyFile($packageFolder.'/'.$file, __DIR__.'/'.$file);
            }

            $newUpdater = $packageFolder.'/updater';

            if (file_exists($newUpdater)) {
                self::draw('doubled', 'bottom');
                
                self::drawMessageBox(Language::text('UPDATE_DONE', 1).$version);

                self::drawMessageBox(
                    Language::text('UPDATER_UPDATED', 0),
                    Language::text('UPDATER_UPDATED', 1),
                    '',
                    Language::text('UPDATER_UPDATED', 2)
                );

                self::pressEnterToContinue();
                exit;
            } else {
                $packageNumber++;
                $lastVersion = $version;
            }
            self::wait(2, false, false);
        }
        self::draw('doubled', 'bottom');
        self::drawMessageBox(Language::text('UPDATE_DONE', 0), Language::text('UPDATE_DONE', 1).$lastVersion);
    }
    
    /**
     * pressEnterToContinue
     *
     * @return void
     */
    private static function pressEnterToContinue(): void
    {
        readline(Language::text('PRESS_ENTER_TO_CONTINUE', 0));
        echo "\n\n\n";
    }
    
    /**
     * wait
     *
     * @param  mixed $seconds
     * @param  mixed $writeDots
     * @param  mixed $longJump
     * @return void
     */
    private static function wait(int $seconds, bool $writeDots = true, bool $longJump = true): void
    {
        for ($i = 0; $i < $seconds; $i++) {
            echo $writeDots ? '.' : '';
            sleep(1);
        }
        echo $longJump ? "\n\n\n" : '';
    }
    
    /**
     * drawMessageBox
     *
     * @param  mixed $messages
     * @return void
     */
    private static function drawMessageBox(string ...$messages): void
    {
        self::draw('doubled', 'top');
        foreach($messages as $message) {
            self::text('doubled', $message, 'center');
        }
        self::draw('doubled', 'bottom');
    }

    
    /**
     * drawMainWindow
     *
     * @return void
     */
    private static function drawMainWindow(): void
    {
        self::draw('doubled', 'top');
        self::text('doubled', 'GALASTRI FRAMEWORK UPDATER', 'center');
        self::text('doubled', 'v'.self::VERSION, 'center');
        self::draw('doubled', 'bottom');
        self::text('thin', Language::text('WELCOME_WINDOW', 0), 'center');
        self::draw('thin', 'line');
        self::text('thin', Language::text('WELCOME_WINDOW', 1));
        self::draw('thin', 'empty');
        self::text('thin', Language::text('WELCOME_WINDOW', 2));
        self::text('thin', Language::text('WELCOME_WINDOW', 3));
        self::draw('thin', 'empty');
        self::text('thin', Language::text('WELCOME_WINDOW', 4));
        self::draw('thin', 'bottom');
    }

    
    /**
     * drawUpdateWindow
     *
     * @param  mixed $currentVersion
     * @param  mixed $packageQty
     * @param  mixed $lastVersion
     * @return void
     */
    private static function drawUpdateWindow(string $currentVersion, int $packageQty, string $lastVersion): void
    {
        $headerText = $packageQty > 1 ? Language::text('UPDATE_WINDOW_HEADER', 0).$packageQty.Language::text('UPDATE_WINDOW_HEADER', 1) : Language::text('UPDATE_WINDOW_HEADER', 2);

        self::draw('doubled', 'top');
        self::text('doubled', $headerText, 'center');
        self::draw('doubled', 'bottom');
        self::text('thin', Language::text('UPDATE_WINDOW_VERSIONS', 0).$currentVersion);
        self::text('thin', Language::text('UPDATE_WINDOW_VERSIONS', 1).$lastVersion);
        self::draw('thin', 'line');
        self::text('thin', Language::text('UPDATE_WINDOW_ABOUT', 0));
        self::draw('thin', 'empty');
        self::text('thin', Language::text('UPDATE_WINDOW_ABOUT', 1));
        self::draw('thin', 'empty');
        self::text('thin', Language::text('UPDATE_WINDOW_ABOUT', 2));
        self::draw('thin', 'empty');
        self::text('thin', Language::text('UPDATE_WINDOW_ABOUT', 3));
        self::draw('thin', 'line');
        self::text('thin', Language::text('UPDATE_WINDOW_ABOUT', 4), 'center');
        self::text('thin', Language::text('UPDATE_WINDOW_ABOUT', 5), 'center');
        self::draw('thin', 'bottom');
    }
    
    /**
     * drawBackupWindow
     *
     * @param  mixed $backupList
     * @return void
     */
    private static function drawBackupWindow(array $backupList): void
    {
        $backupQty = count($backupList);
        $headerText = $backupQty > 1 ? Language::text('BACKUP_WINDOW_HEADER', 0).$backupQty.Language::text('BACKUP_WINDOW_HEADER', 1) : Language::text('BACKUP_WINDOW_HEADER', 2);

        self::draw('doubled', 'top');
        self::text('doubled', $headerText, 'center');
        self::draw('doubled', 'bottom');


        foreach($backupList as $backupData) {
            self::text('thin', $backupData['label']);
        }
        
        self::draw('thin', 'line');
        self::text('thin', Language::text('BACKUP_WINDOW_ABOUT', 0));
        self::draw('thin', 'empty');
        self::text('thin', Language::text('BACKUP_WINDOW_ABOUT', 1));
        self::draw('thin', 'empty');
        self::text('thin', Language::text('BACKUP_WINDOW_ABOUT', 2));
        self::draw('thin', 'empty');
        self::text('thin', Language::text('BACKUP_WINDOW_ABOUT', 3));
        self::draw('thin', 'empty');
        self::text('thin', Language::text('BACKUP_WINDOW_ABOUT', 4));
        self::draw('thin', 'line');
        self::text('thin', Language::text('BACKUP_WINDOW_ABOUT', 5), 'center');
        self::draw('thin', 'bottom');
    }

    
    /**
     * text
     *
     * @param  mixed $style
     * @param  mixed $message
     * @param  mixed $align
     * @return void
     */
    private static function text(string $style, string $message, string $align = 'left'): void
    {
        $textMaxSize = self::LAYOUT_SIZE - 2;

        if (mb_strlen($message) <= $textMaxSize) {
            echo self::BOX_STYLES[$style][5].self::stringpad(' '.$message.' ', self::LAYOUT_SIZE, ' ', self::textAlign($align)).self::BOX_STYLES[$style][5]."\n";
        } else {
            $delimiter = ' ';

            if (strpos($message, ' ') === false) {
                $delimiter = '/';
            }

            $words = explode($delimiter, $message);
            $pharase[0] = [];
            $pharaseCount = 0;
    
            foreach($words as $word) {
                if (mb_strlen(implode($delimiter, $pharase[$pharaseCount]).$delimiter.$word) > $textMaxSize) {
                    $pharaseCount++;
                    $pharase[$pharaseCount] = [];
                }
    
                $pharase[$pharaseCount][] = $word;
            }
            foreach($pharase as $line) {
                echo self::BOX_STYLES[$style][5].' '.self::stringpad(trim(implode($delimiter, $line).$delimiter), $textMaxSize, ' ', self::textAlign($align)).' '.self::BOX_STYLES[$style][5]."\n";
            }
        }

    }
    
    /**
     * textAlign
     *
     * @param  mixed $align
     * @return int
     */
    private static function textAlign(string $align): int
    {
        switch($align){
            case 'center':
                return STR_PAD_BOTH;
            
            case 'right':
                return STR_PAD_LEFT;
            
            case 'left':
                return STR_PAD_RIGHT;
            
            default:
                return STR_PAD_LEFT;
        }
    }
    
    /**
     * draw
     *
     * @param  mixed $style
     * @param  mixed $type
     * @return void
     */
    private static function draw(string $style, string $type): void
    {
        switch($type) {
            case 'top':
                echo self::BOX_STYLES[$style][0].self::stringpad('', self::LAYOUT_SIZE, self::BOX_STYLES[$style][4], STR_PAD_LEFT).self::BOX_STYLES[$style][1]."\n";
                break;

            case 'bottom':
                echo self::BOX_STYLES[$style][2].self::stringpad('', self::LAYOUT_SIZE, self::BOX_STYLES[$style][4], STR_PAD_LEFT).self::BOX_STYLES[$style][3]."\n";
                break;

            case 'line':
                echo self::BOX_STYLES[$style][6].self::stringpad('', self::LAYOUT_SIZE, self::BOX_STYLES[$style][4], STR_PAD_LEFT).self::BOX_STYLES[$style][7]."\n";
                break;
            
            case 'empty':
                echo self::BOX_STYLES[$style][5].self::stringpad('', self::LAYOUT_SIZE, " ", STR_PAD_LEFT).self::BOX_STYLES[$style][5]."\n";
                break;
        }
    }

    /**
     * Source: https://stackoverflow.com/a/2050909
     * Author: Felix Kling
     * 
     * This function copy the entire source directory to a destination directory. PHP's native copy()
     * function doesn't copy folders, much less do it recursively.
     *
     * @param  string $sourceDirectory                  The directory that will be copied.
     * 
     * @param  string $destinationDirectory             The destination folder that will receive the
     *                                                  copy of the source directory.
     * 
     * @param  string $childFolder                      (Optional) Adds a child folder inside the
     *                                                  destination directory and copies the source
     *                                                  directory to this child folder.
     * 
     * @return void
     */
    private static function copyDirectory(string $sourceDirectory, string $destinationDirectory, string $childFolder = '', array $ignorePaths = []): void {
        $directory = opendir($sourceDirectory);

        if (is_dir($destinationDirectory) === false) {
            mkdir($destinationDirectory);
        }

        if ($childFolder !== '') {
            if (is_dir("$destinationDirectory/$childFolder") === false) {
                mkdir("$destinationDirectory/$childFolder");
            }

            while (($file = readdir($directory)) !== false) {
                if ($file === '.' || $file === '..') {
                    continue;
                }

                if (is_dir("$sourceDirectory/$file") === true) {
                    self::copyDirectory("$sourceDirectory/$file", "$destinationDirectory/$childFolder/$file", '', $ignorePaths);
                } else {
                    foreach ($ignorePaths as $ignore) {
                        if ($ignore == substr($sourceDirectory, 0, strlen($ignore))) {
                            return;
                        }
                    }
                    copy("$sourceDirectory/$file", "$destinationDirectory/$childFolder/$file");
                }
            }

            closedir($directory);

            return;
        }

        while (($file = readdir($directory)) !== false) {
            if ($file === '.' || $file === '..') {
                continue;
            }

            if (is_dir("$sourceDirectory/$file") === true) {
                self::copyDirectory("$sourceDirectory/$file", "$destinationDirectory/$file", '', $ignorePaths);
            }
            else {
                foreach ($ignorePaths as $ignore) {
                    if ($ignore == substr($sourceDirectory, 0, strlen($ignore))) {
                        return;
                    }
                }
                copy("$sourceDirectory/$file", "$destinationDirectory/$file");
            }
        }

        closedir($directory);
    }
    
    /**
     * copyFile
     *
     * @param  mixed $sourceFile
     * @param  mixed $destinationFile
     * @return void
     */
    private static function copyFile($sourceFile, $destinationFile) {
        $path = pathinfo($destinationFile);

        if (!file_exists($path['dirname'])) {
            mkdir($path['dirname'], 0777, true);
        }
        
        copy($sourceFile, $destinationFile);
    }

    /**
     * Source: https://intecsols.com/delete-files-and-folders-from-a-folder-using-php-by-intecsols/
     * Author: Syed Muhammad Waqas
     * 
     * This function delete the entire directory even if it has files inside it. PHP's native rmdir()
     * function doesn't remove folders with files inside.
     *
     * @param  string $directory                              Directory that will be removed.
     * 
     * @return void
     */
    private static function deleteAll(string $directory): void
    {
        foreach(glob($directory . '/*') as $file) {
            if(is_dir($file)) {
                self::deleteAll($file);
            } else {
                unlink($file);
            }
        }

        rmdir($directory);
    }

    /**
     * Source: https://www.php.net/manual/pt_BR/function.str-pad.php#116244
     * Author: wes
     * 
     * This function is the multibyte version of str_pad() function from PHP.
     *
     * @param  mixed $string
     * 
     * @param  mixed $padlength
     * 
     * @param  mixed $pad_str
     * 
     * @param  mixed $align
     * 
     * @param  mixed $encoding
     * 
     * @return string
     */
    private static function stringpad(string $string, int $padlength, string $padstring = ' ', int $align = STR_PAD_RIGHT, ?string $encoding = NULL): string
    {
        $encoding = $encoding === NULL ? mb_internal_encoding() : $encoding;

        $padBefore = $align === STR_PAD_BOTH || $align === STR_PAD_LEFT;
        $padAfter = $align === STR_PAD_BOTH || $align === STR_PAD_RIGHT;
        $padlength -= mb_strlen($string, $encoding);
        
        $targetLength = $padBefore && $padAfter ? $padlength / 2 : $padlength;
        $strToRepeatLength = mb_strlen($padstring, $encoding);

        $repeatTimes = ceil($targetLength / $strToRepeatLength);
        $repeatedString = str_repeat($padstring, max(0, $repeatTimes)); // safe if used with valid utf-8 strings

        $stringbefore = $padBefore ? mb_substr($repeatedString, 0, floor($targetLength), $encoding) : '';
        $stringafter = $padAfter ? mb_substr($repeatedString, 0, ceil($targetLength), $encoding) : '';
        
        return $stringbefore.$string.$stringafter;
    }
}

/**
 * Language
 */
final class Language
{
    const AVAILABLE_LANGUAGES = ['br', 'en'];

    const NO_VERSION_FILE = [
        'en' => [
            'The "VERSION" file wasn\'t found in the "galastri" folder.',
            'Without this file, the updater cannot continue.',
        ],
        'br' => [
            'Não foi encontrado o arquivo "VERSION" dentro da pasta "galastri".',
            'Sem este arquivo, o atualizador não pode continuar.',
        ],
    ];

    const NO_WRITING_PERMISSION = [
        'en' => [
            'The following folder doesn\'t have writing permissions:',
            'Grant write permissions to the folder and run the updater again.',
        ],
        'br' => [
            'A seguinte pasta não possui permissões de escrita:',
            'Conceda permissões de escrita para a pasta e execute o atualizador novamente.',
        ],
    ];

    const CHOOSE_A_OPTION = [
        'en' => [
            'Choose an option: ',
        ],
        'br' => [
            'Escolha uma das opções: ',
        ],
    ];

    const EXIT = [
        'en' => [
            'Closing the updater!',
            'Bye bye! :)',
        ],
        'br' => [
            'Encerrando o atualizador!',
            'Bye bye! :)',
        ],
    ];

    const MAIN_INVALID_OPTION = [
        'en' => [
            'Option "',
            '" is invalid. Please, choose a valid option.',
        ],
        'br' => [
            'A opção "',
            '" é inválida. Por favor, escolha uma opção válida.',
        ],
    ];

    const NO_BACKUP_FOUND = [
        'en' => [
            'No backup found.',
        ],
        'br' => [
            'Nenhum backup encontrado.',
        ],
    ];

    const CHOOSE_BACKUP_RESTORATION = [
        'en' => [
            "Choose a number of the backup to be restored,\n",
            'or choose 0 (zero) to cancel: ',
        ],
        'br' => [
            "Informe o número do backup a ser restaurado,\n",
            'ou informe 0 (zero) para cancelar: ',
        ],
    ];

    const CANCEL_BACKUP_RESTORATION = [
        'en' => [
            'No problem! :)',
            'Process cancelled. No backup was restored!',
        ],
        'br' => [
            'Sem problemas! :)',
            'Processo cancelado. Nenhum backup foi restaurado!',
        ],
    ];

    const CONFIRM_BACKUP_RESTORAION = [
        'en' => [
            'Confirm the backup restoration? ',
            'Confirma the restoration? [y/N]: ',
        ],
        'br' => [
            'Confirma a restauração do backup? ',
            'Confirma a restauração? [s/N]: ',
        ],
    ];

    const INVALID_BACKUP_OPTION = [
        'en' => [
            'The number you choose is invalid. Try again!',
        ],
        'br' => [
            'O número informado é inválido. Tente novamente!',
        ],
    ];

    const CHECKING_UPDATES = [
        'en' => [
            'Checking for updates. Make sure that you have internet access!',
        ],
        'br' => [
            'Verificando atualizações. Certifique-se de que você tem acesso à internet!',
        ],
    ];

    const RESTORING_BACKUP = [
        'en' => [
            'Restoring the backup files.',
        ],
        'br' => [
            'Restaurando os arquivos do backup.',
        ],
    ];

    const RESTORING_BACKUP_PROCESS = [
        'en' => [
            '- Restoring files from ',
        ],
        'br' => [
            '- Restaurando os arquivos de ',
        ],
    ];

    const BACKUP_RESTORED = [
        'en' => [
            'Restoration process done! :D',
        ],
        'br' => [
            'Processo de restauração concluído! :D',
        ],
    ];

    const INVALID_VERSION = [
        'en' => [
            'Strange... Your current version is "',
            '", but it isn\'t in the list of available versions of Galastri Framework.',
            'For security reasons, it is better you update the framework manually.',
        ],
        'br' => [
            'Estranho... A sua versão é a "',
            '", mas ela não consta na lista de versões existentes do Galastri Framework.',
            'Por questões de segurança, é melhor você atualizar o framework manualmente.',
        ],
    ];

    const UP_TO_DATE_VERSION = [
        'en' => [
            'There is no new updates available',
            'Your version "',
            '" is already the most up to date!',
        ],
        'br' => [
            'Nenhuma nova atualização disponível.',
            'Sua versão "',
            '" já é a mais recente!',
        ],
    ];

    const STARTING_UPDATE = [
        'en' => [
            'Starting the update process!',
        ],
        'br' => [
            'Iniciando o processo de atualização!',
        ],
    ];

    const UPDATE_PROCESS = [
        'en' => [
            ' - Downloading the package',
            ' - Package downloaded. Extracting the files.',
            ' - Applying the update package.',
        ],
        'br' => [
            ' - Baixando o pacote "',
            ' - Pacote baixado. Extraindo os arquivos.',
            ' - Aplicando o pacote de atualização.',
        ],
    ];

    const UPDATER_UPDATED = [
        'en' => [
            'The updater updated itself!',
            'We need to restart the updater before continue.',
            'Run the updater again and restart the updating process to continue with the installation.',
        ],
        'br' => [
            'O atualizador foi atualizado!',
            'Precisamos reiniciar o atualizar antes de continuar.',
            'Reabra-o e reinicie o processo de atualização para prosseguir com a instalação de novos pacotes.',
        ],
    ];

    const UPDATE_DONE = [
        'en' => [
            'Updating process done! :D',
            'Your Galastri Framework is now in the version ',
        ],
        'br' => [
            'Processo de atualização concluído! :D',
            'Seu Galastri Framework agora está na versão ',
        ],
    ];

    const CONFIRM_UPDATE = [
        'en' => [
            'Start update? [y/N]: ',
        ],
        'br' => [
            'Deseja atualizar? [s/N]: ',
        ],
    ];

    const CANCEL_UPDATE = [
        'en' => [
            'No problem! :)',
            'Update cancelled. No update package was installed!',
        ],
        'br' => [
            'Sem problemas! :)',
            'Processo cancelado. Nenhum pacote de atualização foi instalado!',
        ],
    ];

    const BACKUP_PROCESS = [
        'en' => [
            '- Creating a backup of the current files.',
            'Backup created at:',
        ],
        'br' => [
            '- Fazendo backup dos arquivos atuais.',
            'Backup criado em:',
        ],
    ];

    const PRESS_ENTER_TO_CONTINUE = [
        'en' => [
            'Press ENTER to continue...',
        ],
        'br' => [
            'Pressione ENTER para continuar...',
        ],
    ];

    const WELCOME_WINDOW = [
        'en' => [
            'Welcome to the Galastri Framework updater!',
            'Choose an option below:',
            '1. Check for new updates',
            '2. Restore backups',
            '0. Exit the updater',
        ],
        'br' => [
            'Seja bem-vindo ao atualizador do Galastri Framework!',
            'Escolha uma das opções abaixo:',
            '1. Verificar novas atualizações',
            '2. Restaurar backups',
            '0. Sair do atualizador',
        ],
    ];

    const UPDATE_WINDOW_ABOUT = [
        'en' => [
            'About the updating process:',
            '- A backup will be created before any changes.',
            '- It WON\'T CHANGE the files inside "app", "logs", "public_html" and "vendor", nor the files .gitattributes", ".gitignore", "composer.json", "LICENSE" and "README.md".',
            '- Any other file can be updated.',
            'Do you want to proceed with the update?',
            '(y) YES | (N) No',
        ],
        'br' => [
            'Sobre o processo de atualização:',
            '- É realizado um backup antes de qualquer alteração.',
            '- NÃO SERÃO ALTERADOS arquivos contidos em "app", "logs", "public_html" e "vendor", nem os arquivos ".gitattributes", ".gitignore", "composer.json", "LICENSE" e "README.md".',
            '- Quaisquer outros arquivos podem sofrer alterações.',
            'Deseja aplicar a atualização?',
            '(s) SIM | (N) NÃO',
        ],
    ];

    const BACKUP_WINDOW_ABOUT = [
        'en' => [
            'About the restoring process:',
            '- The restoration process restore the updates from the most recent to the selected point you choose.',
            '- The restored backup data is removed from the backup folder.',
            '- It WON\'T CHANGE the files inside "app", "logs", "public_html" and "vendor", nor the files .gitattributes", ".gitignore", "composer.json", "LICENSE" and "README.md".',
            '- Any other file can be restored.',
            'Choose the number of the backup you want to restore, or type 0 (zero) to cancel.',
        ],
        'br' => [
            'Sobre o processo de restauração:',
            '- A restauração reverte as alterações do ponto mais recente até o ponto que você escolher.',
            '- Os dados do backup restaurado são removidos da pasta de backup.',
            '- NÃO SERÃO ALTERADOS arquivos contidos em "app", "logs", "public_html" e "vendor", nem os arquivos ".gitattributes", ".gitignore", "composer.json", "LICENSE" e "README.md".',
            '- Quaisquer outros arquivos podem sofrer alterações.',
            'Informe agora o número do backup que deseja restaurar, ou digite 0 (zero) para cancelar.',
        ],
    ];

    const UPDATE_WINDOW_HEADER = [
        'en' => [
            'There are ',
            ' update packages found!',
            'There is 1 update package found!',
        ],

        'br' => [
            'Foram encontrados ',
            ' pacotes de atualização!',
            'Foi encontrado 1 pacote de atualização!',
        ],
    ];

    const UPDATE_WINDOW_VERSIONS = [
        'en' => [
            '- Your version: ',
            '- Most recent version: ',
        ],

        'br' => [
            '- Sua versão: ',
            '- Versão mais recente: ',
        ],
    ];

    const BACKUP_WINDOW_HEADER = [
        'en' => [
            'There are ',
            ' backups found!',
            'There is 1 backup found!',
        ],

        'br' => [
            'Foram encontrados ',
           ' backups!',
            'Foi encontrado 1 backup!',
        ],
    ];

    private static string $language = 'br';
    
    public static function text($code, $index)
    {
        return constant('self::'.$code)[self::$language][$index];
    }

    public static function setLanguage($language = 'en')
    {
        if(array_search($language, self::AVAILABLE_LANGUAGES) === false) {
            $language = 'en';
        }
        self::$language = $language;
    }
}
Language::setLanguage($argv[1] ?? 'en');
Updater::execute();