<?php
/**
 * FuzeWorks Framework Layout Template System.
 *
 * The FuzeWorks PHP FrameWork
 *
 * Copyright (C) 2013-2018 TechFuze
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * @author    TechFuze
 * @copyright Copyright (c) 2013 - 2018, TechFuze. (http://techfuze.net)
 * @license   https://opensource.org/licenses/MIT MIT License
 *
 * @link  http://techfuze.net/fuzeworks
 * @since Version 1.2.0
 *
 * @version Version 1.2.0
 */

use FuzeWorks\Factory;
use FuzeWorks\Layout;
use FuzeWorks\Events;
use FuzeWorks\EventPriority;

/**
 * Class LayoutTest.
 *
 * This test will test the layout manager and the default TemplateEngines
 */
class LayoutTest extends LayoutTestAbstract
{

    /**
     * @var Factory
     */
    protected $factory;

    /**
     * @var Layout
     */
    protected $layout;

    public function setUp()
    {
        // Load the factory first
        $this->factory = Factory::getInstance();
        $this->layout = Factory::getInstance()->layouts;
        $this->layout->reset();
    }

    /**
     * @covers \FuzeWorks\Layout::init
     * @covers \FuzeWorks\LayoutComponent::getClasses
     */
    public function testComponent()
    {
        // Load the component
        $component = new FuzeWorks\LayoutComponent();

        // Prepare container
        $configurator = new \FuzeWorks\Configurator();
        $configurator->addComponent($component);
        $configurator->addDirectory(dirname(__DIR__) . '/application');

        // Create container
        $container = $configurator->createContainer();

        // Init container
        $container = $container->init();
        $this->assertTrue(property_exists($container, 'layouts'));
        $this->assertInstanceOf('FuzeWorks\Layout', $container->layouts);
    }

    /**
     * @covers \FuzeWorks\Layout::setFile
     * @covers \FuzeWorks\Layout::getFile
     * @covers \FuzeWorks\Layout::setDirectory
     * @covers \FuzeWorks\Layout::getDirectory
     */
    public function testFileAndDirectory()
    {
        // File test
        $file = 'test.php';
        $this->layout->setFile($file);
        $this->assertEquals($file, $this->layout->getFile());

        // Directory test
        $directory = 'test'.DS.'templates'.DS.'testFileAndDirectory';
        $this->layout->setDirectory($directory);
        $this->assertEquals($directory, $this->layout->getDirectory());
    }

    /**
     * @covers \FuzeWorks\Layout::getExtensionFromFile
     */
    public function testGetFileExtensions()
    {
        // Test getting php files
        $this->assertEquals('php', $this->layout->getExtensionFromFile('class.test.php'));
        $this->assertEquals('php', $this->layout->getExtensionFromFile('class.test.org.php'));
        $this->assertEquals('random', $this->layout->getExtensionFromFile('class.test.something.random'));
    }

    /**
     * @depends testGetFileExtensions
     * @covers \FuzeWorks\Layout::setFileFromString
     * @covers \FuzeWorks\Layout::getFileFromString
     */
    public function testGetFilePath()
    {
        // Extensions to be used in this test
        $extensions = array('php', 'json');

        // Basic path
        $this->layout->setFileFromString('test', 'test'.DS.'templates'.DS.'testGetFilePath', $extensions);
        $this->assertEquals('test'.DS.'templates'.DS.'testGetFilePath'.DS.'layout.test.php', $this->layout->getFile());
        $this->assertEquals('test'.DS.'templates'.DS.'testGetFilePath'.DS, $this->layout->getDirectory());

        // Alternate file extension
        $this->layout->setFileFromString('JSON', 'test'.DS.'templates'.DS.'testGetFilePath', $extensions);
        $this->assertEquals('test'.DS.'templates'.DS.'testGetFilePath'.DS.'layout.JSON.json', $this->layout->getFile());
        $this->assertEquals('test'.DS.'templates'.DS.'testGetFilePath'.DS, $this->layout->getDirectory());

        // Complex deeper path
        $this->layout->setFileFromString('Deeper/test', 'test'.DS.'templates'.DS.'testGetFilePath', $extensions);
        $this->assertEquals('test'.DS.'templates'.DS.'testGetFilePath'.DS.'Deeper'.DS.'layout.test.php', $this->layout->getFile());
        $this->assertEquals('test'.DS.'templates'.DS.'testGetFilePath'.DS, $this->layout->getDirectory());
    }

    /**
     * @depends testGetFilePath
     * @expectedException FuzeWorks\Exception\LayoutException
     * @covers \FuzeWorks\Layout::setFileFromString
     * @covers \FuzeWorks\Layout::getFileFromString
     */
    public function testMalformedPaths()
    {
        // Extensions to be used in this test
        $extensions = array('php', 'json');

        $this->layout->setFileFromString('test?\/<>', 'test|?/*<>', $extensions);
    }

    /**
     * @expectedException FuzeWorks\Exception\LayoutException
     * @covers \FuzeWorks\Layout::setFileFromString
     * @covers \FuzeWorks\Layout::getFileFromString
     */
    public function testMissingDirectory()
    {
        // Directory that does not exist
        $this->layout->setFileFromString('test', 'test'.DS.'templates'.DS.'doesNotExist'.DS, array('php'));
    }

    /**
     * @expectedException FuzeWorks\Exception\LayoutException
     * @covers \FuzeWorks\Layout::setFileFromString
     * @covers \FuzeWorks\Layout::getFileFromString
     */
    public function testMissingFile()
    {
        $this->layout->setFileFromString('test', 'test'.DS.'templates'.DS.'testMissingFile'.DS, array('php'));
    }

    /**
     * @expectedException FuzeWorks\Exception\LayoutException
     * @covers \FuzeWorks\Layout::setFileFromString
     * @covers \FuzeWorks\Layout::getFileFromString
     */
    public function testUnknownFileExtension()
    {
        $this->layout->setFileFromString('test', 'test'.DS.'templates'.DS.'testUnknownFileExtension'.DS, array('php'));
    }

    /**
     * @covers \FuzeWorks\Layout::get
     */
    public function testLayoutGet()
    {
        // Directory of these tests
        $directory = 'test'.DS.'templates'.DS.'testLayoutGet'.DS;

        $this->assertEquals('Retrieved Data', $this->layout->get('test', $directory));
    }

    /**
     * @covers \FuzeWorks\Layout::get
     */
    public function testLayoutGetRepeat()
    {
        $directory = 'test'.DS.'templates'.DS.'testLayoutGetRepeat'.DS;
        $this->assertEquals('First Data', $this->layout->get('first', $directory));
        $this->assertEquals('Second Data', $this->layout->get('second', $directory));
    }

    /**
     * @covers \FuzeWorks\Layout::get
     * @covers \FuzeWorks\Event\LayoutLoadEvent::init
     */
    public function testLayoutGetCancelledEvent()
    {
        $directory = 'test'.DS.'templates'.DS.'testLayoutGetCancelledEvent';
        Events::addListener(function($event){
            $event->setCancelled(true);
        }, 'layoutLoadEvent', EventPriority::NORMAL);
        $this->assertEquals('cancelled', $this->layout->get('test', $directory));
    }

    /**
     * @expectedException FuzeWorks\Exception\LayoutException
     * @covers \FuzeWorks\Layout::get
     * @covers \FuzeWorks\Event\LayoutLoadEvent::init
     */
    public function testLayoutGetEventWrongFile()
    {
        $directory = 'test'.DS.'templates'.DS.'testLayoutGetEventWrongFile';
        Events::addListener(function($event){
            $event->file = 'does_not_exist';
        }, 'layoutLoadEvent', EventPriority::NORMAL);
        $this->layout->get('test', $directory);
    }

    /**
     * @covers \FuzeWorks\Layout::display
     * @covers \FuzeWorks\Event\LayoutDisplayEvent::init
     */
    public function testLayoutDisplayEventAndDisplay()
    {
        // Directory of these tests
        $directory = 'test'.DS.'templates'.DS.'testLayoutGet'.DS;
        Events::addListener(function($event){
            $this->assertEquals('Retrieved Data', $event->contents);
        }, 'layoutDisplayEvent', EventPriority::NORMAL);

        ob_start();
        $this->layout->display('test', $directory);
        $this->assertEquals('Retrieved Data', ob_get_contents());
        ob_end_clean();
    }

    /**
     * @covers \FuzeWorks\Layout::reset
     * @covers \FuzeWorks\Layout::setTitle
     * @covers \FuzeWorks\Layout::getTitle
     */
    public function testReset()
    {
        // First the the variables
        $this->layout->setTitle('Test Title');
        $this->layout->setDirectory('test'.DS.'templates'.DS.'testLayoutGet');

        // Test if they are actually set
        $this->assertEquals('Test Title', $this->layout->getTitle());
        $this->assertEquals('test'.DS.'templates'.DS.'testLayoutGet', $this->layout->getDirectory());

        // Reset the layout system
        $this->layout->reset();

        // Test for default values
        $this->assertFalse($this->layout->getTitle());
        $this->assertTrue(strpos($this->layout->getDirectory(), 'application' . DS . 'Layout') !== false);
    }

    /**
     * @covers \FuzeWorks\Layout::getEngineFromExtension
     */
    public function testGetEngineFromExtension()
    {
        $this->layout->loadTemplateEngines();

        // Test all the default engines
        $this->assertInstanceOf('FuzeWorks\TemplateEngine\PHPEngine', $this->layout->getEngineFromExtension('php'));
        $this->assertInstanceOf('FuzeWorks\TemplateEngine\JsonEngine', $this->layout->getEngineFromExtension('json'));
        $this->assertInstanceOf('FuzeWorks\TemplateEngine\SmartyEngine', $this->layout->getEngineFromExtension('tpl'));
    }

    /**
     * @depends testGetEngineFromExtension
     * @expectedException FuzeWorks\Exception\LayoutException
     * @covers \FuzeWorks\Layout::getEngineFromExtension
     */
    public function testGetEngineFromExtensionFail()
    {
        $this->layout->getEngineFromExtension('faulty');
    }

    /**
     * @covers \FuzeWorks\Layout::loadTemplateEngines
     */
    public function testLoadTemplateEngines()
    {
        // Load first try
        $this->assertTrue($this->layout->loadTemplateEngines());

        // Try second time
        $this->assertFalse($this->layout->loadTemplateEngines());

        // Reset
        $this->layout->reset();
        $this->assertTrue($this->layout->loadTemplateEngines());
    }

    /**
     * @covers \FuzeWorks\Layout::loadTemplateEngines
     * @expectedException \FuzeWorks\Exception\LayoutException
     */
    public function testLoadLoadEngineEvent()
    {
        Events::addListener(function($event){
            $this->assertInstanceOf('\FuzeWorks\Event\NotifierEvent', $event);
            throw new \FuzeWorks\Exception\EventException('Forcing failure in loadTemplateEngines()');
        }, 'layoutLoadEngineEvent', EventPriority::NORMAL);

        $this->layout->loadTemplateEngines();
    }

    /**
     * @depends testGetEngineFromExtension
     * @covers \FuzeWorks\Layout::registerEngine
     */
    public function testCustomEngine()
    {
        // Create the engine
        $mock = $this->getMockBuilder('FuzeWorks\TemplateEngine\TemplateEngine')->getMock();

        // Add the methods
        $mock->method('get')->willReturn('output');

        // And listen for usage
        $mock->expects($this->once())->method('get')->with('test'.DS.'templates'.DS.'testCustomEngine'.DS.'layout.test.test');

        // Register the engine
        $this->layout->registerEngine($mock, 'Custom', array('test'));

        // And run the engine
        $this->assertEquals('output', $this->layout->get('test', 'test'.DS.'templates'.DS.'testCustomEngine'));
    }


    /**
     * @depends testCustomEngine
     * @expectedException \FuzeWorks\Exception\LayoutException
     * @covers \FuzeWorks\Layout::registerEngine
     */
    public function testExistingCustomEngine()
    {
        // Create mock
        $mock = $this->getMockBuilder('FuzeWorks\TemplateEngine\TemplateEngine')->getMock();
        $mock->method('get')->willReturn('output');

        // And register
        $this->assertTrue($this->layout->registerEngine($mock, 'Custom', ['test']));

        // And re-register
        $this->layout->registerEngine($mock, 'Custom', ['othertest']);
    }

    /**
     * @depends testCustomEngine
     * @expectedException \FuzeWorks\Exception\LayoutException
     * @covers \FuzeWorks\Layout::registerEngine
     */
    public function testCustomEngineWithExistingExtensions()
    {
        // Create mock
        $mock = $this->getMockBuilder('FuzeWorks\TemplateEngine\TemplateEngine')->getMock();
        $mock->method('get')->willReturn('output');

        // Register initial
        $this->assertTrue($this->layout->registerEngine($mock, 'Custom', ['test']));

        // Register failing
        $this->layout->registerEngine($mock, 'other', ['test']);
    }

    /**
     * @depends testCustomEngine
     * @covers \FuzeWorks\Layout::setEngine
     * @covers \FuzeWorks\Layout::getEngine
     */
    public function testSetEngine()
    {
        // Create mocks
        $mock = $this->getMockBuilder('FuzeWorks\TemplateEngine\TemplateEngine')->getMock();
        $mock2 = $this->getMockBuilder('FuzeWorks\TemplateEngine\TemplateEngine')->getMock();
        $mock->method('get')->willReturn('output');
        $mock2->method('get')->willReturn('output2');

        // Register custom engine
        $this->assertTrue($this->layout->registerEngine($mock, 'custom', ['test']));
        $this->assertTrue($this->layout->registerEngine($mock2, 'custom2', ['test2']));

        // Test getEngine
        $this->assertInstanceOf(get_class($mock), $this->layout->getEngine('custom'));
        $this->assertInstanceOf(get_class($mock2), $this->layout->getEngine('custom2'));

        // Test setEngine1
        $this->assertTrue($this->layout->setEngine('custom'));
        $this->assertTrue($this->layout->setEngine('custom2'));
    }

    /**
     * @depends testSetEngine
     * @expectedException \FuzeWorks\Exception\LayoutException
     * @covers \FuzeWorks\Layout::setEngine
     */
    public function testSetInvalidEngine()
    {
        $this->layout->setEngine('invalid');
    }

    /**
     * @depends testSetEngine
     * @expectedException \FuzeWorks\Exception\LayoutException
     * @covers \FuzeWorks\Layout::getEngine
     */
    public function testGetInvalidEngine()
    {
        $this->layout->getEngine('invalid');
    }

    /**
     * @covers \FuzeWorks\Layout::registerEngine
     */
    public function testEnginesLoadLayout()
    {
        // Directory of these tests
        $directory = 'test'.DS.'templates'.DS.'testEngines'.DS;

        // First the PHP Engine
        $this->assertEquals('PHP Template Check', $this->layout->get('php', $directory));
        $this->layout->reset();

        // Then the JSON Engine
        $this->assertEquals('JSON Template Check', json_decode($this->layout->get('json', $directory), true)[0]);
        $this->layout->reset();

        // And the Smarty Engine
        $this->assertEquals('Smarty Template Check', $this->layout->get('smarty', $directory));
    }

    /**
     * @covers \FuzeWorks\Layout::assign
     */
    public function testEngineVariables()
    {
        // Directory of these tests
        $directory = 'test'.DS.'templates'.DS.'testEngineVariables'.DS;

        // First the PHP Engine
        $this->layout->assign('key', 'value');
        $this->assertEquals('value', $this->layout->get('php', $directory));
        $this->layout->reset();

        // Then the JSON Engine
        $this->layout->assign('key', 'value');
        $this->assertEquals('value', json_decode($this->layout->get('json', $directory), true)['data']['key']);
        $this->layout->reset();

        // And the Smarty Engine
        $this->layout->assign('key', 'value');
        $this->assertEquals('value', $this->layout->get('smarty', $directory));
    }
}

class MockEngine {

}