<?php

/**
 * This file provides the part of lessphp API (https://github.com/leafo/lessphp)
 * to be a drop-in replacement for following products:
 *  - Drupal 7, by the less module v3.0+ (https://drupal.org/project/less)
 *  - Symfony 2
 *  https://github.com/oyejorge/less.php
 */
require_once 'HTML/Less/Version.php';

class HTML_Less {

    static public $VERSION = HTML_Less_Version::less_version;
    public $importDir = '';
    protected $allParsedFiles = array();
    protected $libFunctions = array();
    var $registeredVars = array();
    private $formatterName;
    private $options = array();

    public function __construct($lessc = null, $sourceName = null) 
    {
        
    }

    public function setImportDir($dirs) 
    {
        $this->importDir = (array) $dirs;
    }

    public function addImportDir($dir) 
    {
        $this->importDir = (array) $this->importDir;
        $this->importDir[] = $dir;
    }

    public function setFormatter($name) 
    {
        $this->formatterName = $name;
    }

    public function setPreserveComments($preserve) 
    {
        
    }

    public function registerFunction($name, $func) 
    {
        $this->libFunctions[$name] = $func;
    }

    public function unregisterFunction($name) 
    {
        unset($this->libFunctions[$name]);
    }

    public function setVariables($variables) 
    {
        foreach ($variables as $name => $value) {
            $this->setVariable($name, $value);
        }
    }

    public function setVariable($name, $value) 
    {
        $this->registeredVars[$name] = $value;
    }

    public function unsetVariable($name) 
    {
        unset($this->registeredVars[$name]);
    }

    public function setOptions($options) 
    {
        foreach ($options as $name => $value) {
            $this->setOption($name, $value);
        }
    }

    public function setOption($name, $value) 
    {
        $this->options[$name] = $value;
    }

    public function parse($buffer, $presets = array()) 
    {
        $this->setVariables($presets);

        require_once 'HTML/Less/Parser.php';
        
        $parser = new HTML_Less_Parser($this->getOptions());
        $parser->setImportDirs($this->getImportDirs());
        foreach ($this->libFunctions as $name => $func) {
            $parser->registerFunction($name, $func);
        }
        $parser->parse($buffer);
        if (count($this->registeredVars)) {
            $parser->ModifyVars($this->registeredVars);
        }
        return $parser->getCss();
    }

    protected function getOptions() 
    {
        $options = array('relativeUrls' => false);
        switch ($this->formatterName) {
            case 'compressed':
                $options['compress'] = true;
                break;
        }
        if (is_array($this->options)) {
            $options = array_merge($options, $this->options);
        }
        return $options;
    }

    protected function getImportDirs() 
    {
        $dirs_ = (array) $this->importDir;
        $dirs = array();
        foreach ($dirs_ as $dir) {
            $dirs[$dir] = '';
        }
        return $dirs;
    }

    public function compile($string, $name = null) 
    {
        $oldImport = $this->importDir;
        $this->importDir = (array) $this->importDir;

        $this->allParsedFiles = array();

        require_once 'HTML/Less/Parser.php';
        
        $parser = new HTML_Less_Parser($this->getOptions());
        $parser->SetImportDirs($this->getImportDirs());
        if (count($this->registeredVars)) {
            $parser->ModifyVars($this->registeredVars);
        }
        foreach ($this->libFunctions as $name => $func) {
            $parser->registerFunction($name, $func);
        }
        $parser->parse($string);
        $out = $parser->getCss();

        $parsed = HTML_Less_Parser::AllParsedFiles();
        foreach ($parsed as $file) {
            $this->addParsedFile($file);
        }

        $this->importDir = $oldImport;

        return $out;
    }

    public function compileFile($fname, $outFname = null) 
    {
        if (!is_readable($fname)) {
            throw new Exception('load error: failed to find ' . $fname);
        }

        require_once 'HTML/Less/Parser.php';
        
        $pi = pathinfo($fname);

        $oldImport = $this->importDir;

        $this->importDir = (array) $this->importDir;
        $this->importDir[] = HTML_Less_Parser::AbsPath($pi['dirname']) . '/';

        $this->allParsedFiles = array();
        $this->addParsedFile($fname);

        $parser = new HTML_Less_Parser($this->getOptions());
        $parser->SetImportDirs($this->getImportDirs());
        if (count($this->registeredVars)) {
            $parser->ModifyVars($this->registeredVars);
        }
        foreach ($this->libFunctions as $name => $func) {
            $parser->registerFunction($name, $func);
        }
        $parser->parseFile($fname);
        
        //print_R($parser->getVariables());
        
        $out = $parser->getCss();

        $parsed = HTML_Less_Parser::AllParsedFiles();
        foreach ($parsed as $file) {
            $this->addParsedFile($file);
        }

        $this->importDir = $oldImport;

        if ($outFname !== null) {
            return file_put_contents($outFname, $out);
        }

        return $out;
    }

    public function checkedCompile($in, $out) 
    {
        if (!is_file($out) || filemtime($in) > filemtime($out)) {
            $this->compileFile($in, $out);
            return true;
        }
        return false;
    }

    /**
     * Execute lessphp on a .less file or a lessphp cache structure
     *
     * The lessphp cache structure contains information about a specific
     * less file having been parsed. It can be used as a hint for future
     * calls to determine whether or not a rebuild is required.
     *
     * The cache structure contains two important keys that may be used
     * externally:
     *
     * compiled: The final compiled CSS
     * updated: The time (in seconds) the CSS was last compiled
     *
     * The cache structure is a plain-ol' PHP associative array and can
     * be serialized and unserialized without a hitch.
     *
     * @param mixed $in Input
     * @param bool $force Force rebuild?
     * @return array lessphp cache structure
     */
    public function cachedCompile($in, $force = false) 
    {
        // assume no root
        $root = null;

        if (is_string($in)) {
            $root = $in;
        } elseif (is_array($in) and isset($in['root'])) {
            if ($force or ! isset($in['files'])) {
                // If we are forcing a recompile or if for some reason the
                // structure does not contain any file information we should
                // specify the root to trigger a rebuild.
                $root = $in['root'];
            } elseif (isset($in['files']) and is_array($in['files'])) {
                foreach ($in['files'] as $fname => $ftime) {
                    if (!file_exists($fname) or filemtime($fname) > $ftime) {
                        // One of the files we knew about previously has changed
                        // so we should look at our incoming root again.
                        $root = $in['root'];
                        break;
                    }
                }
            }
        } else {
            // TODO: Throw an exception? We got neither a string nor something
            // that looks like a compatible lessphp cache structure.
            return null;
        }

        if ($root !== null) {
            // If we have a root value which means we should rebuild.
            $out = array();
            $out['root'] = $root;
            $out['compiled'] = $this->compileFile($root);
            $out['files'] = $this->allParsedFiles();
            $out['updated'] = time();
            return $out;
        } else {
            // No changes, pass back the structure
            // we were given initially.
            return $in;
        }
    }

    public function ccompile($in, $out, $less = null) 
    {
        if ($less === null) {
            $less = new self;
        }
        return $less->checkedCompile($in, $out);
    }

    public static function cexecute($in, $force = false, $less = null) 
    {
        if ($less === null) {
            $less = new self;
        }
        return $less->cachedCompile($in, $force);
    }

    public function allParsedFiles() 
    {
        return $this->allParsedFiles;
    }

    protected function addParsedFile($file) 
    {
        require_once 'HTML/Less/Parser.php';
        $this->allParsedFiles[HTML_Less_Parser::AbsPath($file)] = filemtime($file);
    }

}