<?php
require_once(dirname(__FILE__)."/ui_calendar.class.php");
require_once(dirname(__FILE__)."/../backend/Schedule.php");
require_once('Calendar/Month/Weekdays.php');
require_once('Calendar/Week.php');

/**
 * @package Campcaster
 * @subpackage htmlUI
 * @copyright 2010 Sourcefabric O.P.S.
 */
class uiScheduler extends uiCalendar {
	/**
	 * @var array
	 */
    public $curr;

    /**
     * For the "schedule at time" value.
     *
     * @var array
     */
    public $scheduleAtTime;

    /**
     * For the "snap to previous" value.
     *
     * @var array
     */
    public $schedulePrev;

    /**
     * For the "snap to next" value.
     *
     * @var array
     */
    public $scheduleNext;

    /**
     * @var SchedulerPhpClient
     */
    public $spc;

    /**
     * @var uiBase
     */
    public $Base;

    /**
     * @var string
     */
    public $reloadUrl;

    /**
     * @var string
     */
    public $closeUrl;

    /**
     * Playlists that are available to be scheduled.  These are copied
     * from the scratchpad.
     *
     * @var array
     */
    private $availablePlaylists;

    public $firstDayOfWeek;
	  private $scriptError;
    public $error;


    public function __construct(&$uiBase)
    {
        $this->curr =& $_SESSION[UI_CALENDAR_SESSNAME]['current'];
        $this->scheduleAtTime =& $_SESSION[UI_CALENDAR_SESSNAME]['scheduleAtTime'];
        $this->schedulePrev =& $_SESSION[UI_CALENDAR_SESSNAME]['schedulePrev'];
        $this->scheduleNext =& $_SESSION[UI_CALENDAR_SESSNAME]['scheduleNext'];
        #$this->error =& $_SESSION['SCHEDULER']['error'];

        if (!is_array($this->curr)) {
            $this->curr['view'] = UI_SCHEDULER_DEFAULT_VIEW;
            $this->curr['year'] = strftime("%Y");
            $this->curr['month'] = strftime("%m");
            $this->curr['week'] = strftime("%V");
            $this->curr['day'] = strftime("%d");
            $this->curr['hour'] = strftime("%H");
            $this->curr['dayname'] = strftime("%A");
            $this->curr['monthname'] = strftime("%B");
            $this->curr['isToday'] = TRUE;
        }

        $this->Base =& $uiBase;
        $this->reloadUrl = UI_BROWSER.'?popup[]=_reload_parent&popup[]=_close';
        $this->closeUrl = UI_BROWSER.'?popup[]=_close';
        parent::__construct();
        $this->initXmlRpc();
    } // constructor


    public function setReload()
    {
        $this->Base->redirUrl = $this->reloadUrl;
    } // fn setReload


    public function setClose()
    {
        $this->Base->redirUrl = $this->closeUrl;
    } // fn setClose


    /**
     * @param array $arr
     * 		Can have keys:
     * 		["view"]
     * 		["today"]
     * 		["year"]
     * 		["month"]
     * 		["day"]
     * 		["hour"]
     * @return void
     */
    function set($arr)
    {
        extract($arr);

        if (isset($view)) {
            $this->curr['view'] = $view;
        }
        if (isset($today)) {
            list($year, $month, $day) = explode("-", strftime("%Y-%m-%d"));
        }
        if (isset($year) && is_numeric($year)) {
            $this->curr['year'] = sprintf('%04d', $year);
        }
        if (isset($month) && is_numeric($month)) {
            $this->curr['month'] = sprintf('%02d', $month);
        }
        if (isset($day) && is_numeric($day)) {
            $this->curr['day'] = sprintf('%02d', $day);
        }
        if (isset($hour) && is_numeric($hour)) {
            $this->curr['hour'] = sprintf('%02d', $hour);
        }

        $stampNow = self::datetimeToTimestamp($this->curr['year']
            .$this->curr['month']
            .$this->curr['day']
            .'T'.$this->curr['hour'].':00:00');
        $stampTarget = $stampNow;

        if (isset($month) && ($month==='++')) {
            $stampTarget = strtotime("+1 month", $stampNow);
        }
        if (isset($month) && ($month==='--')) {
            $stampTarget = strtotime("-1 month", $stampNow);
        }
        if (isset($week) && ($week==='++')) {
            $stampTarget = strtotime("+1 week", $stampNow);
        }
        if (isset($week) && ($week==='--')) {
            $stampTarget = strtotime("-1 week", $stampNow);
        }
        if (isset($day) && ($day==='++')) {
            $stampTarget = strtotime("+1 day", $stampNow);
        }
        if (isset($day) && ($day==='--')) {
            $stampTarget = strtotime("-1 day", $stampNow);
        }

        $this->curr['year'] = strftime("%Y", $stampTarget);
        $this->curr['month'] = strftime("%m", $stampTarget);
        $this->curr['week'] = strftime("%V", $stampTarget);
        $this->curr['day'] = strftime("%d", $stampTarget);
        $this->curr['hour'] = strftime("%H", $stampTarget);
        $this->curr['dayname'] = strftime("%A", $stampTarget);
        $this->curr['monthname'] = strftime("%B", $stampTarget);

        if ($this->curr['year'] === strftime("%Y") && $this->curr['month'] === strftime("%m") && $this->curr['day'] === strftime("%d")) {
            $this->curr['isToday'] = TRUE;
        } else {
            $this->curr['isToday'] = FALSE;
        }
    } // fn set


    /**
     * Set the schedule time given by parameters,
     * calculate previous and next clip to snap with it
     *
     * @param input $arr
     * 		Can contain keys:
     * 		["today"]
     * 		["year"]
     * 		["month"]
     * 		["day"]
     * 		["hour"]
     * 		["minute"]
     * 		["second"]
     *
     * @return void
     */
    public function setScheduleAtTime($arr)
    {
//        $today = $arr['today'];
//        $year = $arr['year'];
//        $month = $arr['month'];
//        $day = $arr['day'];
//        $hour = $arr['hour'];
//        $minute = $arr['minute'];
//        $second = $arr['second'];

        extract($arr);

        if (isset($today)) {
            list($year, $month, $day) = explode("-", strftime("%Y-%m-%d"));
        }
        if (is_numeric($year)) {
            $this->scheduleAtTime['year'] = sprintf('%04d', $year);
        }
        if (is_numeric($month)) {
            $this->scheduleAtTime['month'] = sprintf('%02d', $month);
        }
        if (is_numeric($day)) {
            $this->scheduleAtTime['day'] = sprintf('%02d', $day);
        }
        if (is_numeric($hour)) {
            $this->scheduleAtTime['hour'] = sprintf('%02d', $hour);
        }
        if (is_numeric($minute)) {
            $this->scheduleAtTime['minute'] = sprintf('%02d', $minute);
        }
        if (is_numeric($second)) {
            $this->scheduleAtTime['second'] = sprintf('%02d', $second);
        }

        $this->schedulePrev['year'] = $this->scheduleAtTime['year'];
        $this->schedulePrev['month'] = $this->scheduleAtTime['month'];
        $this->schedulePrev['day'] = $this->scheduleAtTime['day'];
        $this->schedulePrev['hour'] = 0;
        $this->schedulePrev['minute'] = 0;
        $this->schedulePrev['second'] = 0;

        $this->scheduleNext['year'] = $this->scheduleAtTime['year'];
        $this->scheduleNext['month'] = $this->scheduleAtTime['month'];
        $this->scheduleNext['day'] = $this->scheduleAtTime['day'];
        $this->scheduleNext['hour'] = 23;
        $this->scheduleNext['minute'] = 59;
        $this->scheduleNext['second'] = 59;

        $this->scheduleAtTime['stamp'] = self::datetimeToTimestamp(
            $this->scheduleAtTime['year']
            .$this->scheduleAtTime['month']
            .$this->scheduleAtTime['day']
            .'T'.$this->scheduleAtTime['hour']
            .':'.$this->scheduleAtTime['minute']
            .':'.$this->scheduleAtTime['second']);

        $week = $this->getWeekEntrys();
        if (is_array($week)) {
            // Search for previous entry
            if (count($week[$this->scheduleAtTime['day']]) >= 1) {
                $reversedDays = array_reverse($week[$this->scheduleAtTime['day']]);
                foreach ($reversedDays as $hourly) {
                    $reversedHours = array_reverse($hourly);
                    foreach ($reversedHours as $entry) {
                        if ($entry['end_stamp'] <=  $this->scheduleAtTime['stamp']) {
                            list ($this->schedulePrev['hour'], $this->schedulePrev['minute'], $this->schedulePrev['second']) =
                                explode (':', strftime('%H:%M:%S', strtotime('+'.UI_SCHEDULER_PAUSE_PL2PL, strtotime($entry['end'])))
                            );
                            break 2;
                        }
                    }
                }
            }
            reset($week);

            // Search for next entry
            if (count($week[$this->scheduleAtTime['day']]) >= 1) {
                // Go through each hour
                foreach ($week[$this->scheduleAtTime['day']] as $hourly) {
                    // Go through all the entries of the hour
                    foreach ($hourly as $entry) {
                        if ($entry['start_stamp'] >= $this->scheduleAtTime['stamp']) {
                            list ($this->scheduleNext['hour'], $this->scheduleNext['minute'], $this->scheduleNext['second']) =
                                explode (':', strftime('%H:%M:%S', strtotime('-'.UI_SCHEDULER_PAUSE_PL2PL, strtotime($entry['start']))));
                            break 2;
                        }
                    }
                }
            }
        }
    } // fn setScheduleAtTime


    /**
     * Get all items scheduled for the week.
     *
     * @return false|array
     */
    public function getWeekEntrys()
    {
        // build array within all entrys of current week
        $this->buildWeek();
        $thisWeekStart = strftime("%Y-%m-%d", $this->Week[0]['timestamp']);
        $nextWeekStart = strftime("%Y-%m-%d", $this->Week[6]['timestamp'] + 86400);
        $arr = $this->displayScheduleMethod($thisWeekStart.' 00:00:00', $nextWeekStart.' 00:00:00');

        if (!is_array($arr)) {
            return FALSE;
        }

        $items = array();
        foreach ($arr as $key => $val) {
          if ($val["count"] == "1") {
            $track = StoredFile::Recall($val["file_id"]);
            $trackMetadata = $track->getMetadata();
            $title = $trackMetadata["track_title"];
            $creator = $trackMetadata["artist_name"];
          } else {
            $title = $val["name"];
            $creator = $val["creator"];
          }

        	$startDay = strftime('%d', self::datetimeToTimestamp($val['start']));
        	$startHour = number_format(strftime('%H', self::datetimeToTimestamp($val['start'])));
            $items[$startDay][$startHour][]= array (
                'id' => $val['playlistId'],
                'scheduleid'=> $val["group_id"],
                'start' => substr($val['start'], strpos($val['start'], ' ')+1),
                'end' => substr($val['end'], strpos($val['end'], ' ')+1),
                'start_stamp' => self::datetimeToTimestamp($val['start']),
                'end_stamp' => self::datetimeToTimestamp($val['end']),
                'title' => $title,
                'creator' => $creator,
                'type' => 'Playlist'
            );
        }
        return $items;
    } // fn getWeekEntrys


    /**
     * Get all items scheduled for a given day.
     *
     * @return array|false
     */
    public function getDayEntrys()
    {
        // build array within all entrys of current day
        $this->buildDay();
        $thisDay = strftime("%Y-%m-%d", $this->Day[0]['timestamp']);
        $nextDay = strftime("%Y-%m-%d", $this->Day[0]['timestamp'] + 86400);
        $arr = $this->displayScheduleMethod($thisDay.' 00:00:00', $nextDay.' 00:00:00');
        if (!is_array($arr)) {
            return FALSE;
        }

        $items = array();
        foreach ($arr as $key => $val) {
        	$start = self::datetimeToTimestamp($val['start']);
          $end = self::datetimeToTimestamp($val['end']);
        	$Y = strftime('%Y', $start);
          $m = number_format(strftime('%m', $start));
          $d = number_format(strftime('%d', $start));
          $h = number_format(strftime('%H', $start));
          $M = number_format(strftime('%i', $start));

          $id = $val['playlistId'];
          $startHour = (int)strftime('%H', $start);
          $endHour = (int)strftime('%H', $end);
          $startTime = substr($val['start'], strpos($val['start'], ' ')+1);
          $endTime = substr($val['end'], strpos($val['end'], ' ') + 1);

          if ($val["count"] == "1") {
            $track = StoredFile::Recall($val["file_id"]);
            $trackMetadata = $track->getMetadata();
            $title = $trackMetadata["track_title"];
            $creator = $trackMetadata["artist_name"];
          } else {
            $title = $val["name"];
            $creator = $val["creator"];
          }
          // Item starts today
          if (strftime('%Y-%m-%d', $start) === $thisDay) {
              $endsToday = (strftime('%d', $start) === strftime('%d', $end)) ? TRUE : FALSE;
              $endsHere = strftime('%H', $start) === strftime('%H', $end) ? TRUE : FALSE;
          	$items[$startHour]['start'][] =
          	   array('id' => $id,
                     'scheduleid' => $val['id'],
                     'start' => $startTime,
                     'end' => $endTime,
                     'title' => $title,
                     'creator' => $creator,
                     'type' => 'Playlist',
                     'endstoday' => $endsToday,
                     'endshere' => $endsHere);
          }

          // Item ends today
          if ( (strftime('%Y-%m-%d', $end) === $thisDay) && ($startHour !== $endHour) ) {
              $startsYesterday = (strftime('%d', $start) === strftime('%d', $end)) ? FALSE : TRUE;

          	$items[$endHour]['end'][] =
          	   array('id' => $id,
                     'scheduleid' => $val['id'],
                     'start' => $startTime,
                     'end' => $endTime,
                     'title' => $title,
                     'creator' => $creator,
                     'type' => 'Playlist',
                     'startsyesterday' => $startsYesterday);
          }

          $diffHours = floor(($end - $start)/3600);
          // If the item spans three hours or more
          if ( $diffHours > 2 ) {
              // $skip becomes true if we dont actually have to do
              // this section.
              $skip = false;
              if (strftime('%Y-%m-%d', $start) === $thisDay) {
                  // For the edge case of starting at the end of
                  // today.
                  if ($startHour == 23) {
                      $skip = true;
                  }
                  $countStart = $startHour + 1;
              } else {
                  $countStart = 0;
              }
              if (strftime('%Y-%m-%d', $end) === $thisDay) {
                  // For the edge case of ending at the beginning
                  // of today.
                  if ($endHour == 0) {
                      $skip = true;
                  }
                  $countEnd = $endHour - 1;
              } else {
                  $countEnd = 23;
              }
              if (!$skip) {
                  for ($i = $countStart; $i <= $countEnd; $i++) {
                  	$items[$i]['span'] =
                  	   array('id' => $id,
      	                     'scheduleid' => $val['id'],
      	                     'start' => $startTime,
      	                     'end' => $endTime,
      	                     'title' => $title,
      	                     'creator' => $creator,
      	                     'type' => 'Playlist');
                  }
              }
          }
        }

        return $items;
    } // fn getDayEntrys


    private function getDayUsage($year, $month, $day)
    {
        $thisDay = $year.$month.$day;
        $nextDay = strftime("%Y-%m-%d", strtotime('+1 day', strtotime("$year-$month-$day")));
        $arr = $this->displayScheduleMethod($thisDay.' 00:00:00', $nextDay.' 00:00:00');

        if (!is_array($arr)) {
            return FALSE;
        }

        foreach ($arr as $key => $val) {
          $pl = Playlist::Recall($val['playlistId']);
        	//$id = BasicStor::IdFromGunid($val['playlistId']);
          $arr[$key]['title'] = $pl->getName(); //$this->Base->getMetadataValue($id, UI_MDATA_KEY_TITLE);
          $arr[$key]['creator'] = $pl->getPLMetaData("dc:title");// $this->Base->getMetadataValue($id, UI_MDATA_KEY_CREATOR);
          $arr[$key]['pos'] = self::datetimeToTimestamp($val['start']);
          $arr[$key]['span'] = date('H', self::datetimeToTimestamp($val['end'])) - date('H', self::datetimeToTimestamp($val['start'])) +1;
        }
        return $arr;
    } // fn getDayUsage


    /**
     * Return the percentage of the day for which audio has been scheduled.
     *
     * @param int $year
     * @param int $month
     * @param int $day
     * @return int
     */
    public function getDayUsagePercentage($year, $month, $day)
    {
        if (!$arr = $this->getDayUsage($year, $month, $day)) {
            return false;
        }

        $duration = 0;
        foreach ($arr as $val) {
            $duration += (self::datetimeToTimestamp($val['end'])-self::datetimeToTimestamp($val['start']))/86400*100;
        }
        return $duration;
    } // fn getDayUsagePercentage


    /**
     * Return an array of numbers from 0 to 23.
     *
     * @return array
     */
    public function getDayTimingScale()
    {
        for ($n = 0; $n <= 23; $n++) {
            $scale[] = $n;
        }

        return $scale;
    } //fn getDayTimingScale


    /**
     * @return array
     */
    public function getScheduleForm()
    {
        global $ui_fmask;
        foreach ($this->availablePlaylists as $val) {
            $ui_fmask['schedule']['id_duration']['options'][$val['id'].'|'.$val['duration']] = $val['title'];
        }

        $form = new HTML_QuickForm('schedule', UI_STANDARD_FORM_METHOD, UI_HANDLER);
        uiBase::parseArrayToForm($form, $ui_fmask['schedule']);
        $settime = array('H' => $this->scheduleAtTime['hour'],
                         'i' => $this->scheduleAtTime['minute'],
                         's' => $this->scheduleAtTime['second']);
        $setdate = array('Y' => $this->scheduleAtTime['year'],
                         'm' => $this->scheduleAtTime['month'],
                         'd' => $this->scheduleAtTime['day']);
        $form->setDefaults(array('time' => $settime,
                                 'date' => $setdate));

        $renderer = new HTML_QuickForm_Renderer_Array(true, true);
        $form->accept($renderer);
        $output = $renderer->toArray();
        return $output;
    } // fn getScheduleForm


    public function getPlaylistToSchedule($id)
    {
        if ($id) {
            $this->Base->SCRATCHPAD->addItem($id, 'playlist');
            $this->availablePlaylists[] = $this->Base->getPLMetaInfo($id);
            return TRUE;
        } else {
            return $this->copyPlaylistFromScratchpad();
        }
    } // fn getPlaylistToSchedule


    /**
     * Get the currently available playlists in the scratchpad and
     * add them to the internal $this->availablePlaylists array.
     *
     * @return boolean
     */
    private function copyPlaylistFromScratchpad()
    {
    	$scratchpad = $this->Base->SCRATCHPAD->get();
        foreach ($scratchpad as $val) {
            if ($val['type'] === 'playlist'
            	&& ($this->Base->gb->playlistIsAvailable($val['id'], $this->Base->sessid) === TRUE)
            	&& ($val['id'] != $this->Base->PLAYLIST->activeId) ) {
                $this->availablePlaylists[] = $val;
            }
        }
        if (!count($this->availablePlaylists)) {
            return FALSE;
        }

        return TRUE;
    }


    /**
     * Get a scheduled item.
     *
     * Note: just use methods here which work without valid authentification.
     *
     * @param int $p_playlist_nr
     *      0=current pl; 1=next pl ...
     * @return array
     */
    public function getScheduledPlaylist($p_playlist_nr=0, $p_period=3600)
    {
        $now = time();
        $start = strftime('%Y-%m-%d %H:%M:%S', $now);
        $end =  $p_playlist_nr ? strftime('%Y-%m-%d %H:%M:%S', $now + $p_period) : strftime('%Y-%m-%d %H:%M:%S', $now);
        $playlists = $this->displayScheduleMethod($start, $end);

        if (!is_array($playlists) || !count($playlists)) {
            return FALSE;
        }

        switch ($p_playlist_nr) {
            case 0:
                if ($playlist = current($playlists)) {
                    return $playlist;
                }
            break;

            default:
                $pos = 0;
                foreach ($playlists as $playlist) {
                    if (self::datetimeToTimestamp($playlist['start']) > $now) {
                        $pos++;
                        if ($pos == $p_playlist_nr) {
                            return $playlist;
                        }
                    }
                }
            break;
        }
        return false;
    }   // fn getScheduledPlaylist


    public function getClipFromCurrent($p_playlist, $p_item_nr=0)
    {
        //  subtract difference to UTC
        $offset = strftime('%H:%M:%S', time() - self::datetimeToTimestamp($p_playlist['start']) - 3600 * strftime('%H', 0));

        $clip = $this->Base->gb->displayPlaylistClipAtOffset($this->Base->sessid, $p_playlist['playlistId'], $offset, $p_item_nr, $_SESSION['langid'], UI_DEFAULT_LANGID);

        if (!$clip['gunid']) {
            return FALSE;
        }

        $secondsElapsed = Playlist::playlistTimeToSeconds($clip['elapsed']);
        $secondsRemaining =  Playlist::playlistTimeToSeconds($clip['remaining']);
        list($duration['h'], $duration['m'], $duration['s']) = explode(':', Playlist::secondsToPlaylistTime($secondsElapsed + $secondsRemaining));
        list($elapsed['h'], $elapsed['m'], $elapsed['s']) = explode(':', $clip['elapsed']);
        list($remaining['h'], $remaining['m'], $remaining['s']) = explode(':', $clip['remaining']);
        $duration = array_map('round', $duration);
        $elapsed = array_map('round', $elapsed);
        $remaining = array_map('round', $remaining);
        $percentage =  $secondsElapsed ? (100 * $secondsElapsed / ($secondsElapsed + $secondsRemaining)) : 100;

        return array('title' => $clip['title'],
                     'duration'  => $duration,
                     'elapsed'   => $elapsed,
                     'remaining' => $remaining,
                     'percentage'=> $percentage,
                     'playlist'  => $clip['playlist']
               );
    }

    public function getClipFromPlaylist($p_playlist, $p_position=0)
    {
        $pos = 0;
        $playlist = new uiPlaylist($this->Base);
        $flat = $playlist->getFlat(BasicStor::IdFromGunid($p_playlist['playlistId']));

        foreach ($flat as $clip) {
            if ($pos == $p_position) {
                $found = true;
                break;
            }
            $pos++;
        }
        if ($found) {
            list($duration['h'], $duration['m'], $duration['s']) = explode(':', $clip['attrs']['clipLength']);
            list($elapsed['h'], $elapsed['m'], $elapsed['s']) = explode(':', '00:00:00');
            $remaining = $duration;
            $duration = array_map('round', $duration);
            $elapsed = array_map('round', $elapsed);
            $remaining = array_map('round', $remaining);
            $percentage =  $secondsElapsed ? (100 * $secondsElapsed / ($secondsElapsed + $secondsRemaining)) : 100;
            return array(
                     'title' => $clip['title'],
                     'duration'  => $duration,
                     'elapsed'   => $elapsed,
                     'remaining' => $remaining,
                     'percentage'=> $percentage
            );
        }
        return false;
    }

    public function getScheduleInfo_jscom($p_playlist_nr=0)
    {
        // just use methods which work without valid authentification
        $c_pl = self::getScheduledPlaylist();
        $pl = Playlist::Recall($c_pl['playlistId']);

        $n_clip = null;
        if ($c_clip = $this->getClipFromCurrent($c_pl, 0)) {
            $n_clip = $this->getClipFromCurrent($c_pl, 1);
        }
        $nextClip = StoredFile::Recall($n_clip);
        $u_clip = null;
        $u_pl_start = null;
        if ($u_pl = self::getScheduledPlaylist(2)) {
            $u_clip = $this->getClipFromPlaylist($u_pl);
            $u_pl_start = explode(':', date('H:i:s', self::datetimeToTimestamp($u_pl['start'])));
        }
        $upcomingClip = StoredFile::Recall($u_pl['playlistId']);

        return array(
            'current'               => $c_clip ? 1 : 0,
            'current.title'         => addcslashes($c_clip['title'], "'"),
            //'current.pltitle'       => addcslashes($this->Base->getMetadataValue(BasicStor::IdFromGunid($c_pl['playlistId']), UI_MDATA_KEY_TITLE), "'"),
            'current.pltitle'       => addcslashes($pl->getName(), "'"),
        		'current.elapsed.h'     => $c_clip['elapsed']['h'],
            'current.elapsed.m'     => $c_clip['elapsed']['m'],
            'current.elapsed.s'     => $c_clip['elapsed']['s'],
            'current.duration.h'    => $c_clip['duration']['h'],
            'current.duration.m'    => $c_clip['duration']['m'],
            'current.duration.s'    => $c_clip['duration']['s'],

            'next'                  => $n_clip ? 1 : 0,
            'next.title'            => $n_clip ? addcslashes($n_clip['title'], "'") : "",
            //'next.pltitle'          => addcslashes($this->Base->getMetadataValue($n_clip, UI_MDATA_KEY_TITLE), "'"),
            'next.pltitle'          => addcslashes($nextClip->getTitle(), "'"),
        		'next.duration.h'       => $n_clip ? $n_clip['duration']['h'] : 0,
            'next.duration.m'       => $n_clip ? $n_clip['duration']['m'] : 0,
            'next.duration.s'       => $n_clip ? $n_clip['duration']['s'] : 0,

            'upcoming'              => $u_pl ? 1 : 0,
            'upcoming.title'        => addcslashes($u_clip['title'], "'"),
            //'upcoming.pltitle'      => addcslashes($this->Base->getMetadataValue(BasicStor::IdFromGunid($u_pl['playlistId']), UI_MDATA_KEY_TITLE), "'"),
            'upcoming.pltitle'      => addcslashes($upcomingClip->getName(), "'"),
        		'upcoming.duration.h'   => $u_clip['duration']['h'],
            'upcoming.duration.m'   => $u_clip['duration']['m'],
            'upcoming.duration.s'   => $u_clip['duration']['s'],
            'upcoming.plstart.h'    => $u_pl_start[0],
            'upcoming.plstart.m'    => $u_pl_start[1],
            'upcoming.plstart.s'    => $u_pl_start[2],

        );
    }


    /**
     * Convert a string timestamp to UNIX time value.
     *
     * @param string $i
     * @return int
     */
    public static function datetimeToTimestamp($i)
    {
      $i = str_replace('-', '', $i);
      $i = str_replace(' ', 'T', $i);
      $i = substr($i, 0, 17);
      return self::strtotime($i);
    } // fn datetimeToTimestamp


    /**
     * There is a bug in strtotime() - it does not support
     * datetime-format using "T" character correctly, so we need this
     * function.
     *
     * @param string $input
     * @return string
     */
    private static function strtotime($input)
    {
        return strtotime(str_replace('T', ' ', $input));
    }


    protected function _scheduledDays($period)
    {
        if ($period === 'month') {
            $Period = new Calendar_Month_Weekdays($this->curr['year'], $this->curr['month'], $this->firstDayOfWeek);
            $Period->build();
        } elseif ($period === 'week') {
            $Period = new Calendar_Week($this->curr['year'], $this->curr['month'], $this->curr['day'], $this->firstDayOfWeek);
            $Period->build();
        } else {
            return array();
        }
        $d = $Period->fetch();
        // The next two lines are due to a bug in Calendar_Month_Weekdays
        $corrMonth = ($d->thisMonth() <= 12) ? sprintf('%02d', $d->thisMonth()) : '01';
        $corrYear = ($d->thisMonth() <= 12) ? $d->thisYear() : $d->thisYear()+1;
        $first = array('day'   => sprintf('%02d', $d->thisDay()),
                       'month' => $corrMonth,
                       'year'  => $corrYear);

        while ($l = $Period->fetch()) {
            $d = $l;
        }
        // The next two lines are due to a bug in Calendar_Month_Weekdays
        $corrMonth = ($d->thisMonth() <= 12) ? sprintf('%02d', $d->thisMonth()) : '01';
        $corrYear = ($d->thisMonth() <= 12) ? $d->thisYear() : $d->thisYear()+1;
        $last = array('day'   => sprintf('%02d', $d->thisDay()),
                      'month' => $corrMonth,
                      'year'  => $corrYear);

        $days = $this->_receiveScheduledDays($first['year'].$first['month'].$first['day'], $last['year'].$last['month'].$last['day']);
        foreach ($days as $val) {
            $selections[] = new Calendar_Day($val['year'], $val['month'], $val['day']);
        }
        return $selections;
    } // fn _scheduledDays


    private function _receiveScheduledDays($dfrom, $dto)
    {
        $dfrom = $dfrom.' 00:00:00';
        $dto = $dto.' 23:59:59';
        if (($pArr = $this->displayScheduleMethod($dfrom, $dto)) === FALSE) {
            return array(FALSE);
        }

        $pStampArr = null;
        foreach ($pArr as $val) {
            $pStampArr[] = array('start' => self::datetimeToTimestamp($val['start']),
                                 'end'   => self::datetimeToTimestamp($val['end']));
        }
        if (is_array($pStampArr)) {
            for ($n = self::datetimeToTimestamp($dfrom); $n <= self::datetimeToTimestamp($dto); $n+=86400) {
                foreach ($pStampArr as $val) {
                    if ($val['start'] < $n+86400 && $val['end'] >= $n) {
                        $days[date('Ymd', $n)] = array('year'  => date('Y', $n),
                                                                       'month' => date('m', $n),
                                                                       'day'   => date('d', $n));
                    }
                }
            }
            return $days;
        }
        return array(FALSE);
    } // fn _receiveScheduledDays


    /**
     * Return true if the argument is an array and has a key index "error"
     * which is an array.  If it is an error, set the internal error
     * message, which can be retrieved with getErrorMsg().
     *
     * @param mixed $r
     * @return boolean
     */
    function _isError($r)
    {
        if (isset($r['error']) && is_array($r['error'])) {
            $this->setErrorMsg(tra('Error: $1', str_replace("\n", "\\n", addslashes($r['error']['message']))));
            return TRUE;
        }
        return FALSE;
    } // fn _isError


    function getErrorMsg()
    {
        return $this->error;
    } // fn getErrorMsg


    /**
     * Set the internal error message.
     *
     * @param string $msg
     * @return void
     */
    public function setErrorMsg($msg)
    {
        $this->error = $msg;
    } // fn setErrorMsg


    /********************************************************************
     * Scheduler Daemon methods
     ********************************************************************/

    /**
     * Return TRUE if the scheduler startup script has been configured.
     * If not, the internal variable $this->scriptError is set with the
     * error message.
     *
     * @return boolean
     */
    private function scriptIsConfigured()
    {
    	$this->scriptError = null;
        if (!isset($this->Base->STATIONPREFS['schedulerStartupScript'])
        	|| empty($this->Base->STATIONPREFS['schedulerStartupScript'])) {
           	$this->scriptError = 'Scheduler startup script has not been defined.  Please set this value in the "Preferences->Station Settings".';
           	return FALSE;
        } elseif (!file_exists($this->Base->STATIONPREFS['schedulerStartupScript'])) {
        	$this->scriptError = sprintf('The scheduler startup script you defined does not exist.  You can set this value in "Preferences->Station Settings".  The current value is "%s"', $this->Base->STATIONPREFS['schedulerStartupScript']);
        	return FALSE;
        }
        return TRUE;
    }


    public function getScriptError()
    {
    	return $this->scriptError;
    }


    /**
     * Try to start the scheduler daemon.
     *
     * @param boolean $msg
     * @return boolean
     */
    public function startDaemon($msg=FALSE)
    {
    	if (!$this->scriptIsConfigured()) {
			return FALSE;
    	}
        if ($this->daemonIsRunning($msg) === TRUE) {
            return TRUE;
        }

        $cmd = "{$this->Base->STATIONPREFS['schedulerStartupScript']} start 1>/tmp/scheduler_startup.log 2>&1";
        exec($cmd);
        flush();
        sleep(2);

        if ($this->daemonIsRunning($msg)===FALSE) {
            if ($msg) {
		        $output = file('/tmp/scheduler_startup.log');
		        $message = '';
		        foreach ($output as $line) {
		            $message .= trim(addslashes($line)).'\n';
		        }
            	$this->Base->_retMsg('Scheduler did not start. Returned message:\n$1', $message);
            }
            return FALSE;
        }
    } // fn startDaemon


    /**
     * Try to stop the scheduler daemon.
     *
     * @param boolean $msg
     * @return boolean
     */
    public function stopDaemon($msg=FALSE)
    {
    	if (!$this->scriptIsConfigured()) {
			return FALSE;
    	}
        if ($this->daemonIsRunning($msg) === FALSE) {
            return TRUE;
        }

        $cmd = "{$this->Base->STATIONPREFS['schedulerStartupScript']} stop 1>/tmp/scheduler_startup.log 2>&1";
        exec($cmd);
        flush();
        sleep(2);

        if ($this->daemonIsRunning($msg)===TRUE) {
            if ($msg) {
		        $output = file('/tmp/scheduler_startup.log');
		        foreach ($output as $line) {
		            $message .= trim(addslashes($line)).'\n';
		        }
                $this->Base->_retMsg('Scheduler did not stop. Returned message:\n$1', $message);
            }
            return FALSE;
        }
    } // fn stopDaemon


    /**
     * Return TRUE if the scheduler daemon is running.
     *
     * @param boolean $msg
     * @return boolean
     */
    public function daemonIsRunning($msg = FALSE)
    {
    	if (!$this->scriptIsConfigured()) {
			return FALSE;
    	}
        $cmd = "{$this->Base->STATIONPREFS['schedulerStartupScript']} status";
        exec($cmd, $output);

        if (empty($output)) {
           	$this->scriptError = 'Scheduler startup script does not appear to be valid.  Please check the value you have set in "Preferences->Station Settings".';
           	return FALSE;
        }
        $message = "";
        foreach ($output as $line) {
            $message .= trim(addslashes($line)).'\n';
        }

        if (strstr($message, 'is running')) {
            if ($msg) {
                $this->Base->_retMsg('Scheduler is running.');
            }
            return TRUE;
        }

        return FALSE;
    } // fn daemonIsRunning


    /********************************************************************
     * XML-RPC wrapper methods
     ********************************************************************/

    /**
     * Create the XMLRPC client.
     */
    function initXmlRpc()
    {
//        include_once(dirname(__FILE__).'/ui_schedulerPhpClient.class.php');
//        $this->spc =& SchedulerPhpClient::factory($mdefs, FALSE, FALSE);
    } // fn initXmlRpc


    /**
     * Add an item to the scheduler.
     *
     * @param array $formdata
     *      Must have the following keys set:
     *      ['playlist'] -> id of playlist
     *      ['date']['Y'] - Year
     *      ['date']['m'] - month
     *      ['date']['d'] - day
     *      ['date']['H'] - hour
     *      ['date']['i'] - minute
     *      ['date']['s'] - second
     *
     * @return int|PEAR_Error
     *
     */
    function addItem(&$formdata)
    {
        $playlistId = $formdata['playlist'];
        $datetime = $formdata['date']['Y']
            .'-'
            .sprintf('%02d', $formdata['date']['m'])
            .'-'
            .sprintf('%02d', $formdata['date']['d'])
            .' '.sprintf('%02d', $formdata['time']['H'])
            .':'.sprintf('%02d', $formdata['time']['i'])
            .':'.sprintf('%02d', $formdata['time']['s']);

        $item = new ScheduleGroup();
        $groupId = $item->add($datetime, null, $playlistId);
        return $groupId;
    }


    /**
     * Remove an item from the scheduler.
     *
     * @param string $id
     *      groupId of the item
     * @return boolean
     *      TRUE on success, FALSE on failure.
     */
    function removeFromScheduleMethod($p_groupId)
    {
      $item = new ScheduleGroup($p_groupId);
      $success = $item->remove();
      //$r = $this->spc->removeFromScheduleMethod($this->Base->sessid, $id);
      if (!$success) {
        return FALSE;
      }
      if (UI_VERBOSE) {
        $this->Base->_retMsg('Entry with ScheduleId $1 removed.', $id);
      }
      return TRUE;
    } // fn removeFromScheduleMethod


    /**
     * Get the scheduled items between the $from and $to dates.
     *
     * @param string $from
     *      In the format "YYYY-MM-DD HH:MM:SS.nnnnnn"
     * @param string $to
     *      In the format "YYYY-MM-DD HH:MM:SS.nnnnnn"
     * @return array|false
     */
    function displayScheduleMethod($p_from, $p_to, $p_playlistsOnly = true)
    {
      $items = Schedule::GetItems($p_from, $p_to, $p_playlistsOnly);
      //$_SESSION["debug"] = $items;
      return $items;
    } // fn displayScheduleMethod


    /********************************************************************
     * Export Methods
     ********************************************************************/

    /**
     * Get the token for the schedule which is currently being exported.
     * It is stored in the user preferences.
     *
     * @return string
     */
    function getExportToken()
    {
        $token = $this->Base->gb->loadPref($this->Base->sessid, UI_SCHEDULER_EXPORTTOKEN_KEY);

        if (PEAR::isError($token) || empty($token)) {
            return false;
        }
        return $token;
    } // fn getExportToken


    /**
     * Export a schedule within a certain time range.
     *
     * @param string $from
     *      Date-time format
     * @param string $to
     *      Date-time format
     * @return boolean
     */
    function scheduleExportOpen($from, $to)
    {
        $criteria = array('filetype' => UI_FILETYPE_ANY);
        $token = $this->spc->exportOpenMethod($this->Base->sessid, $criteria, $from, $to);

        if (PEAR::isError($token)) {
            $this->Base->_retMsg('Error initializing scheduler export: $1', $token->getMessage());
            return false;
        }

        if (isset($token["error"])) {
            $this->Base->_retMsg('Error initializing scheduler export: $1',
                                 $token["error"]["code"].":".$token["error"]["message"]);
            return false;
        }
        $this->Base->gb->savePref($this->Base->sessid, UI_SCHEDULER_EXPORTTOKEN_KEY, $token['token']);
        //$this->scheduleExportCheck();
        return true;
    } // fn scheduleExportOpen


    /**
     * Check the status of a schedule that is being exported.
     *
     * @return string|false
     */
    function scheduleExportCheck()
    {
        $token = $this->getExportToken();

        if (empty($token)) {
            $this->Base->_retMsg('Token not available');
            return false;
        }

        $res = $this->spc->exportCheckMethod($token);
        if (PEAR::isError($res)) {
            $this->Base->_retMsg('Unable to check scheduler export status: $1', $res->getMessage());
            return false;
        }
        return $res;
    } // fn scheduleExportCheck


    function scheduleExportClose()
    {
        $token = $this->getExportToken();

        if (empty($token)) {
            $this->Base->_retMsg('Token not available');
            return false;
        }

        $status = $this->spc->exportCloseMethod($token);

        if (PEAR::isError($status)) {
            $this->Base->_retMsg('Error closing scheduler export: $1', $status->getMessage());
            return false;
        }

        if ($status === true) {
            $this->Base->gb->delPref($this->Base->sessid, UI_SCHEDULER_EXPORTTOKEN_KEY);
        }

        return $status;
    } // fn scheduleExportClose


    /********************************************************************
     * Import Methods
     ********************************************************************/


    function getImportToken()
    {
        $token = $this->Base->gb->loadPref($this->Base->sessid, UI_SCHEDULER_IMPORTTOKEN_KEY);

        if (PEAR::isError($token)) {
            return false;
        }
        return $token;
    } // fn getImportToken


    function scheduleImportOpen($filename)
    {
        $token = $this->spc->importOpenMethod($this->Base->sessid, $filename);

        if (PEAR::isError($token)) {
            $this->Base->_retMsg('Error initializing scheduler import: $1', $token->getMessage());
            return false;
        }

        $this->scheduleImportCheck();

        $this->Base->gb->savePref($this->Base->sessid, UI_SCHEDULER_IMPORTTOKEN_KEY, $token['token']);

        return true;
    } // fn scheduleImportOpen


    function scheduleImportCheck()
    {
        $token = $this->getImportToken();

        if ($token === false) {
            return false;
        }

        $res = $this->spc->importCheckMethod($token);
        //echo '<XMP style="background:yellow;">'; var_dump($res); echo "</XMP>\n";
        if (PEAR::isError($res)) {
            $this->Base->_retMsg('Unable to check scheduler import status: $1', $res->getMessage());
            return false;
        }

        return $res;
    } // fn scheduleImportCheck


    function scheduleImportClose()
    {
        $token = $this->getImportToken();

        if ($token === false) {
            $this->Base->_retMsg('Token not available');
            return false;
        }

        $status = $this->spc->importCloseMethod($token);

        if (PEAR::isError($status)) {
            $this->Base->_retMsg('Error closing scheduler import: $1', $status->getMessage());
            return false;
        }

        if ($status === true) {
            $this->Base->gb->delPref($this->Base->sessid, UI_SCHEDULER_IMPORTTOKEN_KEY);
        }

        return $status;
    } // fn scheduleImportClose

    public function getSchedulerTime()
    {
      return time();
        static $first, $cached;
        if (!$first) {
            $first = time();
            $r = $this->spc->GetSchedulerTimeMethod();
            if ($this->_isError($r)) {
                return false;
            }
            $cached = self::datetimeToTimestamp($r['schedulerTime']);
        }
        $schedulerTime = $cached + time() - $first;
        return $schedulerTime;
    }

} // class uiScheduler

?>