<?php
/**
 * FuzeWorks Async Library
 *
 * The FuzeWorks PHP FrameWork
 *
 * Copyright (C) 2013-2020 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 - 2020, TechFuze. (http://techfuze.net)
 * @license   https://opensource.org/licenses/MIT MIT License
 *
 * @link  http://techfuze.net/fuzeworks
 * @since Version 1.0.0
 *
 * @version Version 1.0.0
 */

use FuzeWorks\Async\Constraint;
use FuzeWorks\Async\Handler;
use FuzeWorks\Async\Task;
use FuzeWorks\Async\TasksException;
use Mock\Handlers\EmptyHandler;
use PHPUnit\Framework\TestCase;

class TaskTest extends TestCase
{

    public function testClass()
    {
        // Create dummy task
        $dummyTask = new Task('testClass', new EmptyHandler());

        // And check the class. A pretty useless but standard test
        $this->assertInstanceOf('FuzeWorks\Async\Task', $dummyTask);
    }

    /* ---------------------------------- Basic variables tests --------------------------- */

    /**
     * @depends testClass
     */
    public function testBaseVariables()
    {
        // Create dummy task
        $dummyTask = new Task('testBaseVariables', new EmptyHandler(), true);

        // test the values
        $this->assertEquals('testBaseVariables', $dummyTask->getId());
        $this->assertInstanceOf(EmptyHandler::class, $dummyTask->getHandler());
        $this->assertTrue($dummyTask->getUsePostHandler());
    }

    /**
     * @depends testBaseVariables
     */
    public function testArguments()
    {
        // Create task without arguments
        $dummyTask1 = new Task('testArguments1', new EmptyHandler(), true);
        $this->assertEmpty($dummyTask1->getArguments());

        // Now create a task with some arguments
        $dummyTask2 = new Task('testArguments2', new EmptyHandler(), true, 'some', 'arguments');
        $this->assertEquals(['some', 'arguments'], $dummyTask2->getArguments());
    }

    /**
     * @depends testBaseVariables
     */
    public function testPostHandler()
    {
        // Create dummy tasks
        $dummyTask1 = new Task('testPostHandler1', new EmptyHandler(), true);
        $dummyTask2 = new Task('testPostHandler2', new EmptyHandler(), false);

        $this->assertTrue($dummyTask1->getUsePostHandler());
        $this->assertFalse($dummyTask2->getUsePostHandler());
    }

    /**
     * @depends testBaseVariables
     */
    public function testConstraints()
    {
        // First create a mock constraint
        $stub = $this->createMock(Constraint::class);

        // Then add it to the task
        $dummyTask = new Task('testConstraints', new EmptyHandler(), false);
        $dummyTask->addConstraint($stub);

        // Assert it exists
        $this->assertEquals([$stub], $dummyTask->getConstraints());
    }

    /**
     * @depends testBaseVariables
     */
    public function testInitHandler()
    {
        $mockHandler = $this->createMock(Handler::class);
        $mockHandler->expects($this->once())->method('init')
            ->with($this->callback(function($subject){return $subject instanceof Task;}));

        // Then create a class
        new Task('testInitHandler', $mockHandler);
    }

    /**
     * @depends testBaseVariables
     */
    public function testStatusCodes()
    {
        // Create dummy task
        $dummyTask = new Task('testStatusCodes', new EmptyHandler(), true);

        for ($i = 1; $i <= 9; $i++) {
            $dummyTask->setStatus($i);
            $this->assertEquals($i, $dummyTask->getStatus());
        }
    }

    /**
     * @depends testBaseVariables
     */
    public function testDelayTime()
    {
        // Create dummy task
        $dummyTask = new Task('testDelayTime', new EmptyHandler(), true);

        $this->assertEquals(0, $dummyTask->getDelayTime());
        $dummyTask->setDelayTime(1000);
        $this->assertEquals(1000, $dummyTask->getDelayTime());
    }

    /**
     * @depends testBaseVariables
     */
    public function testAttributes()
    {
        // Create dummy task
        $dummyTask = new Task('testAttributes', new EmptyHandler(), true);

        // First test a non-existing attribute
        $this->assertNull($dummyTask->attribute('testKey'));

        // Now add it and test if it is there
        $dummyTask->addAttribute('testKey', 'SomeContent');
        $this->assertEquals('SomeContent', $dummyTask->attribute('testKey'));

        // Remove attribute
        $dummyTask->removeAttribute('testKey');
        $this->assertNull($dummyTask->attribute('testKey'));

        // Remove attribute not found
        $this->expectException(TasksException::class);
        $dummyTask->removeAttribute('NotExistant');
    }

    /**
     * @depends testBaseVariables
     */
    public function testOutputsAndErrors()
    {
        // Create dummy task
        $dummyTask = new Task('testOutputsAndErrors', new EmptyHandler(), true);

        // Check if non are filled
        $this->assertNull($dummyTask->getOutput());
        $this->assertNull($dummyTask->getPostOutput());
        $this->assertNull($dummyTask->getErrors());
        $this->assertNull($dummyTask->getPostErrors());

        // Then write some data to the task
        $dummyTask->setOutput('SomeOutput', 'SomeErrors');
        $dummyTask->setPostOutput('SomePostOutput', 'SomePostErrors');

        // And check again
        $this->assertEquals('SomeOutput', $dummyTask->getOutput());
        $this->assertEquals('SomePostOutput', $dummyTask->getPostOutput());
        $this->assertEquals('SomeErrors', $dummyTask->getErrors());
        $this->assertEquals('SomePostErrors', $dummyTask->getPostErrors());
    }

    /**
     * @depends testBaseVariables
     */
    public function testRetrySettings()
    {
        // Create dummy task
        $dummyTask = new Task('testRetrySettings', new EmptyHandler(), true);

        // Test starting position
        $this->assertEquals([
            'retryOnFail' => false,
            'maxRetries' => 2,
            'retryPFailures' => true,
            'retryRFailures' => true,
            'retryPostFailures' => true,
            'maxTime' => 30
        ], $dummyTask->getSettings());

        // Then change the settings
        $dummyTask->setSettings(true, 30, 60, false, false, false);

        // And test the new positions
        $this->assertEquals([
            'retryOnFail' => true,
            'maxRetries' => 30,
            'retryPFailures' => false,
            'retryRFailures' => false,
            'retryPostFailures' => false,
            'maxTime' => 60
        ], $dummyTask->getSettings());
    }

    /**
     * @depends testBaseVariables
     */
    public function testRetries()
    {
        // Create dummy task
        $dummyTask = new Task('testRetries', new EmptyHandler(), true);

        // First test the starting position
        $this->assertEquals(0, $dummyTask->getRetries());

        // Then add one and test
        $dummyTask->addRetry();
        $this->assertEquals(1, $dummyTask->getRetries());

        // Then reset it and test
        $dummyTask->resetRetries();
        $this->assertEquals(0, $dummyTask->getRetries());
    }

    public function testGetStatusType()
    {
        $this->assertEquals('Task::PENDING', Task::getStatusType(Task::PENDING));
        $this->assertEquals('Task::RUNNING', Task::getStatusType(Task::RUNNING));
        $this->assertEquals('Task::FAILED', Task::getStatusType(Task::FAILED));
        $this->assertEquals('Task::PFAILED', Task::getStatusType(Task::PFAILED));
        $this->assertEquals('Task::SUCCESS', Task::getStatusType(Task::SUCCESS));
        $this->assertEquals('Task::POST', Task::getStatusType(Task::POST));
        $this->assertEquals('Task::COMPLETED', Task::getStatusType(Task::COMPLETED));
        $this->assertEquals('Task::DELAYED', Task::getStatusType(Task::DELAYED));
        $this->assertEquals('Task::CANCELLED', Task::getStatusType(Task::CANCELLED));
        $this->assertFalse(Task::getStatusType(10));
    }
}