<?php

  namespace Sabre\CalDAV\Backend;

  use Sabre\VObject;

  use Sabre\CalDAV;

  
  /**
   * Abstract Calendaring backend. Extend this class to create your own backends.
   *
   * Checkout the BackendInterface for all the methods that must be implemented.
   *

   * @copyright Copyright (C) 2007-2014 fruux GmbH (https://fruux.com/).
   * @author Evert Pot (http://evertpot.com/)
   * @license http://sabre.io/license/ Modified BSD License

   */

  abstract class AbstractBackend implements BackendInterface {

  
      /**
       * Updates properties for a calendar.
       *
       * The mutations array uses the propertyName in clark-notation as key,
       * and the array value for the property value. In the case a property
       * should be deleted, the property value will be null.
       *
       * This method must be atomic. If one property cannot be changed, the
       * entire operation must fail.
       *
       * If the operation was successful, true can be returned.
       * If the operation failed, false can be returned.
       *
       * Deletion of a non-existent property is always successful.
       *
       * Lastly, it is optional to return detailed information about any
       * failures. In this case an array should be returned with the following
       * structure:
       *
       * array(
       *   403 => array(
       *      '{DAV:}displayname' => null,
       *   ),
       *   424 => array(
       *      '{DAV:}owner' => null,
       *   )
       * )
       *
       * In this example it was forbidden to update {DAV:}displayname.
       * (403 Forbidden), which in turn also caused {DAV:}owner to fail
       * (424 Failed Dependency) because the request needs to be atomic.
       *
       * @param mixed $calendarId
       * @param array $mutations
       * @return bool|array
       */
      public function updateCalendar($calendarId, array $mutations) {
  
          return false;
  
      }
  
      /**
       * Performs a calendar-query on the contents of this calendar.
       *
       * The calendar-query is defined in RFC4791 : CalDAV. Using the
       * calendar-query it is possible for a client to request a specific set of
       * object, based on contents of iCalendar properties, date-ranges and
       * iCalendar component types (VTODO, VEVENT).
       *
       * This method should just return a list of (relative) urls that match this
       * query.
       *
       * The list of filters are specified as an array. The exact array is

       * documented by \Sabre\CalDAV\CalendarQueryParser.

       *
       * Note that it is extremely likely that getCalendarObject for every path
       * returned from this method will be called almost immediately after. You
       * may want to anticipate this to speed up these requests.
       *
       * This method provides a default implementation, which parses *all* the
       * iCalendar objects in the specified calendar.
       *
       * This default may well be good enough for personal use, and calendars
       * that aren't very large. But if you anticipate high usage, big calendars
       * or high loads, you are strongly adviced to optimize certain paths.
       *
       * The best way to do so is override this method and to optimize
       * specifically for 'common filters'.
       *
       * Requests that are extremely common are:
       *   * requests for just VEVENTS
       *   * requests for just VTODO
       *   * requests with a time-range-filter on either VEVENT or VTODO.
       *
       * ..and combinations of these requests. It may not be worth it to try to
       * handle every possible situation and just rely on the (relatively
       * easy to use) CalendarQueryValidator to handle the rest.
       *
       * Note that especially time-range-filters may be difficult to parse. A
       * time-range filter specified on a VEVENT must for instance also handle
       * recurrence rules correctly.
       * A good example of how to interprete all these filters can also simply

       * be found in \Sabre\CalDAV\CalendarQueryFilter. This class is as correct

       * as possible, so it gives you a good idea on what type of stuff you need
       * to think of.
       *
       * @param mixed $calendarId
       * @param array $filters
       * @return array
       */
      public function calendarQuery($calendarId, array $filters) {
  
          $result = array();
          $objects = $this->getCalendarObjects($calendarId);

          $validator = new \Sabre\CalDAV\CalendarQueryValidator();

  
          foreach($objects as $object) {
  
              if ($this->validateFilterForObject($object, $filters)) {
                  $result[] = $object['uri'];
              }
  
          }
  
          return $result;
  
      }
  
      /**
       * This method validates if a filters (as passed to calendarQuery) matches
       * the given object.
       *
       * @param array $object

       * @param array $filters

       * @return bool
       */
      protected function validateFilterForObject(array $object, array $filters) {
  
          // Unfortunately, setting the 'calendardata' here is optional. If
          // it was excluded, we actually need another call to get this as
          // well.
          if (!isset($object['calendardata'])) {
              $object = $this->getCalendarObject($object['calendarid'], $object['uri']);
          }
  
          $data = is_resource($object['calendardata'])?stream_get_contents($object['calendardata']):$object['calendardata'];
          $vObject = VObject\Reader::read($data);

          $validator = new CalDAV\CalendarQueryValidator();

          return $validator->validate($vObject, $filters);
  
      }
  
  
  }