<?php declare(strict_types=1);
/**
 * Part of Windwalker project.
 *
 * @copyright  Copyright (C) 2019 LYRASOFT.
 * @license    GNU General Public License version 2 or later.
 */

namespace Windwalker\Renderer;

use Windwalker\Edge\Cache\EdgeArrayCache;
use Windwalker\Edge\Cache\EdgeCacheInterface;
use Windwalker\Edge\Cache\EdgeFileCache;
use Windwalker\Edge\Compiler\EdgeCompiler;
use Windwalker\Edge\Compiler\EdgeCompilerInterface;
use Windwalker\Edge\Edge;
use Windwalker\Edge\Exception\LayoutNotFoundException;
use Windwalker\Edge\Extension\EdgeExtensionInterface;
use Windwalker\Edge\Loader\EdgeFileLoader;
use Windwalker\Edge\Loader\EdgeLoaderInterface;
use Windwalker\Renderer\Edge\GlobalContainer;

/**
 * The EdgeRenderer class.
 *
 * @since  3.0
 */
class EdgeRenderer extends AbstractEngineRenderer
{
    /**
     * Property compiler.
     *
     * @var  EdgeCompilerInterface
     */
    protected $compiler;

    /**
     * Property loader.
     *
     * @var  EdgeLoaderInterface
     */
    protected $loader;

    /**
     * Property cache.
     *
     * @var  EdgeCacheInterface
     */
    protected $cache;

    /**
     * Property extensions.
     *
     * @var  callable[]
     */
    protected $extensions = [];

    /**
     * Method to get property Engine
     *
     * @param   boolean $new
     *
     * @return  Edge
     */
    public function getEngine($new = false)
    {
        if (!$this->engine || $new) {
            $this->loader = null;
            $this->compiler = null;
            $this->cache = null;

            $edge = new Edge($this->getLoader(), $this->getCompiler(), $this->getCache());

            foreach (GlobalContainer::getExtensions() as $name => $extension) {
                $edge->addExtension($extension, $name);
            }

            foreach ($this->getExtensions() as $name => $extension) {
                $edge->addExtension($extension, $name);
            }

            foreach (GlobalContainer::getGlobals() as $key => $value) {
                $edge->addGlobal($key, $value);
            }

            $this->engine = $edge;
        }

        return $this->engine;
    }

    /**
     * Method to set property engine
     *
     * @param   Edge $engine
     *
     * @return  static  Return self to support chaining.
     */
    public function setEngine($engine)
    {
        if (!$this->engine instanceof Edge) {
            throw new \InvalidArgumentException('Engine should be instance of Edge');
        }

        $this->engine = $engine;

        return $this;
    }

    /**
     * render
     *
     * @param string $file
     * @param array  $data
     *
     * @return  string
     * @throws \Windwalker\Edge\Exception\EdgeException
     */
    public function render($file, $data = [])
    {
        if ($data instanceof \Traversable) {
            $data = iterator_to_array($data);
        }

        if (is_object($data)) {
            $data = get_object_vars($data);
        }

        return $this->getEngine(true)->render($file, (array) $data);
    }

    /**
     * finFile
     *
     * @param string $file
     * @param string $ext
     *
     * @return  string
     */
    public function findFile($file, $ext = '')
    {
        try {
            return $this->getEngine()->getLoader()->find($file);
        } catch (LayoutNotFoundException $e) {
            return null;
        }
    }

    /**
     * Method to get property Compiler
     *
     * @return  EdgeCompilerInterface
     */
    public function getCompiler()
    {
        if (!$this->compiler) {
            $this->compiler = new EdgeCompiler();
        }

        return $this->compiler;
    }

    /**
     * Method to set property compiler
     *
     * @param   EdgeCompilerInterface $compiler
     *
     * @return  static  Return self to support chaining.
     */
    public function setCompiler($compiler)
    {
        $this->compiler = $compiler;

        return $this;
    }

    /**
     * Method to get property Loader
     *
     * @return  EdgeLoaderInterface
     */
    public function getLoader()
    {
        if (!$this->loader) {
            $this->loader = new EdgeFileLoader($this->dumpPaths());
        }

        return $this->loader;
    }

    /**
     * Method to set property loader
     *
     * @param   EdgeLoaderInterface $loader
     *
     * @return  static  Return self to support chaining.
     */
    public function setLoader($loader)
    {
        $this->loader = $loader;

        return $this;
    }

    /**
     * Method to get property Cache
     *
     * @return  EdgeCacheInterface
     */
    public function getCache()
    {
        if (!$this->cache) {
            if ($this->config->exists('cache_path')) {
                $this->cache = new EdgeFileCache($this->config->get('cache_path'));
            } else {
                $this->cache = new EdgeArrayCache();
            }
        }

        return $this->cache;
    }

    /**
     * Method to set property cache
     *
     * @param   EdgeCacheInterface $cache
     *
     * @return  static  Return self to support chaining.
     */
    public function setCache($cache)
    {
        $this->cache = $cache;

        return $this;
    }

    /**
     * Method to get property Extensions
     *
     * @return  EdgeExtensionInterface[]
     */
    public function getExtensions()
    {
        return $this->extensions;
    }

    /**
     * Method to set property extensions
     *
     * @param   EdgeExtensionInterface[] $extensions
     *
     * @return  static  Return self to support chaining.
     */
    public function setExtensions($extensions)
    {
        $this->extensions = $extensions;

        return $this;
    }

    /**
     * addExtension
     *
     * @param   EdgeExtensionInterface $extension
     * @param   string                 $name
     *
     * @return static
     */
    public function addExtension(EdgeExtensionInterface $extension, $name = null)
    {
        $this->extensions[$name ?: $extension->getName()] = $extension;

        return $this;
    }
}