namespace IlluminateViewCompilers;

use IlluminateSupportArr;

use IlluminateSupportStr;

// namespace is so cool

class BladeCompiler extends Compiler implements CompilerInterface

{// has father class and api

    protected $extensions = [];// all of the registered extension.

    protected $customDirectives = [];// All custom "directive" handlers

    protected $path;// The file currently being compiled.

    protected $compilers = [

        'Extensions',

        'Statements',

        'Comments',

        'Echos',

    ];// All of the available compiler functions

   // a function collection

    protected $rawTags = ['{!!', '!!}'];// Array of opening and closing tags for raw echos.

    protected $contentTags = ['{{', '}}'];//Array of opening and closing tags for regular echos.

    protected $escapedTags = ['{{{', '}}}'];//Array of opening and closing tags for escaped echos.

    protected $echoFormat = 'e(%s)';// The "regular" /legacy echo string format.

    protected $footer = [];// Array of footer lines to the added to template.

    protected $forelseCounter = 0;//Counter to keep track of nested for else statements.

    public function compile($path = null)

    {//Compile the view at the given path.

        if ($path) {// $path

            $this->setPath($path);// path

        }

        $contents = $this->compileString($this->files->get($this->getPath()));// contents

       // get the contents

        if (! is_null($this->cachePath)) {

            $this->files->put($this->getCompiledPath($this->getPath()), $contents);

        }// if not null

    }// return it,

    public function getPath()

    {

        return $this->path;

    }// big get just get you want

    public function setPath($path)

    {

        $this->path = $path;

    }// set Path

    public function compileString($value)

    {//Compile the given Blade template contents.

        $result = '';// this result

        $this->footer = [];// this footer

        // Here we will loop through all of the tokens returned by the Zend lexer and

        // parse each one into the corresponding valid PHP. We will then have this

        // template as the correctly rendered PHP that can be rendered natively.

        foreach (token_get_all($value) as $token) {

            $result .= is_array($token) ? $this->parseToken($token) : $token;

        }// token_get_all

       //loop the token_get_all

        // If there are any footer lines that need to get added to a template we will

        // add them here at the end of the template. This gets used mainly for the

        // template inheritance via the extends keyword that should be appended.

        if (count($this->footer) > 0) {

            $result = ltrim($result, PHP_EOL)

                    .PHP_EOL.implode(PHP_EOL, array_reverse($this->footer));

        }// append something

        return $result;//return result

    }

    protected function parseToken($token)

    {//Parse the tokens from the template.

        list($id, $content) = $token;//get list

        if ($id == T_INLINE_HTML) {// a special id

            foreach ($this->compilers as $type) {// loop compile

                $content = $this->{"compile{$type}"}($content);// this is a good use

               //$content = $this=>{"compile{$type}"}($content);

            }

        }

        return $content;//return this type

    }// a classic function type

    protected function compileExtensions($value)

    {

        foreach ($this->extensions as $compiler) {

            $value = call_user_func($compiler, $value, $this);

        }// loop extensions and call_user_func

        return $value;

    }//Execute the user defined extensions

    protected function compileComments($value)

    {

        $pattern = sprintf('/%s--((.|s)*?)--%s/', $this->contentTags[0], $this->contentTags[1]);

// get the pattern

       // a very good function type

       // just comments

        return preg_replace($pattern, '', $value);

    }//compile Blade comments into valid PHP

    protected function compileEchos($value)

    {//compile Blade echos into valid PHP.

        foreach ($this->getEchoMethods() as $method => $length) {

            $value = $this->$method($value);//get the value

        }// foreach

        return $value;

    }// return $value

    protected function getEchoMethods()

    {//Get the echo methods in the proper order for compilation.

        $methods = [

            'compileRawEchos' => strlen(stripcslashes($this->rawTags[0])),

            'compileEscapedEchos' => strlen(stripcslashes($this->escapedTags[0])),

            'compileRegularEchos' => strlen(stripcslashes($this->contentTags[0])),

        ];// set some regular method to use

        uksort($methods, function ($method1, $method2) use ($methods) {

           // use user define method to sort the array

            // Ensure the longest tags are processed first

            if ($methods[$method1] > $methods[$method2]) {

                return -1;

            }

            if ($methods[$method1]

                return 1;

            }

            // Otherwise give preference to raw tags (assuming they've overridden)

            if ($method1 === 'compileRawEchos') {

                return -1;

            }

            if ($method2 === 'compileRawEchos') {

                return 1;

            }

            if ($method1 === 'compileEscapedEchos') {

                return -1;

            }

            if ($method2 === 'compileEscapedEchos') {

                return 1;

            }

        });

        return $methods;

    }// The methods.