<?php

/**
 * Created by PhpStorm.
 * User: danilo
 * Date: 18/12/15
 * Time: 10:58
 */
namespace Modules\Core\Services;

use Theme;

/**
 * Asset class
 *
 */
class Asset
{
    // This constant indicates where to add a asset;
    const ADD_TO_NONE = 0;
    const ADD_TO_CSS = 1;
    const ADD_TO_LESS = 2;
    const ADD_TO_JS = 3;

    /*
     * If the assert To add do not have extension or the extension
     * is unknown this constant indicate what to do:
     */
    const ON_UNKNOWN_EXTENSION_NONE = 0;
    const ON_UNKNOWN_EXTENSION_CSS = 1;
    const ON_UNKNOWN_EXTENSION_LESS = 2;
    const ON_UNKNOWN_EXTENSION_JS = 3;
    public static $css = array();
    public static $less = array();
    public static $styles = array();
    public static $javascript = array();
    public static $scripts = array();
    public static $domain = '/';
    public static $prefix = '';
    public static $hash = array();
    public static $environment = null;
    public static $secure = false;
    protected static $cacheBusterGenerator = null;
    private static $onUnknownExtensionToAddTo = array(
        Asset::ON_UNKNOWN_EXTENSION_NONE => Asset::ADD_TO_CSS,
        Asset::ON_UNKNOWN_EXTENSION_LESS => Asset::ADD_TO_LESS,
        Asset::ON_UNKNOWN_EXTENSION_JS => Asset::ADD_TO_JS
    );
    private static $useShortHandReady = false;
    private static $unknownExtension = Asset::ON_UNKNOWN_EXTENSION_NONE;

    /**
     * Set domain name
     *
     * @param string $url
     *
     * @return void
     */
    public static function setDomain($url)
    {
        if (is_string($url)) {
            static::$domain = $url;
        }
    }

    /**
     * Set prefix
     *
     * @param string $prefix
     *
     * @return void
     */
    public static function setPrefix($prefix)
    {
        static::$prefix = $prefix;
    }

    /**
     * Set cache buster JSON file
     *
     * @param string $cachebuster
     *
     * @return void
     */
    public static function setCachebuster($cachebuster)
    {
        if (file_exists($cachebuster)) {
            static::$hash = json_decode(file_get_contents($cachebuster), true);
        }
    }

    /**
     * Set cache buster function
     *
     * @param Callable $fn
     *
     * Callable must accepts ONE argument {String} (filename)
     * and return a {String} (hash without filename and "?")
     *
     * @return void
     */
    public static function setcacheBusterGenerator($fn)
    {
        static::$cacheBusterGenerator = $fn;
    }

    /**
     * Set indicator if use Short Hand [$()] or Normal $( document ).ready()
     *
     * @param boolean $useShortHandReady
     *
     * @return void
     */
    public static function setUseShortHandReady($useShortHandReady)
    {
        static::$useShortHandReady = $useShortHandReady;
    }

    /**
     * Indicate what to do by default if an unknown extension is found.
     *
     * @param int (static::ON_UNKNOWN_EXTENSION_NONE,
     *             static::ON_UNKNOWN_EXTENSION_JS) $unknownExtension
     *
     * @return void
     */
    public static function setOnUnknownExtensionDefault($unknownExtension)
    {
        if ((!is_int($unknownExtension))
            || ($unknownExtension < static::ON_UNKNOWN_EXTENSION_NONE)
            || ($unknownExtension > static::ON_UNKNOWN_EXTENSION_JS)
        ) {
            $unknownExtension = static::ON_UNKNOWN_EXTENSION_NONE;
        }

        static::$unknownExtension = $unknownExtension;
    }

    /**
     * Add new asset
     *
     * @param string $a
     * @param string $name
     * @param int (static::ON_UNKNOWN_EXTENSION_NONE,
     *             static::ON_UNKNOWN_EXTENSION_JS) $onUnknownExtension
     *
     * @return void
     */
    public static function add($a, $name = 'footer', $onUnknownExtension = false)
    {
        if (is_array($a)) {
            foreach ($a as $item) {
                static::processAdd($item, $name, $onUnknownExtension);
            }
        } else {
            static::processAdd($a, $name, $onUnknownExtension);
        }
    }

    /**
     * Process add method
     *
     * @param string $a
     * @param string $name
     *
     * @return void
     */
    protected static function processAdd($a, $name, $onUnknownExtension = false)
    {
        switch (static::getAddTo($a, $onUnknownExtension)) {
            case static::ADD_TO_CSS:
                static::$css[] = $a;
                break;
            case static::ADD_TO_LESS:
                static::$less[] = $a;
                break;
            case static::ADD_TO_JS:
                static::$javascript[$name][] = $a;
                break;
        }
    }

    /**
     * Identify where to add an asset:
     *
     * @param string $a
     * @param int (static::ON_UNKNOWN_EXTENSION_NONE,
     *             static::ON_UNKNOWN_EXTENSION_JS)/boolean $onUnknownExtension
     *
     * @return int (static::ADD_TO_NONE, static::ADD_TO_JS)
     */
    private static function getAddTo($a, $onUnknownExtension = false)
    {
        if (false === $onUnknownExtension) {
            $onUnknownExtension = static::$unknownExtension;
        }

        if (preg_match("/(\.css|\/css\?)/i", $a)) {
            // css
            return static::ADD_TO_CSS;
        } elseif (preg_match("/\.less/i", $a)) {
            // less
            return static::ADD_TO_LESS;
        } elseif (preg_match("/\.js|\/js/i", $a)) {
            // js
            return static::ADD_TO_JS;
        } elseif ((static::ON_UNKNOWN_EXTENSION_NONE != $onUnknownExtension) && isset(static::$onUnknownExtensionToAddTo[$onUnknownExtension])) {
            return static::$onUnknownExtensionToAddTo[$onUnknownExtension];
        }

        return static::ADD_TO_NONE;
    }

    /**
     * Add new asset before another asset in its array
     *
     * @param string $asset
     * @param string $before
     * @param string $name
     *
     * @return void
     */
    public static function addBefore($asset, $before, $name = 'footer', $onUnknownExtension = false)
    {
        switch (static::getAddTo($asset, $onUnknownExtension)) {
            case static::ADD_TO_CSS:
                $pos = array_search($before, static::$css);
                self::addToPosition($asset, $name, $pos, static::$css);
                break;
            case static::ADD_TO_LESS:
                $pos = array_search($before, static::$less);
                self::addToPosition($asset, $name, $pos, static::$less);
                break;
            case static::ADD_TO_JS:
                if (!empty(static::$javascript[$name])) {
                    $pos = array_search($before, static::$javascript[$name]);
                    self::addToPosition($asset, $name, $pos, static::$javascript[$name]);
                }
                break;
        }
    }

    /**
     * @param $asset
     * @param $before
     * @param $name
     * @param $pos
     * @param $collection
     */
    private static function addToPosition($asset, $name, $pos, &$collection)
    {
        if ($pos === 0) {
            static::addFirst($asset, $name);
        } elseif ($pos >= 1) {
            $barr = array_slice($collection, $pos);
            $aarr = array_slice($collection, 0, $pos);
            array_push($aarr, $asset);
            $collection = array_merge($aarr, $barr);
        } else {
            $collection[] = $asset;
        }
    }

    /**
     * Add new asset as first in its array
     *
     * @param string $asset
     * @param string $name
     *
     * @return void
     */
    public static function addFirst($asset, $name = 'footer', $onUnknownExtension = false)
    {
        switch (static::getAddTo($asset, $onUnknownExtension)) {
            case static::ADD_TO_CSS:
                array_unshift(static::$css, $asset);
                break;
            case static::ADD_TO_LESS:
                array_unshift(static::$less, $asset);
                break;
            case static::ADD_TO_JS:
                if (!empty(static::$javascript[$name])) {
                    array_unshift(static::$javascript[$name], $asset);
                } else {
                    static::$javascript[$name][] = $asset;
                }
                break;
        }
    }

    /**
     * Add new asset after another asset in its array
     *
     * @param string $asset
     * @param string $before
     * @param string $name
     *
     * @return void
     */
    public static function addAfter($asset, $before, $name = 'footer', $onUnknownExtension = false)
    {
        switch (static::getAddTo($asset, $onUnknownExtension)) {
            case static::ADD_TO_CSS:
                $pos = array_search($before, static::$css) + 1;
                self::addToPosition($asset, $name, $pos, static::$css);
                break;
            case static::ADD_TO_LESS:
                $pos = array_search($before, static::$less) + 1;
                self::addToPosition($asset, $name, $pos, static::$less);
                break;
            case static::ADD_TO_JS:
                if (!empty(static::$javascript[$name])) {
                    $pos = array_search($before, static::$javascript[$name]) + 1;
                    self::addToPosition($asset, $name, $pos, static::$javascript[$name]);
                }
                break;
        }
    }

    /**
     * Add new script
     *
     * @param string $script
     * @param string $name
     *
     * @return void
     */
    public static function addScript($script, $name = 'footer')
    {
        static::$scripts[$name][] = $script;
    }

    /**
     * Add new style
     *
     * @param string $style
     * @param string $section
     *
     * @return void
     */
    public static function addStyle($style, $section = 'header')
    {
        static::$styles[$section][] = $style;
    }

    /**
     * Loads all items from $css array not wrapped in <link> tags
     *
     * @param string $separator
     *
     * @return void
     */
    public static function cssRaw($separator = "")
    {
        static::checkEnv();

        if (!empty(static::$css)) {
            foreach (static::$css as $file) {
                echo static::$prefix, static::url($file), $separator;
            }
        }
    }

    /**
     * Check environment
     *
     * @return void
     */
    public static function checkEnv()
    {
        if (static::$environment == null) {
            static::$environment = \App::environment();
        }

        // use only local files in local environment
        if (static::$environment == 'local' && (static::$domain != '/')) {
            static::$domain = '/';
        }
    }

    /**
     * Returns the full-path for an asset.
     *
     * @param  string $source
     * @return string
     */
    public static function url($file)
    {
        if (preg_match('/(https?:)?\/\//i', $file)) {
            return $file;
        }
        if (strstr($file, ":")) {
            $moduleAsset = explode(':', $file);
            $module = $moduleAsset[0];
            $file = "modules/" . $module . "/" . $moduleAsset[1];
        }

        $file = static::generateCacheBusterFilename($file);

        if (static::$domain == '/' && static::$environment != 'testing') {
            if (isset($module)) {
                return asset($file, static::$secure);
            }

            return Theme::url($file, static::$secure);
        }

        return rtrim(static::$domain, '/') . '/' . ltrim($file, '/');
    }

    /**
     * Generate cache buster filename
     *
     * @param string $a
     * @param string $name
     *
     * @return string
     */
    private static function generateCacheBusterFilename($a)
    {
        $hash = '';
        if (!is_callable(static::$cacheBusterGenerator)) {
            if (is_array(static::$hash) && array_key_exists($a, static::$hash)) {
                $hash .= static::$hash[$a];
            }
        } else {
            $hash = call_user_func_array(static::$cacheBusterGenerator, array($a));
        }

        if (is_string($hash) && $hash !== '') {
            $a .= '?' . $hash;
        }

        return $a;
    }

    /**
     * Loads all items from $css array
     *
     * @return void
     */
    public static function css()
    {
        static::checkEnv();

        if (!empty(static::$css)) {
            foreach (static::$css as $file) {
                echo static::$prefix, '<link rel="stylesheet" type="text/css" href="', static::url($file), "\" />\n";
            }
        }
    }


    /**
     * Loads all items from $less array not wrapped in <link> tags
     *
     * @param string $separator
     *
     * @return void
     */
    public static function lessRaw($separator = "")
    {
        static::checkEnv();

        if (!empty(static::$less)) {
            foreach (static::$less as $file) {
                echo static::$prefix, static::url($file), $separator;
            }
        }
    }


    /**
     * Loads all items from $less array
     *
     * @return void
     */
    public static function less()
    {
        static::checkEnv();

        if (!empty(static::$less)) {
            foreach (static::$less as $file) {
                echo static::$prefix, '<link rel="stylesheet/less" type="text/css" href="', static::url($file), "\" />\n";
            }
        }
    }


    /**
     * Loads all items from $styles array
     *
     * @param string $name
     *
     * @return void
     */
    public static function styles($name = 'header')
    {
        if (($name !== '') && (!empty(static::$styles[$name]))) {
            echo "\n", static::$prefix, "<style type=\"text/css\">\n", static::$prefix;

            foreach (static::$styles[$name] as $style) {
                echo "$style\n", static::$prefix;
            }

            echo static::$prefix, "</style>\n";
        } elseif (!empty(static::$styles)) {
            echo static::$prefix, "<style type=\"text/css\">\n";

            foreach (static::$styles as $style) {
                echo "$style\n";
            }

            echo "</style>\n";
        }
    }


    /**
     * Loads items from $javascript array not wrapped in <script> tags
     *
     * @param string $separator
     * @param string $name
     *
     * @return void
     */
    public static function jsRaw($separator = "", $name = 'footer')
    {
        static::checkEnv();

        if (!empty(static::$javascript[$name])) {
            foreach (static::$javascript[$name] as $file) {
                echo static::$prefix, static::url($file), $separator;
            }
        }
    }


    /**
     * Loads items from $javascript array
     *
     * @param string $name
     * @param boolean $tags
     * @param string $join
     *
     * @return void
     */
    public static function js($name = 'footer')
    {
        static::checkEnv();

        if ($name === false) {
            $name = 'footer';
        }

        if (!empty(static::$javascript[$name])) {
            foreach (static::$javascript[$name] as $file) {
                echo static::$prefix, '<script src="', static::url($file), "\"></script>\n";
            }
        }
    }


    /**
     * Loads items from $scripts array
     *
     * @param string $name
     *
     * @return void
     */
    public static function scripts($name = 'footer')
    {
        if ($name == 'ready') {
            if (!empty(static::$scripts['ready'])) {
                echo static::$prefix, '<script>', (static::$useShortHandReady ? '$(' : '$(document).ready('), "function(){\n";

                foreach (static::$scripts['ready'] as $script) {
                    echo "$script\n", static::$prefix;
                }

                echo "});</script>\n";
            }
        } else {
            if (!empty(static::$scripts[$name])) {
                foreach (static::$scripts[$name] as $script) {
                    echo static::$prefix, "<script>\n$script\n</script>\n";
                }
            }
        }
    }
}