<?php

final class Application_Model_Scheduler
{
    private $con;
    private $fileInfo = [
        'id' => '',
        'cliplength' => '',
        'cuein' => '00:00:00',
        'cueout' => '00:00:00',
        'fadein' => '00:00:00',
        'fadeout' => '00:00:00',
        'sched_id' => null,
        'type' => 0, // default type of '0' to represent files. type '1' represents a webstream
    ];

    private $epochNow;
    private $nowDT;
    private $user;

    private $crossfadeDuration;
    private $applyCrossfades = true;

    private $checkUserPermissions = true;

    public function __construct($checkUserPermissions = true)
    {
        $this->con = Propel::getConnection(CcSchedulePeer::DATABASE_NAME);

        // subtracting one because sometimes when we cancel a track, we set its end time
        // to epochNow and then send the new schedule to pypo. Sometimes the currently cancelled
        // track can still be included in the new schedule because it may have a few ms left to play.
        // subtracting 1 second from epochNow resolves this issue.
        $this->epochNow = microtime(true) - 1;
        $this->nowDT = DateTime::createFromFormat('U.u', $this->epochNow, new DateTimeZone('UTC'));

        if ($this->nowDT === false) {
            // DateTime::createFromFormat does not support millisecond string formatting in PHP 5.3.2 (Ubuntu 10.04).
            // In PHP 5.3.3 (Ubuntu 10.10), this has been fixed.
            $this->nowDT = DateTime::createFromFormat('U', time(), new DateTimeZone('UTC'));
        }

        $this->setCheckUserPermissions($checkUserPermissions);

        if ($this->checkUserPermissions) {
            $this->user = Application_Model_User::getCurrentUser();
        }

        $this->crossfadeDuration = Application_Model_Preference::GetDefaultCrossfadeDuration();
    }

    public function setCheckUserPermissions($value)
    {
        $this->checkUserPermissions = $value;
    }

    private function validateItemMove($itemsToMove, $destination)
    {
        $destinationInstanceId = $destination['instance'];
        $destinationCcShowInstance = CcShowInstancesQuery::create()
            ->findPk($destinationInstanceId);
        $isDestinationLinked = $destinationCcShowInstance->getCcShow()->isLinked();

        foreach ($itemsToMove as $itemToMove) {
            $sourceInstanceId = $itemToMove['instance'];
            $ccShowInstance = CcShowInstancesQuery::create()
                ->findPk($sourceInstanceId);

            // does the item being moved belong to a linked show
            $isSourceLinked = $ccShowInstance->getCcShow()->isLinked();

            if ($isDestinationLinked && !$isSourceLinked) {
                throw new Exception('Cannot move items into linked shows');
            }
            if (!$isDestinationLinked && $isSourceLinked) {
                throw new Exception('Cannot move items out of linked shows');
            }
            if ($isSourceLinked && $sourceInstanceId != $destinationInstanceId) {
                throw new Exception(_('Cannot move items out of linked shows'));
            }
        }
    }

    /*
     * make sure any incoming requests for scheduling are legit.
    *
    * @param array $items, an array containing pks of cc_schedule items.
    */
    private function validateRequest($items, $addRemoveAction = false, $cancelShow = false)
    {
        // $items is where tracks get inserted (they are schedule locations)

        $nowEpoch = floatval($this->nowDT->format('U.u'));

        $schedInfo = [];
        $instanceInfo = [];

        for ($i = 0; $i < count($items); ++$i) {
            $id = $items[$i]['id'];

            // could be added to the beginning of a show, which sends id = 0;
            if ($id > 0) {
                // schedule_id of where we are inserting after?
                $schedInfo[$id] = $items[$i]['instance'];
            }

            // format is instance_id => timestamp
            $instanceInfo[$items[$i]['instance']] = $items[$i]['timestamp'];
        }

        if (count($instanceInfo) === 0) {
            throw new Exception('Invalid Request.');
        }

        $schedIds = [];
        if (count($schedInfo) > 0) {
            $schedIds = array_keys($schedInfo);
        }
        $schedItems = CcScheduleQuery::create()->findPKs($schedIds, $this->con);
        $instanceIds = array_keys($instanceInfo);
        $showInstances = CcShowInstancesQuery::create()->findPKs($instanceIds, $this->con);

        // an item has been deleted
        if (count($schedIds) !== count($schedItems)) {
            throw new OutDatedScheduleException(_("The schedule you're viewing is out of date! (sched mismatch)"));
        }

        // a show has been deleted
        if (count($instanceIds) !== count($showInstances)) {
            throw new OutDatedScheduleException(_("The schedule you're viewing is out of date! (instance mismatch)"));
        }

        foreach ($schedItems as $schedItem) {
            $id = $schedItem->getDbId();
            $instance = $schedItem->getCcShowInstances($this->con);

            if (intval($schedInfo[$id]) !== $instance->getDbId()) {
                throw new OutDatedScheduleException(_("The schedule you're viewing is out of date!"));
            }
        }

        foreach ($showInstances as $instance) {
            $id = $instance->getDbId();
            $show = $instance->getCcShow($this->con);

            if ($this->checkUserPermissions && $this->user->canSchedule($show->getDbId()) === false) {
                throw new Exception(sprintf(_('You are not allowed to schedule show %s.'), $show->getDbName()));
            }

            if ($instance->getDbRecord()) {
                throw new Exception(_('You cannot add files to recording shows.'));
            }

            $showEndEpoch = floatval($instance->getDbEnds('U.u'));

            if ($showEndEpoch < $nowEpoch) {
                throw new OutDatedScheduleException(sprintf(_('The show %s is over and cannot be scheduled.'), $show->getDbName()));
            }

            $ts = intval($instanceInfo[$id]);
            $lastSchedTs = intval($instance->getDbLastScheduled('U')) ?: 0;
            if ($ts < $lastSchedTs) {
                Logging::info("ts {$ts} last sched {$lastSchedTs}");

                throw new OutDatedScheduleException(sprintf(_('The show %s has been previously updated!'), $show->getDbName()));
            }

            /*
             * Does the afterItem belong to a show that is linked AND
             * currently playing?
             * If yes, throw an exception
             * unless it is a cancel show action then we don't check because otherwise
             * ongoing linked shows can't be cancelled
             */
            if ($addRemoveAction && !$cancelShow) {
                $ccShow = $instance->getCcShow();
                if ($ccShow->isLinked()) {
                    // get all the linked shows instances and check if
                    // any of them are currently playing
                    $ccShowInstances = $ccShow->getCcShowInstancess();
                    $timeNowUTC = gmdate(DEFAULT_TIMESTAMP_FORMAT);
                    foreach ($ccShowInstances as $ccShowInstance) {
                        if (
                            $ccShowInstance->getDbStarts() <= $timeNowUTC
                            && $ccShowInstance->getDbEnds() > $timeNowUTC
                        ) {
                            throw new Exception(_('Content in linked shows cannot be changed while on air!'));
                        }
                    }
                }
            }
        }
    }

    private function validateMediaItems($mediaItems)
    {
        foreach ($mediaItems as $mediaItem) {
            $id = $mediaItem['id'];
            if ($mediaItem['type'] === 'playlist') {
                $playlist = new Application_Model_Playlist($id, $this->con);
                if ($playlist->containsMissingFiles()) {
                    throw new Exception(_('Cannot schedule a playlist that contains missing files.'));
                }
            }
        }

        return true;
    }

    /*
     * @param $id
     * @param $type
     * @param $show
     *
     * @return $files
     */
    private function retrieveMediaFiles($id, $type, $show)
    {
        // if there is a show we need to set a show limit to pass to smart blocks in case they use time remaining
        $showInstance = new Application_Model_ShowInstance($show);
        $showLimit = $showInstance->getSecondsRemaining();
        $originalShowLimit = $showLimit;

        $files = [];
        if ($type === 'audioclip') {
            $file = CcFilesQuery::create()->findPK($id, $this->con);

            if (is_null($file) || !$file->visible()) {
                throw new Exception(_('A selected File does not exist!'));
            }
            $data = $this->fileInfo;
            $data['id'] = $id;

            $cuein = Application_Common_DateHelper::playlistTimeToSeconds($file->getDbCuein());
            $cueout = Application_Common_DateHelper::playlistTimeToSeconds($file->getDbCueout());
            $row_length = Application_Common_DateHelper::secondsToPlaylistTime($cueout - $cuein);

            $data['cliplength'] = $row_length;

            $data['cuein'] = $file->getDbCuein();
            $data['cueout'] = $file->getDbCueout();

            // fade is in format SS.uuuuuu
            $data['fadein'] = Application_Model_Preference::GetDefaultFadeIn();
            $data['fadeout'] = Application_Model_Preference::GetDefaultFadeOut();

            $files[] = $data;
        } elseif ($type === 'playlist') {
            $pl = new Application_Model_Playlist($id);
            $contents = $pl->getContents();
            // because the time remaining is not updated until after the schedule inserts we need to track it for
            // the entire add vs. querying on the smartblock level
            foreach ($contents as $plItem) {
                if ($plItem['type'] == 0) {
                    $data['id'] = $plItem['item_id'];
                    $data['cliplength'] = $plItem['length'];
                    $data['cuein'] = $plItem['cuein'];
                    $data['cueout'] = $plItem['cueout'];
                    $data['fadein'] = $plItem['fadein'];
                    $data['fadeout'] = $plItem['fadeout'];
                    $data['type'] = 0;
                    $files[] = $data;
                } elseif ($plItem['type'] == 1) {
                    $data['id'] = $plItem['item_id'];
                    $data['cliplength'] = $plItem['length'];
                    $data['cuein'] = $plItem['cuein'];
                    $data['cueout'] = $plItem['cueout'];
                    $data['fadein'] = '00.500000'; // $plItem['fadein'];
                    $data['fadeout'] = '00.500000'; // $plItem['fadeout'];
                    $data['type'] = 1;
                    $files[] = $data;
                } elseif ($plItem['type'] == 2) {
                    // if it's a block
                    $bl = new Application_Model_Block($plItem['item_id']);
                    if ($bl->isStatic()) {
                        foreach ($bl->getContents() as $track) {
                            $data['id'] = $track['item_id'];
                            $data['cliplength'] = $track['length'];
                            $data['cuein'] = $track['cuein'];
                            $data['cueout'] = $track['cueout'];
                            $data['fadein'] = $track['fadein'];
                            $data['fadeout'] = $track['fadeout'];
                            $data['type'] = 0;
                            $files[] = $data;
                        }
                    } else {
                        $defaultFadeIn = Application_Model_Preference::GetDefaultFadeIn();
                        $defaultFadeOut = Application_Model_Preference::GetDefaultFadeOut();
                        $dynamicFiles = $bl->getListOfFilesUnderLimit($showLimit);
                        foreach ($dynamicFiles as $f) {
                            $fileId = $f['id'];
                            $file = CcFilesQuery::create()->findPk($fileId);
                            if (isset($file) && $file->visible()) {
                                $data['id'] = $file->getDbId();
                                $data['cuein'] = $file->getDbCuein();
                                $data['cueout'] = $file->getDbCueout();

                                $cuein = Application_Common_DateHelper::calculateLengthInSeconds($data['cuein']);
                                $cueout = Application_Common_DateHelper::calculateLengthInSeconds($data['cueout']);
                                $data['cliplength'] = Application_Common_DateHelper::secondsToPlaylistTime($cueout - $cuein);

                                // fade is in format SS.uuuuuu
                                $data['fadein'] = $defaultFadeIn;
                                $data['fadeout'] = $defaultFadeOut;

                                $data['type'] = 0;
                                $files[] = $data;
                            }
                        }
                    }
                }
                // if this is a playlist it might contain multiple time remaining smart blocks
                // since the schedule isn't updated until after this insert we need to keep tally
                $showLimit = $originalShowLimit - $this->timeLengthOfFiles($files);
            }
        } elseif ($type == 'stream') {
            // need to return
            $stream = CcWebstreamQuery::create()->findPK($id, $this->con);

            if (is_null($stream) /* || !$file->visible() */) {
                throw new Exception(_('A selected File does not exist!'));
            }
            $data = $this->fileInfo;
            $data['id'] = $id;
            $data['cliplength'] = $stream->getDbLength();
            $data['cueout'] = $stream->getDbLength();
            $data['type'] = 1;

            // fade is in format SS.uuuuuu
            $data['fadein'] = Application_Model_Preference::GetDefaultFadeIn();
            $data['fadeout'] = Application_Model_Preference::GetDefaultFadeOut();

            $files[] = $data;
        } elseif ($type == 'block') {
            $bl = new Application_Model_Block($id);
            if ($bl->isStatic()) {
                foreach ($bl->getContents() as $track) {
                    $data['id'] = $track['item_id'];
                    $data['cliplength'] = $track['length'];
                    $data['cuein'] = $track['cuein'];
                    $data['cueout'] = $track['cueout'];
                    $data['fadein'] = $track['fadein'];
                    $data['fadeout'] = $track['fadeout'];
                    $data['type'] = 0;
                    $files[] = $data;
                }
            } else {
                $defaultFadeIn = Application_Model_Preference::GetDefaultFadeIn();
                $defaultFadeOut = Application_Model_Preference::GetDefaultFadeOut();
                $dynamicFiles = $bl->getListOfFilesUnderLimit($showLimit);
                foreach ($dynamicFiles as $f) {
                    $fileId = $f['id'];
                    $file = CcFilesQuery::create()->findPk($fileId);
                    if (isset($file) && $file->visible()) {
                        $data['id'] = $file->getDbId();
                        $data['cuein'] = $file->getDbCuein();
                        $data['cueout'] = $file->getDbCueout();

                        $cuein = Application_Common_DateHelper::calculateLengthInSeconds($data['cuein']);
                        $cueout = Application_Common_DateHelper::calculateLengthInSeconds($data['cueout']);
                        $data['cliplength'] = Application_Common_DateHelper::secondsToPlaylistTime($cueout - $cuein);

                        // fade is in format SS.uuuuuu
                        $data['fadein'] = $defaultFadeIn;
                        $data['fadeout'] = $defaultFadeOut;

                        $data['type'] = 0;
                        $files[] = $data;
                    }
                }
            }
        }

        return $files;
    }

    /*
     * @param DateTime startDT in UTC
    *  @param string duration
    *      in format H:i:s.u (could be more that 24 hours)
    *
    * @return DateTime endDT in UTC
    */
    private function findTimeDifference($p_startDT, $p_seconds)
    {
        $startEpoch = $p_startDT->format('U.u');

        // add two float numbers to 6 subsecond precision
        // DateTime::createFromFormat("U.u") will have a problem if there is no decimal in the resulting number.
        $newEpoch = bcsub($startEpoch, (string) $p_seconds, 6);

        $dt = DateTime::createFromFormat('U.u', $newEpoch, new DateTimeZone('UTC'));

        if ($dt === false) {
            // PHP 5.3.2 problem
            $dt = DateTime::createFromFormat('U', intval($newEpoch), new DateTimeZone('UTC'));
        }

        return $dt;
    }

    private function findTimeDifference2($p_startDT, $p_endDT)
    {
        $startEpoch = $p_startDT->format('U.u');
        $endEpoch = $p_endDT->format('U.u');

        // add two float numbers to 6 subsecond precision
        // DateTime::createFromFormat("U.u") will have a problem if there is no decimal in the resulting number.
        $newEpoch = bcsub($endEpoch, (string) $startEpoch, 6);

        $dt = DateTime::createFromFormat('U.u', $newEpoch, new DateTimeZone('UTC'));

        if ($dt === false) {
            // PHP 5.3.2 problem
            $dt = DateTime::createFromFormat('U', intval($newEpoch), new DateTimeZone('UTC'));
        }

        return $dt;
    }

    /*
     * @param DateTime startDT in UTC
     * @param string duration
     *      in format H:i:s.u (could be more that 24 hours)
     *
     * @return DateTime endDT in UTC
     */
    private function findEndTime($p_startDT, $p_duration)
    {
        $startEpoch = $p_startDT->format('U.u');
        $durationSeconds = Application_Common_DateHelper::playlistTimeToSeconds($p_duration);

        // add two float numbers to 6 subsecond precision
        // DateTime::createFromFormat("U.u") will have a problem if there is no decimal in the resulting number.
        $endEpoch = bcadd($startEpoch, (string) $durationSeconds, 6);

        $dt = DateTime::createFromFormat('U.u', $endEpoch, new DateTimeZone('UTC'));

        if ($dt === false) {
            // PHP 5.3.2 problem
            $dt = DateTime::createFromFormat('U', intval($endEpoch), new DateTimeZone('UTC'));
        }

        return $dt;
    }

    private function findNextStartTime($DT, $instanceId)
    {
        // TODO: there is at least one case where this function creates a filler block with
        //       an incorrect length; should keep an eye on it
        $sEpoch = $DT->format('U.u');
        $nEpoch = $this->epochNow;

        // check for if the show has started.
        if (bccomp($nEpoch, $sEpoch, 6) === 1) {
            $this->applyCrossfades = false;
            // need some kind of placeholder for cc_schedule.
            // playout_status will be -1.
            $nextDT = $this->nowDT;

            $length = bcsub($nEpoch, $sEpoch, 6);
            $cliplength = Application_Common_DateHelper::secondsToPlaylistTime($length);

            // fillers are for only storing a chunk of time space that has already passed.
            $filler = new CcSchedule();
            $filler->setDbStarts($DT)
                ->setDbEnds($this->nowDT)
                ->setDbClipLength($cliplength)
                ->setDbCueIn('00:00:00')
                ->setDbCueOut('00:00:00')
                ->setDbPlayoutStatus(-1)
                ->setDbInstanceId($instanceId)
                ->save($this->con);
        } else {
            $nextDT = $DT;
        }

        return $nextDT;
    }

    /*
     * @param int $showInstance
     *   This function recalculates the start/end times of items in a gapless show to
     *   account for crossfade durations.
     */
    private function calculateCrossfades($instanceId)
    {
        Logging::info('adjusting start, end times of scheduled items to account for crossfades show instance #' . $instanceId);
        $instance = CcShowInstancesQuery::create()->findPk($instanceId);

        if (is_null($instance)) {
            throw new OutDatedScheduleException(_("The schedule you're viewing is out of date!"));
        }

        $schedule = CcScheduleQuery::create()
            ->filterByDbInstanceId($instanceId)
            ->orderByDbStarts()
            ->find($this->con);

        $now = new DateTime('now', new DateTimeZone('UTC'));
        $itemStartDT = $instance->getDbStarts(null);
        foreach ($schedule as $item) {
            $itemEndDT = $this->findEndTime($itemStartDT, $item->getDbClipLength());
            // If the track has already ended, don't change it.
            if ($itemEndDT < $now) {
                $itemStartDT = $itemEndDT;

                continue;
            }
            $item->setDbStarts($itemStartDT)
                ->setDbEnds($itemEndDT)
                ->save($this->con);
            $itemStartDT = $this->findTimeDifference($itemEndDT, $this->crossfadeDuration);
        }
    }

    /*
     * @param int $showInstance
     * @param array $exclude
     *   ids of sched items to remove from the calculation.
     *   This function squeezes all items of a show together so that
     *   there are no gaps between them.
     */
    public function removeGaps($showInstance, $exclude = null)
    {
        Logging::info('removing gaps from show instance #' . $showInstance);

        $instance = CcShowInstancesQuery::create()->findPk($showInstance, $this->con);
        if (is_null($instance)) {
            throw new OutDatedScheduleException(_("The schedule you're viewing is out of date!"));
        }

        $schedule = CcScheduleQuery::create()
            ->filterByDbInstanceId($showInstance)
            ->filterByDbId($exclude, Criteria::NOT_IN)
            ->orderByDbStarts()
            ->find($this->con);

        $now = new DateTime('now', new DateTimeZone('UTC'));
        $itemStartDT = $instance->getDbStarts(null);
        foreach ($schedule as $item) {
            $itemEndDT = $this->findEndTime($itemStartDT, $item->getDbClipLength());
            // If the track has already ended, don't change it.
            if ($itemEndDT < $now) {
                $itemStartDT = $itemEndDT;

                continue;
            }

            $item->setDbStarts($itemStartDT)
                ->setDbEnds($itemEndDT);

            $itemStartDT = $itemEndDT;
        }

        $schedule->save($this->con);
    }

    /** Temporary hack to copy the track cue in, out, and length from the cc_files table to fix
     *  incorrect track lengths (RKTN-260).
     *
     * @param mixed      $showInstance
     * @param null|mixed $exclude
     */
    public function removeGaps2($showInstance, $exclude = null)
    {
        $instance = CcShowInstancesQuery::create()->findPK($showInstance, $this->con);
        if (is_null($instance)) {
            throw new OutDatedScheduleException(_("The schedule you're viewing is out of date!"));
        }

        $itemStartDT = $instance->getDbStarts(null);

        $schedule = CcScheduleQuery::create()
            ->filterByDbInstanceId($showInstance)
            ->filterByDbId($exclude, Criteria::NOT_IN)
            ->orderByDbStarts()
            ->find($this->con);

        foreach ($schedule as $item) {
            // START OF TIME RECALC HACK

            // TODO: Copy the cue in, cue out, and track length from the cc_files table
            $file = $item->getCcFiles($this->con);
            if (!$file) {
                continue;
            }
            $item->setDbCueIn($file->getDbCueIn());
            $item->setDbCueOut($file->getDbCueOut());

            $cueOut = new DateTime($file->getDbCueOut());
            $cueIn = new DateTime($file->getDbCueIn());
            $clipLength = $this->findTimeDifference2($cueIn, $cueOut);

            // The clip length is supposed to be cue out - cue in:
            // FIXME: How do we correctly do time arithmetic in PHP without losing the millseconds?
            $item->setDbClipLength($clipLength->format(DEFAULT_INTERVAL_FORMAT));
            $item->save($this->con);
            // Ensure we don't get cached results
            CcSchedulePeer::clearInstancePool();
            // END OF TIME RECALC HACK

            $itemEndDT = $this->findEndTime($itemStartDT, $item->getDbClipLength());
            $item->setDbStarts($itemStartDT)
                ->setDbEnds($itemEndDT)
                ->save($this->con);
            $itemStartDT = $this->findTimeDifference($itemEndDT, $this->crossfadeDuration);
        }

        $instance->updateDbTimeFilled($this->con); // FIXME: TIME RECALC HACK (Albert)

        $schedule->save($this->con);
    }

    /**
     * Enter description here ...
     *
     * @param       $scheduleItems cc_schedule items, where the items get inserted after
     * @param       $filesToInsert array of schedule item info, what gets inserted into cc_schedule
     * @param mixed $mediaItems
     * @param mixed $moveAction
     * @param mixed $adjustSched
     */
    private function insertAfter($scheduleItems, $mediaItems, $filesToInsert = null, $adjustSched = true, $moveAction = false)
    {
        try {
            // temporary fix for CC-5665
            set_time_limit(180);

            $affectedShowInstances = [];

            // dont want to recalculate times for moved items
            // only moved items have a sched_id
            $excludeIds = [];

            $startProfile = microtime(true);

            $temp = [];
            $instance = null;

            /* Items in shows are ordered by position number. We need to know
             * the position when adding/moving items in linked shows so they are
             * added or moved in the correct position
             */
            $pos = 0;

            $linked = false;

            foreach ($scheduleItems as $schedule) {
                // reset
                $this->applyCrossfades = true;

                $id = intval($schedule['id']);

                /* Find out if the show where the cursor position (where an item will
                 * be inserted) is located is linked or not. If the show is linked,
                 * we need to make sure there isn't another cursor selection in one of it's
                 * linked shows. If there is that will cause a duplication, in the least,
                 * of inserted items
                 */
                if ($id != 0) {
                    $schedule_sql = 'SELECT * FROM cc_schedule WHERE id = ' . $id;
                    $ccSchedule = Application_Common_Database::prepareAndExecute(
                        $schedule_sql,
                        [],
                        Application_Common_Database::SINGLE
                    );

                    $show_sql = 'SELECT * FROM cc_show WHERE id IN (' .
                        'SELECT show_id FROM cc_show_instances WHERE id = ' . $ccSchedule['instance_id'] . ')';
                    $ccShow = Application_Common_Database::prepareAndExecute(
                        $show_sql,
                        [],
                        Application_Common_Database::SINGLE
                    );

                    $linked = $ccShow['linked'];
                    if ($linked) {
                        $unique = $ccShow['id'] . $ccSchedule['position'];
                        if (!in_array($unique, $temp)) {
                            $temp[] = $unique;
                        } else {
                            continue;
                        }
                    }
                } else {
                    $show_sql = 'SELECT * FROM cc_show WHERE id IN (' .
                        'SELECT show_id FROM cc_show_instances WHERE id = ' . $schedule['instance'] . ')';
                    $ccShow = Application_Common_Database::prepareAndExecute(
                        $show_sql,
                        [],
                        Application_Common_Database::SINGLE
                    );

                    $linked = $ccShow['linked'];
                    if ($linked) {
                        $unique = $ccShow['id'] . 'a';
                        if (!in_array($unique, $temp)) {
                            $temp[] = $unique;
                        } else {
                            continue;
                        }
                    }
                }

                /* If the show where the cursor position is located is linked
                 * we need to insert the items for each linked instance belonging
                 * to that show
                 */
                if ($linked) {
                    $instances = CcShowInstancesQuery::create()
                        ->filterByDbShowId($ccShow['id'])
                        ->filterByDbStarts(gmdate(DEFAULT_TIMESTAMP_FORMAT), Criteria::GREATER_THAN)
                        ->find();
                } else {
                    $instances = CcShowInstancesQuery::create()
                        ->filterByDbId($schedule['instance'])
                        ->find();
                }

                $excludePositions = [];
                foreach ($instances as &$instance) {
                    // reset
                    $this->applyCrossfades = true;

                    // $instanceId = $instance["id"];
                    $instanceId = $instance->getDbId();
                    if ($id !== 0) {
                        /* We use the selected cursor's position to find the same
                         * positions in every other linked instance
                         */
                        $pos = $ccSchedule['position'];

                        $linkedItem_sql = 'SELECT ends FROM cc_schedule ' .
                            "WHERE instance_id = {$instanceId} " .
                            "AND position = {$pos} " .
                            'AND playout_status != -1';
                        $linkedItemEnds = Application_Common_Database::prepareAndExecute(
                            $linkedItem_sql,
                            [],
                            Application_Common_Database::COLUMN
                        );

                        if (!$linkedItemEnds) {
                            // With dynamic smart blocks there may be different number of items in
                            // each show. In case the position does not exist we need to select
                            // the end time of the last position
                            $maxPos_sql = 'SELECT max(position) from cc_schedule ' .
                                "WHERE instance_id = {$instanceId}";
                            $pos = Application_Common_Database::prepareAndExecute(
                                $maxPos_sql,
                                [],
                                Application_Common_Database::COLUMN
                            );

                            // show instance has no scheduled tracks
                            if (empty($pos)) {
                                $pos = 0;
                                $nextStartDT = new DateTime($instance->getDbStarts(), new DateTimeZone('UTC'));
                            } else {
                                $linkedItem_sql = 'SELECT ends FROM cc_schedule ' .
                                    "WHERE instance_id = {$instanceId} " .
                                    "AND position = {$pos} " .
                                    'AND playout_status != -1';
                                $linkedItemEnds = Application_Common_Database::prepareAndExecute(
                                    $linkedItem_sql,
                                    [],
                                    Application_Common_Database::COLUMN
                                );

                                $nextStartDT = $this->findNextStartTime(
                                    new DateTime($linkedItemEnds, new DateTimeZone('UTC')),
                                    $instanceId
                                );
                            }
                        } else {
                            $nextStartDT = $this->findNextStartTime(
                                new DateTime($linkedItemEnds, new DateTimeZone('UTC')),
                                $instanceId
                            );

                            ++$pos;
                        }
                    }
                    // selected empty row to add after
                    else {
                        $showStartDT = new DateTime($instance->getDbStarts(), new DateTimeZone('UTC'));
                        $nextStartDT = $this->findNextStartTime($showStartDT, $instanceId);

                        // first item in show so start position counter at 0
                        $pos = 0;

                        /* Show is empty so we don't need to calculate crossfades
                         * for the first inserted item
                         */
                        $this->applyCrossfades = false;
                    }

                    if (!in_array($instanceId, $affectedShowInstances)) {
                        $affectedShowInstances[] = $instanceId;
                    }

                    /*
                     * $adjustSched is true if there are schedule items
                     * following the item just inserted, per show instance
                     */
                    if ($adjustSched === true) {
                        $pstart = microtime(true);

                        if ($this->applyCrossfades) {
                            $initalStartDT = clone $this->findTimeDifference(
                                $nextStartDT,
                                $this->crossfadeDuration
                            );
                        } else {
                            $initalStartDT = clone $nextStartDT;
                        }

                        $pend = microtime(true);
                        Logging::debug('finding all following items.');
                        Logging::debug(floatval($pend) - floatval($pstart));
                    }

                    // passing $schedule["instance"] so that the instance being scheduled
                    // can be used to determine the remaining time
                    // in the case of a fill remaining time smart block
                    if (is_null($filesToInsert)) {
                        $filesToInsert = [];
                        foreach ($mediaItems as $media) {
                            $filesToInsert = array_merge(
                                $filesToInsert,
                                $this->retrieveMediaFiles($media['id'], $media['type'], $schedule['instance'])
                            );
                        }
                    }

                    $doInsert = false;
                    $doUpdate = false;
                    $values = [];

                    // array that stores the cc_file ids so we can update the is_scheduled flag
                    $fileIds = [];

                    foreach ($filesToInsert as &$file) {
                        // item existed previously and is being moved.
                        // need to keep same id for resources if we want REST.
                        if (isset($file['sched_id'])) {
                            $adjustFromDT = clone $nextStartDT;
                            $doUpdate = true;

                            $movedItem_sql = 'SELECT * FROM cc_schedule ' .
                                'WHERE id = ' . $file['sched_id'];
                            $sched = Application_Common_Database::prepareAndExecute(
                                $movedItem_sql,
                                [],
                                Application_Common_Database::SINGLE
                            );

                            /* We need to keep a record of the original positon a track
                             * is being moved from so we can use it to retrieve the correct
                             * items in linked instances
                             */
                            if (!isset($originalPosition)) {
                                $originalPosition = $sched['position'];
                            }

                            /* If we are moving an item in a linked show we need to get
                             * the relative item to move in each instance. We know what the
                             * relative item is by its position
                             */
                            if ($linked) {
                                $movedItem_sql = 'SELECT * FROM cc_schedule ' .
                                    "WHERE position = {$originalPosition} " .
                                    "AND instance_id = {$instanceId}";

                                $sched = Application_Common_Database::prepareAndExecute(
                                    $movedItem_sql,
                                    [],
                                    Application_Common_Database::SINGLE
                                );
                            }
                            /* If we don't find a schedule item it means the linked
                             * shows have a different amount of items (dyanmic block)
                             * and we should skip the item move for this show instance
                             */
                            if (!$sched) {
                                continue;
                            }
                            $excludeIds[] = intval($sched['id']);

                            $file['cliplength'] = $sched['clip_length'];
                            $file['cuein'] = $sched['cue_in'];
                            $file['cueout'] = $sched['cue_out'];
                            $file['fadein'] = $sched['fade_in'];
                            $file['fadeout'] = $sched['fade_out'];
                        } else {
                            $doInsert = true;
                        }

                        // default fades are in seconds
                        // we need to convert to '00:00:00' format
                        // added a check to only run the conversion if they are in seconds format
                        // otherwise php > 7.1 throws errors
                        if (is_numeric($file['fadein'])) {
                            $file['fadein'] = Application_Common_DateHelper::secondsToPlaylistTime($file['fadein']);
                        }
                        if (is_numeric($file['fadeout'])) {
                            $file['fadeout'] = Application_Common_DateHelper::secondsToPlaylistTime($file['fadeout']);
                        }

                        switch ($file['type']) {
                            case 0:
                                $fileId = $file['id'];
                                $streamId = 'null';
                                $fileIds[] = $fileId;

                                break;

                            case 1:
                                $streamId = $file['id'];
                                $fileId = 'null';

                                break;

                            default:
                                break;
                        }

                        if ($this->applyCrossfades) {
                            $nextStartDT = $this->findTimeDifference(
                                $nextStartDT,
                                $this->crossfadeDuration
                            );
                            $endTimeDT = $this->findEndTime($nextStartDT, $file['cliplength']);
                            $endTimeDT = $this->findTimeDifference($endTimeDT, $this->crossfadeDuration);
                            /* Set it to false because the rest of the crossfades
                             * will be applied after we insert each item
                             */
                            $this->applyCrossfades = false;
                        }

                        $endTimeDT = $this->findEndTime($nextStartDT, $file['cliplength']);
                        if ($doInsert) {
                            $values[] = '(' .
                                "'{$nextStartDT->format(DEFAULT_MICROTIME_FORMAT)}', " .
                                "'{$endTimeDT->format(DEFAULT_MICROTIME_FORMAT)}', " .
                                "'{$file['cuein']}', " .
                                "'{$file['cueout']}', " .
                                "'{$file['fadein']}', " .
                                "'{$file['fadeout']}', " .
                                "'{$file['cliplength']}', " .
                                "{$pos}, " .
                                "{$instanceId}, " .
                                "{$fileId}, " .
                                "{$streamId})";
                        } elseif ($doUpdate) {
                            $update_sql = 'UPDATE cc_schedule SET ' .
                                "starts = '{$nextStartDT->format(DEFAULT_MICROTIME_FORMAT)}', " .
                                "ends = '{$endTimeDT->format(DEFAULT_MICROTIME_FORMAT)}', " .
                                "cue_in = '{$file['cuein']}', " .
                                "cue_out = '{$file['cueout']}', " .
                                "fade_in = '{$file['fadein']}', " .
                                "fade_out = '{$file['fadeout']}', " .
                                "clip_length = '{$file['cliplength']}', " .
                                "position = {$pos}, " .
                                "instance_id = {$instanceId} " .
                                "WHERE id = {$sched['id']}";

                            Application_Common_Database::prepareAndExecute(
                                $update_sql,
                                [],
                                Application_Common_Database::EXECUTE
                            );
                        }

                        $nextStartDT = $this->findTimeDifference($endTimeDT, $this->crossfadeDuration);
                        ++$pos;
                    } // all files have been inserted/moved
                    if ($doInsert) {
                        $insert_sql = 'INSERT INTO cc_schedule ' .
                            '(starts, ends, cue_in, cue_out, fade_in, fade_out, ' .
                            'clip_length, position, instance_id, file_id, stream_id) VALUES ' .
                            implode(',', $values) . ' RETURNING id';

                        $stmt = $this->con->prepare($insert_sql);
                        if ($stmt->execute()) {
                            foreach ($stmt->fetchAll() as $row) {
                                $excludeIds[] = $row['id'];
                            }
                        }
                    }

                    $selectCriteria = new Criteria();
                    $selectCriteria->add(CcFilesPeer::ID, $fileIds, Criteria::IN);
                    $selectCriteria->addAnd(CcFilesPeer::IS_SCHEDULED, false);
                    $updateCriteria = new Criteria();
                    $updateCriteria->add(CcFilesPeer::IS_SCHEDULED, true);
                    BasePeer::doUpdate($selectCriteria, $updateCriteria, $this->con);

                    /* Reset files to insert so we can get a new set of files. We have
                     * to do this in case we are inserting a dynamic block
                     */
                    if (!$moveAction) {
                        $filesToInsert = null;
                    }

                    if ($adjustSched === true) {
                        $followingItems_sql = 'SELECT * FROM cc_schedule ' .
                            "WHERE starts >= '{$initalStartDT->format(DEFAULT_MICROTIME_FORMAT)}' " .
                            "AND instance_id = {$instanceId} ";
                        if (count($excludeIds) > 0) {
                            $followingItems_sql .= 'AND id NOT IN (' . implode(',', $excludeIds) . ') ';
                        }
                        $followingItems_sql .= 'ORDER BY starts';
                        $followingSchedItems = Application_Common_Database::prepareAndExecute(
                            $followingItems_sql
                        );

                        $pstart = microtime(true);

                        // recalculate the start/end times after the inserted items.
                        foreach ($followingSchedItems as $item) {
                            $endTimeDT = $this->findEndTime($nextStartDT, $item['clip_length']);
                            $endTimeDT = $this->findTimeDifference($endTimeDT, $this->crossfadeDuration);
                            $update_sql = 'UPDATE cc_schedule SET ' .
                                "starts = '{$nextStartDT->format(DEFAULT_MICROTIME_FORMAT)}', " .
                                "ends = '{$endTimeDT->format(DEFAULT_MICROTIME_FORMAT)}', " .
                                "position = {$pos} " .
                                "WHERE id = {$item['id']}";
                            Application_Common_Database::prepareAndExecute(
                                $update_sql,
                                [],
                                Application_Common_Database::EXECUTE
                            );

                            $nextStartDT = $this->findTimeDifference($endTimeDT, $this->crossfadeDuration);
                            ++$pos;
                        }

                        $pend = microtime(true);
                        Logging::debug('adjusting all following items.');
                        Logging::debug(floatval($pend) - floatval($pstart));
                    }
                    if ($moveAction) {
                        $this->calculateCrossfades($instanceId);
                    }
                } // for each instance
            } // for each schedule location

            $endProfile = microtime(true);
            Logging::debug('finished adding scheduled items.');
            Logging::debug(floatval($endProfile) - floatval($startProfile));

            // update the status flag in cc_schedule.
            $instances = CcShowInstancesQuery::create()
                ->filterByPrimaryKeys($affectedShowInstances)
                ->find($this->con);

            $startProfile = microtime(true);

            foreach ($instances as $instance) {
                $instance->updateScheduleStatus($this->con);
            }

            $endProfile = microtime(true);
            Logging::debug('updating show instances status.');
            Logging::debug(floatval($endProfile) - floatval($startProfile));

            $startProfile = microtime(true);

            // update the last scheduled timestamp.
            CcShowInstancesQuery::create()
                ->filterByPrimaryKeys($affectedShowInstances)
                ->update(['DbLastScheduled' => new DateTime('now', new DateTimeZone('UTC'))], $this->con);

            $endProfile = microtime(true);
            Logging::debug('updating last scheduled timestamp.');
            Logging::debug(floatval($endProfile) - floatval($startProfile));
        } catch (Exception $e) {
            Logging::debug($e->getMessage());

            throw $e;
        }
    }

    private function updateMovedItem() {}

    private function getInstances($instanceId)
    {
        $ccShowInstance = CcShowInstancesQuery::create()->findPk($instanceId);
        $ccShow = $ccShowInstance->getCcShow();
        if ($ccShow->isLinked()) {
            return $ccShow->getFutureCcShowInstancess();
        }

        return [$ccShowInstance];
    }

    /*
     * @param array $scheduleItems (schedule_id and instance_id it belongs to)
     * @param array $mediaItems (file|block|playlist|webstream)
     */
    public function scheduleAfter($scheduleItems, $mediaItems, $adjustSched = true)
    {
        $this->con->beginTransaction();

        try {
            // Increase the transaction isolation level to prevent two concurrent requests from potentially resulting
            // in tracks scheduled at the same time.
            $this->con->exec('SET TRANSACTION ISOLATION LEVEL SERIALIZABLE');

            $this->validateMediaItems($mediaItems); // Check for missing files, etc.
            $this->validateRequest($scheduleItems, true);

            /*
             * create array of arrays
             * array of schedule item info
             * (sched_id is the cc_schedule id and is set if an item is being
             *  moved because it is already in cc_schedule)
             * [0] = Array(
             *     id => 1,
             *     cliplength => 00:04:32,
             *     cuein => 00:00:00,
             *     cueout => 00:04:32,
             *     fadein => 00.5,
             *     fadeout => 00.5,
             *     sched_id => ,
             *     type => 0)
             * [1] = Array(
             *     id => 2,
             *     cliplength => 00:05:07,
             *     cuein => 00:00:00,
             *     cueout => 00:05:07,
             *     fadein => 00.5,
             *     fadeout => 00.5,
             *     sched_id => ,
             *     type => 0)
             */
            $this->insertAfter($scheduleItems, $mediaItems, null, $adjustSched);

            $this->con->commit();

            Application_Model_RabbitMq::PushSchedule();
        } catch (Exception $e) {
            $this->con->rollback();

            throw $e;
        }
    }

    /*
     * @param array $selectedItem
     * @param array $afterItem
     */
    public function moveItem($selectedItems, $afterItems, $adjustSched = true)
    {
        // $startProfile = microtime(true);

        $this->con->beginTransaction();
        // $this->con->useDebug(true);

        try {
            // Increase the transaction isolation level to prevent two concurrent requests from potentially resulting
            // in tracks scheduled at the same time.
            $this->con->exec('SET TRANSACTION ISOLATION LEVEL SERIALIZABLE');

            $this->validateItemMove($selectedItems, $afterItems[0]);
            $this->validateRequest($selectedItems);
            $this->validateRequest($afterItems);

            $endProfile = microtime(true);
            // Logging::debug("validating move request took:");
            // Logging::debug(floatval($endProfile) - floatval($startProfile));

            $afterInstance = CcShowInstancesQuery::create()->findPK($afterItems[0]['instance'], $this->con);

            // map show instances to cc_schedule primary keys.
            $modifiedMap = [];
            $movedData = [];

            // prepare each of the selected items.
            for ($i = 0; $i < count($selectedItems); ++$i) {
                $selected = CcScheduleQuery::create()->findPk($selectedItems[$i]['id'], $this->con);
                $selectedInstance = $selected->getCcShowInstances($this->con);

                $data = $this->fileInfo;
                $data['id'] = $selected->getDbFileId();
                $data['cliplength'] = $selected->getDbClipLength();
                $data['cuein'] = $selected->getDbCueIn();
                $data['cueout'] = $selected->getDbCueOut();
                $data['fadein'] = $selected->getDbFadeIn();
                $data['fadeout'] = $selected->getDbFadeOut();
                $data['sched_id'] = $selected->getDbId();

                $movedData[] = $data;

                // figure out which items must be removed from calculated show times.
                $showInstanceId = $selectedInstance->getDbId();
                $schedId = $selected->getDbId();
                if (isset($modifiedMap[$showInstanceId])) {
                    array_push($modifiedMap[$showInstanceId], $schedId);
                } else {
                    $modifiedMap[$showInstanceId] = [$schedId];
                }
            }

            // calculate times excluding the to be moved items.
            foreach ($modifiedMap as $instance => $schedIds) {
                $startProfile = microtime(true);

                $this->removeGaps($instance, $schedIds);

                // $endProfile = microtime(true);
                // Logging::debug("removing gaps from instance $instance:");
                // Logging::debug(floatval($endProfile) - floatval($startProfile));
            }

            // $startProfile = microtime(true);

            $this->insertAfter($afterItems, null, $movedData, $adjustSched, true);

            // $endProfile = microtime(true);
            // Logging::debug("inserting after removing gaps.");
            // Logging::debug(floatval($endProfile) - floatval($startProfile));

            $modified = array_keys($modifiedMap);
            // need to adjust shows we have moved items from.
            foreach ($modified as $instanceId) {
                $instance = CcShowInstancesQuery::create()->findPK($instanceId, $this->con);
                $instance->updateScheduleStatus($this->con);
            }

            // $this->con->useDebug(false);
            $this->con->commit();

            Application_Model_RabbitMq::PushSchedule();
        } catch (Exception $e) {
            $this->con->rollback();

            throw $e;
        }
    }

    public function removeItems($scheduledItems, $adjustSched = true, $cancelShow = false)
    {
        $showInstances = [];
        $this->con->beginTransaction();

        try {
            $this->validateRequest($scheduledItems, true, true);

            $scheduledIds = [];
            foreach ($scheduledItems as $item) {
                $scheduledIds[] = $item['id'];
            }

            $removedItems = CcScheduleQuery::create()->findPks($scheduledIds);

            // This array is used to keep track of every show instance that was
            // effected by the track deletion. It will be used later on to
            // remove gaps in the schedule and adjust crossfade times.
            $effectedInstanceIds = [];

            foreach ($removedItems as $removedItem) {
                $instance = $removedItem->getCcShowInstances($this->con);
                $effectedInstanceIds[$instance->getDbId()] = $instance->getDbId();

                // check if instance is linked and if so get the schedule items
                // for all linked instances so we can delete them too
                if (!$cancelShow && $instance->getCcShow()->isLinked()) {
                    // returns all linked instances if linked
                    $ccShowInstances = $this->getInstances($instance->getDbId());

                    $instanceIds = [];
                    foreach ($ccShowInstances as $ccShowInstance) {
                        $instanceIds[] = $ccShowInstance->getDbId();
                    }
                    $effectedInstanceIds = array_merge($effectedInstanceIds, $instanceIds);

                    // Delete the same track, represented by $removedItem, in
                    // each linked show instance.
                    $itemsToDelete = CcScheduleQuery::create()
                        ->filterByDbPosition($removedItem->getDbPosition())
                        ->filterByDbInstanceId($instanceIds, Criteria::IN)
                        ->filterByDbId($removedItem->getDbId(), Criteria::NOT_EQUAL)
                        ->delete($this->con);
                }

                // check to truncate the currently playing item instead of deleting it.
                if ($removedItem->isCurrentItem($this->epochNow)) {
                    $nEpoch = $this->epochNow;
                    $sEpoch = $removedItem->getDbStarts('U.u');

                    $length = bcsub($nEpoch, $sEpoch, 6);
                    $cliplength = Application_Common_DateHelper::secondsToPlaylistTime($length);

                    $cueinSec = Application_Common_DateHelper::playlistTimeToSeconds($removedItem->getDbCueIn());
                    $cueOutSec = bcadd($cueinSec, $length, 6);
                    $cueout = Application_Common_DateHelper::secondsToPlaylistTime($cueOutSec);

                    // Set DbEnds - 1 second because otherwise there can be a timing issue
                    // when sending the new schedule to Pypo where Pypo thinks the track is still
                    // playing.
                    $removedItem->setDbCueOut($cueout)
                        ->setDbClipLength($cliplength)
                        ->setDbEnds($this->nowDT)
                        ->save($this->con);
                } else {
                    $removedItem->delete($this->con);
                }
            }
            Application_Model_StoredFile::updatePastFilesIsScheduled();

            if ($adjustSched === true) {
                foreach ($effectedInstanceIds as $instance) {
                    $this->removeGaps($instance);
                    $this->calculateCrossfades($instance);
                }
            }

            // update the status flag in cc_schedule.
            $instances = CcShowInstancesQuery::create()
                ->filterByPrimaryKeys($effectedInstanceIds)
                ->find($this->con);

            foreach ($instances as $instance) {
                $instance->updateScheduleStatus($this->con);
                $instance->correctSchedulePositions();
            }

            // update the last scheduled timestamp.
            CcShowInstancesQuery::create()
                ->filterByPrimaryKeys($showInstances)
                ->update(['DbLastScheduled' => new DateTime('now', new DateTimeZone('UTC'))], $this->con);

            $this->con->commit();

            Application_Model_RabbitMq::PushSchedule();
        } catch (Exception $e) {
            $this->con->rollback();

            throw $e;
        }
    }

    // This is used to determine the duration of a files array
    public function timeLengthOfFiles($files)
    {
        $timeLength = 0;
        foreach ($files as $file) {
            $timeLength += Application_Common_DateHelper::playlistTimeToSeconds($file['cliplength']);
            $timeLength += $file['fadein'];
            $timeLength += $file['fadeout'];
        }

        return $timeLength;
    }

    /*
     * Used for cancelling the current show instance.
     *
     * @param $p_id id of the show instance to cancel.
     */
    public function cancelShow($p_id)
    {
        $this->con->beginTransaction();

        try {
            $instance = CcShowInstancesQuery::create()->findPK($p_id);

            if (!$instance->getDbRecord()) {
                $items = CcScheduleQuery::create()
                    ->filterByDbInstanceId($p_id)
                    ->filterByDbEnds($this->nowDT, Criteria::GREATER_THAN)
                    ->find($this->con);

                if (count($items) > 0) {
                    $remove = [];
                    $ts = $this->nowDT->format('U');

                    for ($i = 0; $i < count($items); ++$i) {
                        $remove[$i]['instance'] = $p_id;
                        $remove[$i]['timestamp'] = $ts;
                        $remove[$i]['id'] = $items[$i]->getDbId();
                    }

                    $this->removeItems($remove, false, true);
                }
            } else {
                $rebroadcasts = $instance->getCcShowInstancessRelatedByDbId(null, $this->con);
                $rebroadcasts->delete($this->con);
            }

            $instance->setDbEnds($this->nowDT);
            $instance->save($this->con);

            $this->con->commit();

            if ($instance->getDbRecord()) {
                Application_Model_RabbitMq::SendMessageToShowRecorder('cancel_recording');
            }
        } catch (Exception $e) {
            $this->con->rollback();

            throw $e;
        }
    }
}

class OutDatedScheduleException extends Exception {}