<?php

/**
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; under version 2
 * of the License (non-upgradable).
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 * Copyright (c) 2016 (original work) Open Assessment Technologies SA ;
 */

/**
 * @author Jean-Sébastien Conan <jean-sebastien.conan@vesperiagroup.com>
 */

namespace oat\taoQtiTest\models\runner\time;

use oat\taoTests\models\runner\time\ExtraTime;
use oat\taoTests\models\runner\time\InconsistentCriteriaException;
use oat\taoTests\models\runner\time\InconsistentRangeException;
use oat\taoTests\models\runner\time\InvalidDataException;
use oat\taoTests\models\runner\time\InvalidStorageException;
use oat\taoTests\models\runner\time\InvalidTimerStrategyException;
use oat\taoTests\models\runner\time\TimeException;
use oat\taoTests\models\runner\time\TimeLine;
use oat\taoTests\models\runner\time\TimePoint;
use oat\taoTests\models\runner\time\TimerAdjustmentMapInterface;
use oat\taoTests\models\runner\time\TimerStrategyInterface;
use oat\taoTests\models\runner\time\TimeStorage;
use oat\taoTests\models\runner\time\Timer;

/**
 * Class QtiTimer
 * @package oat\taoQtiTest\models\runner\time
 */
class QtiTimer implements Timer, ExtraTime, \JsonSerializable
{

    /**
     * The TimeLine used to compute the duration
     * @var TimeLine
     */
    protected $timeLine;

    /**
     * The storage used to maintain the data
     * @var TimeStorage
     */
    protected $storage;

    /**
     * @var TimerStrategyInterface
     */
    protected $timerStrategy;

    /**
     * The total added extra time
     * @var float
     */
    protected $extraTime = 0.0;

    /**
     * The extended time
     * @var float
     */
    protected $extendedTime = 0.0;

    /**
     * The already consumed extra time
     * @var float
     */
    protected $consumedExtraTime = 0.0;

    /**
     * @var AdjustmentMap
     */
    protected $adjustmentMap;

    /**
     * QtiTimer constructor.
     */
    public function __construct()
    {
        $this->timeLine = new QtiTimeLine();
        $this->adjustmentMap = new AdjustmentMap();
    }

    /**
     * Adds a "server start" TimePoint at a particular timestamp for the provided ItemRef
     * @param string|array $tags
     * @param float $timestamp
     * @return Timer
     * @throws TimeException
     */
    public function start($tags, $timestamp)
    {
        // check the provided arguments
        if (!is_numeric($timestamp) || $timestamp < 0) {
            throw new InvalidDataException('start() needs a valid timestamp!');
        }

        // extract the TimePoint identification from the provided item, and find existing range
        $range = $this->getRange($tags);

        // validate the data consistence
        if ($this->isRangeOpen($range)) {
            // unclosed range found, auto closing
            // auto generate the timestamp for the missing END point, one microsecond earlier
            \common_Logger::t('Missing END TimePoint in QtiTimer, auto add an arbitrary value');
            $point = new TimePoint($tags, $timestamp - (1 / TimePoint::PRECISION), TimePoint::TYPE_END, TimePoint::TARGET_SERVER);
            $this->timeLine->add($point);
            $range[] = $point;
        }
        $this->checkTimestampCoherence($range, $timestamp);

        // append the new START TimePoint
        $point = new TimePoint($tags, $timestamp, TimePoint::TYPE_START, TimePoint::TARGET_SERVER);
        $this->timeLine->add($point);

        return $this;
    }

    /**
     * Adds a "server end" TimePoint at a particular timestamp for the provided ItemRef
     * @param string|array $tags
     * @param float $timestamp
     * @return Timer
     * @throws TimeException
     */
    public function end($tags, $timestamp)
    {
        // check the provided arguments
        if (!is_numeric($timestamp) || $timestamp < 0) {
            throw new InvalidDataException('end() needs a valid timestamp!');
        }

        // extract the TimePoint identification from the provided item, and find existing range
        $range = $this->getRange($tags);

        // validate the data consistence
        if ($this->isRangeOpen($range)) {
            $this->checkTimestampCoherence($range, $timestamp);

            // append the new END TimePoint
            $point = new TimePoint($tags, $timestamp, TimePoint::TYPE_END, TimePoint::TARGET_SERVER);
            $this->timeLine->add($point);
        } else {
            // already closed range found, just log the info
            \common_Logger::t('Range already closed, or missing START TimePoint in QtiTimer, continue anyway');
        }

        return $this;
    }

    /**
     * Gets the first timestamp of the range for the provided tags
     * @param string|array $tags
     * @return float $timestamp
     */
    public function getFirstTimestamp($tags)
    {
        // extract the TimePoint identification from the provided item, and find existing range
        $range = $this->getRange($tags);
        $last = false;

        if (count($range)) {
            $last = $range[0]->getTimestamp();
        }

        return $last;
    }

    /**
     * Gets the last timestamp of the range for the provided tags
     * @param string|array $tags
     * @return bool|float $timestamp Returns the last timestamp of the range or false if none
     */
    public function getLastTimestamp($tags)
    {
        // extract the TimePoint identification from the provided item, and find existing range
        $range = $this->getRange($tags);
        $length = count($range);
        $last = false;

        if ($length) {
            $last = $range[$length - 1]->getTimestamp();
        }

        return $last;
    }

    /**
     * Gets the last registered timestamp
     * @return bool|float $timestamp Returns the last timestamp or false if none
     */
    public function getLastRegisteredTimestamp()
    {
        $points = $this->timeLine->getPoints();
        $length = count($points);
        $last = false;

        if ($length) {
            $last = end($points)->getTimestamp();
        }

        return $last;
    }

    /**
     * Adds "client start" and "client end" TimePoint based on the provided duration for a particular ItemRef
     * @param string|array $tags
     * @param float $duration
     * @return Timer
     * @throws TimeException
     */
    public function adjust($tags, $duration)
    {
        // check the provided arguments
        if (!is_null($duration) && (!is_numeric($duration) || $duration < 0)) {
            throw new InvalidDataException('adjust() needs a valid duration!');
        }

        // extract the TimePoint identification from the provided item, and find existing range
        $itemTimeLine = $this->timeLine->filter($tags, TimePoint::TARGET_SERVER);
        $range = $itemTimeLine->getPoints();

        // validate the data consistence
        $rangeLength = count($range);
        if (!$rangeLength || ($rangeLength % 2)) {
            throw new InconsistentRangeException('The time range does not seem to be consistent, the range is not complete!');
        }

        $serverDuration = $itemTimeLine->compute();

        // take care of existing client range
        $clientTimeLine = $this->timeLine->filter($tags, TimePoint::TARGET_CLIENT);
        $clientRange = $clientTimeLine->getPoints();
        $clientRangeLength = count($clientRange);
        if ($clientRangeLength) {
            $clientDuration = 0;
            try {
                $clientDuration = $clientTimeLine->compute();
            } catch (TimeException $e) {
                \common_Logger::t('Handled client range error');
            }

            if (is_null($duration)) {
                if ($clientDuration) {
                    $duration = $clientDuration;
                    \common_Logger::t("No client duration provided to adjust the timer, but a range already exist: ${duration}");
                } else {
                    $duration = $serverDuration;
                    \common_Logger::t("No client duration provided to adjust the timer, fallback to server duration: ${duration}");
                }
            }

            $removed = $this->timeLine->remove($tags, TimePoint::TARGET_CLIENT);
            if ($removed == $clientRangeLength) {
                \common_Logger::t("Replace client duration in timer: ${clientDuration} to ${duration}");
            } else {
                \common_Logger::w("Unable to replace client duration in timer: ${clientDuration} to ${duration}");
            }
        }

        // check if the client side duration is bound by the server side duration
        if (is_null($duration)) {
            $duration = $serverDuration;
            \common_Logger::t("No client duration provided to adjust the timer, fallback to server duration: ${duration}");
        } elseif ($duration > $serverDuration) {
            \common_Logger::w("A client duration must not be larger than the server time range! (${duration} > ${serverDuration})");
            $duration = $serverDuration;
        }

        // extract range boundaries
        TimePoint::sort($range);
        $serverStart = $range[0];
        $serverEnd = $range[$rangeLength - 1];

        // adjust the range by inserting the client duration between the server overall time range boundaries
        $overallDuration = $serverEnd->getTimestamp() - $serverStart->getTimestamp();
        $delay = ($overallDuration - $duration) / 2;

        $start = new TimePoint($tags, $serverStart->getTimestamp() + $delay, TimePoint::TYPE_START, TimePoint::TARGET_CLIENT);
        $this->timeLine->add($start);

        $end = new TimePoint($tags, $serverEnd->getTimestamp() - $delay, TimePoint::TYPE_END, TimePoint::TARGET_CLIENT);
        $this->timeLine->add($end);

        return $this;
    }

    /**
     * Computes the total duration represented by the filtered TimePoints
     * @param string|array $tags A tag or a list of tags to filter
     * @param int $target The type of target TimePoint to filter
     * @return float Returns the total computed duration
     * @throws TimeException
     */
    public function compute($tags, $target)
    {
        // cannot compute a duration across different targets
        if (!$this->onlyOneFlag($target)) {
            throw new InconsistentCriteriaException('Cannot compute a duration across different targets!');
        }

        return $this->timeLine->compute($tags, $target);
    }

    /**
     * Checks if the duration of a TimeLine subset reached the timeout
     * @param float $timeLimit The time limit against which compare the duration
     * @param string|array $tags A tag or a list of tags to filter
     * @param int $target The type of target TimePoint to filter
     * @return bool Returns true if the timeout is reached
     * @throws TimeException
     */
    public function timeout($timeLimit, $tags, $target)
    {
        $duration = $this->compute($tags, $target);
        return $duration >= $timeLimit;
    }

    /**
     * Sets the storage used to maintain the data
     * @param TimeStorage $storage
     * @return Timer
     */
    public function setStorage(TimeStorage $storage)
    {
        $this->storage = $storage;
        return $this;
    }

    /**
     * @inheritDoc
     */
    public function setStrategy(TimerStrategyInterface $strategy)
    {
        $this->timerStrategy = $strategy;
        return $this;
    }

    /**
     * Gets the storage used to maintain the data
     * @return TimeStorage
     */
    public function getStorage()
    {
        return $this->storage;
    }

    /**
     * Exports the internal state to an array
     * @return array
     */
    public function toArray()
    {
        return [
            QtiTimeStorageFormat::STORAGE_KEY_TIME_LINE => $this->timeLine,
            QtiTimeStorageFormat::STORAGE_KEY_EXTRA_TIME => $this->extraTime,
            QtiTimeStorageFormat::STORAGE_KEY_EXTENDED_TIME => $this->extendedTime,
            QtiTimeStorageFormat::STORAGE_KEY_CONSUMED_EXTRA_TIME => $this->consumedExtraTime,
            QtiTimeStorageFormat::STORAGE_KEY_TIMER_ADJUSTMENT_MAP => $this->adjustmentMap,
        ];
    }

    /**
     * Specify data which should be serialized to JSON
     * @link http://php.net/manual/en/jsonserializable.jsonserialize.php
     * @return mixed data which can be serialized by <b>json_encode</b>,
     * which is a value of any type other than a resource.
     * @since 5.4.0
     */
    public function jsonSerialize()
    {
        return $this->toArray();
    }

    /**
     * Saves the data to the storage
     * @return Timer
     * @throws InvalidStorageException
     */
    public function save()
    {
        if (!$this->storage) {
            throw new InvalidStorageException('A storage must be defined in order to store the data!');
        }

        $this->storage->store($this->toArray());
        return $this;
    }

    /**
     * @param mixed $data
     * @return QtiTimeLine
     */
    protected function unserializeTimeLine($data)
    {
        if (is_array($data)) {
            $timeLine = new QtiTimeLine();
            $timeLine->fromArray($data);
        } else {
            $timeLine = $data;
        }

        return $timeLine;
    }

    protected function unserializeAdjustmentMap($data)
    {
        $map = new AdjustmentMap();
        if (is_array($data)) {
            $map->fromArray($data);
        } elseif ($data instanceof TimerAdjustmentMapInterface) {
            $map = $data;
        }

        return $map;
    }

    /**
     * Loads the data from the storage
     * @return Timer
     * @throws InvalidStorageException
     * @throws InvalidDataException
     */
    public function load()
    {
        if (!$this->storage) {
            throw new InvalidStorageException('A storage must be defined in order to store the data!');
        }

        $data = $this->storage->load();

        if (isset($data)) {
            if (!is_array($data)) {
                $data = [
                    QtiTimeStorageFormat::STORAGE_KEY_TIME_LINE => $data,
                ];
            }

            if (isset($data[QtiTimeStorageFormat::STORAGE_KEY_TIME_LINE])) {
                $this->timeLine = $this->unserializeTimeLine($data[QtiTimeStorageFormat::STORAGE_KEY_TIME_LINE]);
            } else {
                $this->timeLine = new QtiTimeLine();
            }

            if (isset($data[QtiTimeStorageFormat::STORAGE_KEY_EXTRA_TIME])) {
                $this->extraTime = $data[QtiTimeStorageFormat::STORAGE_KEY_EXTRA_TIME];
            } else {
                $this->extraTime = 0;
            }

            if (isset($data[QtiTimeStorageFormat::STORAGE_KEY_EXTENDED_TIME])) {
                $this->extendedTime = $data[QtiTimeStorageFormat::STORAGE_KEY_EXTENDED_TIME];
            } else {
                $this->extendedTime = 0;
            }
            if (isset($data[QtiTimeStorageFormat::STORAGE_KEY_CONSUMED_EXTRA_TIME])) {
                $this->consumedExtraTime = $data[QtiTimeStorageFormat::STORAGE_KEY_CONSUMED_EXTRA_TIME];
            } else {
                $this->consumedExtraTime = 0;
            }

            if (isset($data[QtiTimeStorageFormat::STORAGE_KEY_TIMER_ADJUSTMENT_MAP])) {
                $this->adjustmentMap = $this->unserializeAdjustmentMap(
                    $data[QtiTimeStorageFormat::STORAGE_KEY_TIMER_ADJUSTMENT_MAP]
                );
            } else {
                $this->adjustmentMap = new AdjustmentMap();
            }

            if (!$this->timeLine instanceof TimeLine) {
                throw new InvalidDataException('The storage did not provide acceptable data when loading!');
            }

            if (!$this->timerStrategy) {
                throw new InvalidTimerStrategyException('A timer strategy must be defined!');
            }
        }

        return $this;
    }

    /**
     * Gets the added extra time
     * @return float
     */
    public function getExtraTime()
    {
        return $this->extraTime;
    }

    /**
     * @return float
     */
    public function getExtendedTime()
    {
        return $this->extendedTime;
    }

    /**
     * @param $extendedTime
     * @return $this
     */
    public function setExtendedTime($extendedTime)
    {
        $this->extendedTime = $extendedTime;
        return $this;
    }

    /**
     * Sets the added extra time
     * @param float $time
     * @return $this
     */
    public function setExtraTime($time)
    {
        $this->extraTime = max(0, floatval($time));
        return $this;
    }

    /**
     * Sets the added extra time
     * @param float $time
     * @return $this
     */
    public function setConsumedExtraTime($time)
    {
        $this->consumedExtraTime = max($this->consumedExtraTime, floatval($time));
        return $this;
    }

    /**
     * Gets the amount of already consumed extra time. If tags are provided, only take care of the related time.
     * @param string|array $tags A tag or a list of tags to filter
     * @param integer $maxTime initial (total) timer value without extra time
     * @param integer $target (server/client)
     * @return float
     * @throws
     */
    public function getConsumedExtraTime($tags = null, $maxTime = 0, $target = TimePoint::TARGET_SERVER)
    {
        if ($maxTime) {
            $totalConsumed = $this->compute($tags, $target);
            $consumedExtraTime = $totalConsumed - $maxTime < 0 ? 0 : $totalConsumed - $maxTime;
            $this->setConsumedExtraTime($consumedExtraTime)->save();
        }
        return $this->consumedExtraTime;
    }

    /**
     * Gets the amount of remaining extra time
     * @param string|array $tags A tag or a list of tags to filter
     * @param integer $maxTime initial (total) timer value without extra time
     * @param integer $target (server/client)
     * @return float
     */
    public function getRemainingExtraTime($tags = null, $maxTime = 0, $target = TimePoint::TARGET_SERVER)
    {
        return max(0, $this->getExtraTime() - $this->getConsumedExtraTime($tags, $maxTime, $target));
    }

    /**
     * @return AdjustmentMap
     */
    public function getAdjustmentMap()
    {
        return $this->adjustmentMap;
    }

    /**
     * @inheritdoc
     */
    public function delete()
    {
        $storage = $this->getStorage();
        return $storage->delete();
    }

    /**
     * Checks if a timestamp is consistent with existing TimePoint within a range
     * @param array $points
     * @param float $timestamp
     * @throws InconsistentRangeException
     */
    protected function checkTimestampCoherence($points, $timestamp)
    {
        foreach ($points as $point) {
            if ($point->getTimestamp() > $timestamp) {
                throw new InconsistentRangeException('A new TimePoint cannot be set before an existing one!');
            }
        }
    }

    /**
     * Check if the provided range is open (START TimePoint and no related END)
     * @param array $range
     * @return bool
     */
    protected function isRangeOpen($range)
    {
        $nb = count($range);
        return $nb && ($nb % 2) && ($range[$nb - 1]->getType() == TimePoint::TYPE_START);
    }

    /**
     * Extracts a sorted range of TimePoint
     *
     * @param array $tags
     * @return array
     */
    protected function getRange($tags)
    {
        $range = $this->timeLine->find($tags, TimePoint::TARGET_SERVER);

        TimePoint::sort($range);

        return $range;
    }

    /**
     * Checks if a binary flag contains exactly one flag set
     * @param $value
     * @return bool
     */
    protected function onlyOneFlag($value)
    {
        return $this->binaryPopCount($value) == 1;
    }

    /**
     * Count the number of bits set in a 32bits integer
     * @param int $value
     * @return int
     */
    protected function binaryPopCount($value)
    {
        $value -= (($value >> 1) & 0x55555555);
        $value = ((($value >> 2) & 0x33333333) + ($value & 0x33333333));
        $value = ((($value >> 4) + $value) & 0x0f0f0f0f);
        $value += ($value >> 8);
        $value += ($value >> 16);
        return $value & 0x0000003f;
    }
}