<?php

/**
 * Source map generator
 *
 * @package Less
 * @subpackage Output
 */
class Less_SourceMap_Generator extends Less_Configurable {

    /**
     * What version of source map does the generator generate?
     */
    const VERSION = 3;

    /**
     * Array of default options
     *
     * @var array
     */
    protected $defaultOptions = [
        // an optional source root, useful for relocating source files
        // on a server or removing repeated values in the 'sources' entry.
        // This value is prepended to the individual entries in the 'source' field.
        'sourceRoot'        => '',

        // an optional name of the generated code that this source map is associated with.
        'sourceMapFilename' => NULL,

        // url of the map
        'sourceMapURL'      => NULL,

        // absolute path to a file to write the map to
        'sourceMapWriteTo'  => NULL,

        // output source contents?
        'outputSourceFiles' => FALSE,

        // base path for filename normalization
        'sourceMapRootpath' => '',

        // base path for filename normalization
        'sourceMapBasepath' => ''
    ];

    /**
     * The base64 VLQ encoder
     *
     * @var Less_SourceMap_Base64VLQ
     */
    protected $encoder;

    /**
     * Array of mappings
     *
     * @var array
     */
    protected $mappings = [];

    /**
     * The root node
     *
     * @var Less_Tree_Ruleset
     */
    protected $root;

    /**
     * Array of contents map
     *
     * @var array
     */
    protected $contentsMap = [];

    /**
     * File to content map
     *
     * @var array
     */
    protected $sources = [];
    protected $source_keys = [];

    /**
     * Constructor
     *
     * @param Less_Tree_Ruleset $root The root node
     * @param array             $options Array of options
     */
    public function __construct(Less_Tree_Ruleset $root, $contentsMap, $options = []) {
        $this->root = $root;
        $this->contentsMap = $contentsMap;
        $this->encoder = new Less_SourceMap_Base64VLQ();

        $this->SetOptions($options);


        // fix windows paths
        if (!empty($this->options['sourceMapRootpath'])) {
            $this->options['sourceMapRootpath'] = str_replace('\\', '/', $this->options['sourceMapRootpath']);
            $this->options['sourceMapRootpath'] = rtrim($this->options['sourceMapRootpath'], '/').'/';
        }
    }

    /**
     * Generates the CSS
     *
     * @return string
     */
    public function generateCSS() {
        $output = new Less_Output_Mapped($this->contentsMap, $this);

        // catch the output
        $this->root->genCSS($output);


        $sourceMapUrl = $this->getOption('sourceMapURL');
        $sourceMapFilename = $this->getOption('sourceMapFilename');
        $sourceMapContent = $this->generateJson();
        $sourceMapWriteTo = $this->getOption('sourceMapWriteTo');

        if (!$sourceMapUrl && $sourceMapFilename) {
            $sourceMapUrl = $this->normalizeFilename($sourceMapFilename);
        }

        // write map to a file
        if ($sourceMapWriteTo) {
            $this->saveMap($sourceMapWriteTo, $sourceMapContent);
        }

        // inline the map
        if (!$sourceMapUrl) {
            $sourceMapUrl = sprintf('data:application/json,%s', Less_Functions::encodeURIComponent($sourceMapContent));
        }

        if ($sourceMapUrl) {
            $output->add(sprintf('/*# sourceMappingURL=%s */', $sourceMapUrl));
        }

        return $output->toString();
    }

    /**
     * Generates the JSON source map
     *
     * @return string
     * @see https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#
     */
    protected function generateJson() {

        $sourceMap = [];
        $mappings = $this->generateMappings();

        // File version (always the first entry in the object) and must be a positive integer.
        $sourceMap['version'] = self::VERSION;


        // An optional name of the generated code that this source map is associated with.
        $file = $this->getOption('sourceMapFilename');
        if ($file) {
            $sourceMap['file'] = $file;
        }


        // An optional source root, useful for relocating source files on a server or removing repeated values in the 'sources' entry.	This value is prepended to the individual entries in the 'source' field.
        $root = $this->getOption('sourceRoot');
        if ($root) {
            $sourceMap['sourceRoot'] = $root;
        }


        // A list of original sources used by the 'mappings' entry.
        $sourceMap['sources'] = [];
        foreach ($this->sources as $source_uri => $source_filename) {
            $sourceMap['sources'][] = $this->normalizeFilename($source_filename);
        }


        // A list of symbol names used by the 'mappings' entry.
        $sourceMap['names'] = [];

        // A string with the encoded mapping data.
        $sourceMap['mappings'] = $mappings;

        if ($this->getOption('outputSourceFiles')) {
            // An optional list of source content, useful when the 'source' can't be hosted.
            // The contents are listed in the same order as the sources above.
            // 'null' may be used if some original sources should be retrieved by name.
            $sourceMap['sourcesContent'] = $this->getSourcesContent();
        }

        // less.js compat fixes
        if (count($sourceMap['sources']) && empty($sourceMap['sourceRoot'])) {
            unset($sourceMap['sourceRoot']);
        }

        return json_encode($sourceMap);
    }

    /**
     * Generates the mappings string
     *
     * @return string
     */
    public function generateMappings() {

        if (!count($this->mappings)) {
            return '';
        }

        $this->source_keys = array_flip(array_keys($this->sources));


        // group mappings by generated line number.
        $groupedMap = $groupedMapEncoded = [];
        foreach ($this->mappings as $m) {
            $groupedMap[$m['generated_line']][] = $m;
        }
        ksort($groupedMap);

        $lastGeneratedLine = $lastOriginalIndex = $lastOriginalLine = $lastOriginalColumn = 0;

        foreach ($groupedMap as $lineNumber => $line_map) {
            while (++$lastGeneratedLine < $lineNumber) {
                $groupedMapEncoded[] = ';';
            }

            $lineMapEncoded = [];
            $lastGeneratedColumn = 0;

            foreach ($line_map as $m) {
                $mapEncoded = $this->encoder->encode($m['generated_column'] - $lastGeneratedColumn);
                $lastGeneratedColumn = $m['generated_column'];

                // find the index
                if ($m['source_file']) {
                    $index = $this->findFileIndex($m['source_file']);
                    if ($index !== FALSE) {
                        $mapEncoded .= $this->encoder->encode($index - $lastOriginalIndex);
                        $lastOriginalIndex = $index;

                        // lines are stored 0-based in SourceMap spec version 3
                        $mapEncoded .= $this->encoder->encode($m['original_line'] - 1 - $lastOriginalLine);
                        $lastOriginalLine = $m['original_line'] - 1;

                        $mapEncoded .= $this->encoder->encode($m['original_column'] - $lastOriginalColumn);
                        $lastOriginalColumn = $m['original_column'];
                    }
                }

                $lineMapEncoded[] = $mapEncoded;
            }

            $groupedMapEncoded[] = implode(',', $lineMapEncoded).';';
        }

        return rtrim(implode($groupedMapEncoded), ';');
    }

    /**
     * Finds the index for the filename
     *
     * @param string $filename
     *
     * @return integer|false
     */
    protected function findFileIndex($filename) {
        return $this->source_keys[$filename];
    }

    /**
     * Normalizes the filename
     *
     * @param string $filename
     *
     * @return string
     */
    protected function normalizeFilename($filename) {

        $filename = str_replace('\\', '/', $filename);
        $rootpath = $this->getOption('sourceMapRootpath');
        $basePath = $this->getOption('sourceMapBasepath');

        // "Trim" the 'sourceMapBasepath' from the output filename.
        if (strpos($filename, $basePath) === 0) {
            $filename = substr($filename, strlen($basePath));
        }

        // Remove extra leading path separators.
        if (strpos($filename, '\\') === 0 || strpos($filename, '/') === 0) {
            $filename = substr($filename, 1);
        }

        return $rootpath.$filename;
    }

    /**
     * Returns the sources contents
     *
     * @return array|null
     */
    protected function getSourcesContent() {
        if (empty($this->sources)) {
            return;
        }
        $content = [];
        foreach ($this->sources as $sourceFile) {
            $content[] = file_get_contents($sourceFile);
        }

        return $content;
    }

    /**
     * Saves the source map to a file
     *
     * @param string $file The absolute path to a file
     * @param string $content The content to write
     *
     * @throws Exception If the file could not be saved
     */
    protected function saveMap($file, $content) {
        $dir = dirname($file);
        // directory does not exist
        if (!is_dir($dir)) {
            // FIXME: create the dir automatically?
            throw new Exception(sprintf('The directory "%s" does not exist. Cannot save the source map.', $dir));
        }
        // FIXME: proper saving, with dir write check!
        if (file_put_contents($file, $content) === FALSE) {
            throw new Exception(sprintf('Cannot save the source map to "%s"', $file));
        }

        return TRUE;
    }

    /**
     * Adds a mapping
     *
     * @param integer $generatedLine The line number in generated file
     * @param integer $generatedColumn The column number in generated file
     * @param integer $originalLine The line number in original file
     * @param integer $originalColumn The column number in original file
     * @param string  $sourceFile The original source file
     */
    public function addMapping($generatedLine, $generatedColumn, $originalLine, $originalColumn, $fileInfo) {

        $this->mappings[] = [
            'generated_line'   => $generatedLine,
            'generated_column' => $generatedColumn,
            'original_line'    => $originalLine,
            'original_column'  => $originalColumn,
            'source_file'      => $fileInfo['currentUri']
        ];

        $this->sources[$fileInfo['currentUri']] = $fileInfo['filename'];
    }

}