<?php

/**
 * CalDAV driver for the Calendar plugin.
 *
 * @author Aleksander Machniak <machniak@apheleia-it.ch>
 *
 * Copyright (C) 2012-2022, Apheleia IT AG <contact@apheleia-it.ch>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

require_once(__DIR__ . '/../kolab/kolab_driver.php');

class caldav_driver extends kolab_driver
{
    // features this backend supports
    public $alarms              = true;
    public $attendees           = true;
    public $freebusy            = true;
    public $attachments         = false; // TODO
    public $undelete            = false; // TODO
    public $alarm_types         = ['DISPLAY', 'AUDIO'];
    public $categoriesimmutable = true;

    /**
     * Default constructor
     */
    public function __construct($cal)
    {
        $cal->require_plugin('libkolab');

        // load helper classes *after* libkolab has been loaded (#3248)
        require_once(__DIR__ . '/caldav_calendar.php');
        // require_once(__DIR__ . '/kolab_user_calendar.php');
        // require_once(__DIR__ . '/caldav_invitation_calendar.php');

        $this->cal = $cal;
        $this->rc  = $cal->rc;

        // Initialize the CalDAV storage
        $url = $this->rc->config->get('calendar_caldav_server', 'http://localhost');
        $this->storage = new kolab_storage_dav($url);

        $this->cal->register_action('push-freebusy', [$this, 'push_freebusy']);
        $this->cal->register_action('calendar-acl', [$this, 'calendar_acl']);

        // $this->freebusy_trigger = $this->rc->config->get('calendar_freebusy_trigger', false);

        // TODO: get configuration for the Bonnie API
        // $this->bonnie_api = libkolab::get_bonnie_api();
    }

    /**
     * Read available calendars from server
     */
    protected function _read_calendars()
    {
        // already read sources
        if (isset($this->calendars)) {
            return $this->calendars;
        }

        // get all folders that support VEVENT, sorted by namespace/name
        $folders = $this->storage->get_folders('event');
            // + $this->storage->get_user_folders('event', true);

        $this->calendars = [];

        foreach ($folders as $folder) {
            $calendar = $this->_to_calendar($folder);
            if ($calendar->ready) {
                $this->calendars[$calendar->id] = $calendar;
                if ($calendar->editable) {
                    $this->has_writeable = true;
                }
            }
        }

        return $this->calendars;
    }

    /**
     * Convert kolab_storage_folder into caldav_calendar
     */
    protected function _to_calendar($folder)
    {
        if ($folder instanceof caldav_calendar) {
            return $folder;
        }

        if ($folder instanceof kolab_storage_folder_user) {
            $calendar = new kolab_user_calendar($folder, $this->cal);
            $calendar->subscriptions = count($folder->children) > 0;
        }
        else {
            $calendar = new caldav_calendar($folder, $this->cal);
        }

        return $calendar;
    }

    /**
     * Get a list of available calendars from this source.
     *
     * @param int    $filter Bitmask defining filter criterias
     * @param object $tree   Reference to hierarchical folder tree object
     *
     * @return array List of calendars
     */
    public function list_calendars($filter = 0, &$tree = null)
    {
        $this->_read_calendars();

        $folders   = $this->filter_calendars($filter);
        $calendars = [];

        // include virtual folders for a full folder tree
/*
        if (!is_null($tree)) {
            $folders = $this->storage->folder_hierarchy($folders, $tree);
        }
*/
        $parents = array_keys($this->calendars);

        foreach ($folders as $id => $cal) {
/*
            $path = explode('/', $cal->name);

            // find parent
            do {
                array_pop($path);
                $parent_id = $this->storage->folder_id(implode('/', $path));
            }
            while (count($path) > 1 && !in_array($parent_id, $parents));

            // restore "real" parent ID
            if ($parent_id && !in_array($parent_id, $parents)) {
                $parent_id = $this->storage->folder_id($cal->get_parent());
            }

            $parents[] = $cal->id;

            if ($cal->virtual) {
                $calendars[$cal->id] = [
                    'id'       => $cal->id,
                    'name'     => $cal->get_name(),
                    'listname' => $cal->get_foldername(),
                    'editname' => $cal->get_foldername(),
                    'virtual'  => true,
                    'editable' => false,
                    'group'    => $cal->get_namespace(),
                ];
            }
            else {
*/
                // additional folders may come from kolab_storage_dav::folder_hierarchy() above
                // make sure we deal with caldav_calendar instances
                $cal = $this->_to_calendar($cal);
                $this->calendars[$cal->id] = $cal;

                $is_user = ($cal instanceof caldav_user_calendar);

                $calendars[$cal->id] = [
                    'id'        => $cal->id,
                    'name'      => $cal->get_name(),
                    'listname'  => $cal->get_foldername(),
                    'editname'  => $cal->get_foldername(),
                    'title'     => '', // $cal->get_title(),
                    'color'     => $cal->get_color(),
                    'editable'  => $cal->editable,
                    'group'     => $is_user ? 'other user' : $cal->get_namespace(),
                    'active'    => $cal->is_active(),
                    'owner'     => $cal->get_owner(),
                    'removable' => !$cal->default,
                    // extras to hide some elements in the UI
                    'subscriptions' => false,
                    'driver' => 'caldav',
                ];

                if (!$is_user) {
                    $calendars[$cal->id] += [
                        'default'    => $cal->default,
                        'rights'     => $cal->rights,
                        'showalarms' => $cal->alarms,
                        'history'    => !empty($this->bonnie_api),
                        'children'   => true,  // TODO: determine if that folder indeed has child folders
                        'parent'     => $parent_id,
                        'subtype'    => $cal->subtype,
                        'caldavurl'  => '', // $cal->get_caldav_url(),
                    ];
                }
/*
            }
*/
            if ($cal->subscriptions) {
                $calendars[$cal->id]['subscribed'] = $cal->is_subscribed();
            }
        }
/*
        // list virtual calendars showing invitations
        if ($this->rc->config->get('kolab_invitation_calendars') && !($filter & self::FILTER_INSERTABLE)) {
            foreach ([self::INVITATIONS_CALENDAR_PENDING, self::INVITATIONS_CALENDAR_DECLINED] as $id) {
                $cal = new caldav_invitation_calendar($id, $this->cal);
                if (!($filter & self::FILTER_ACTIVE) || $cal->is_active()) {
                    $calendars[$id] = [
                        'id'         => $cal->id,
                        'name'       => $cal->get_name(),
                        'listname'   => $cal->get_name(),
                        'editname'   => $cal->get_foldername(),
                        'title'      => $cal->get_title(),
                        'color'      => $cal->get_color(),
                        'editable'   => $cal->editable,
                        'rights'     => $cal->rights,
                        'showalarms' => $cal->alarms,
                        'history'    => !empty($this->bonnie_api),
                        'group'      => 'x-invitations',
                        'default'    => false,
                        'active'     => $cal->is_active(),
                        'owner'      => $cal->get_owner(),
                        'children'   => false,
                        'counts'     => $id == self::INVITATIONS_CALENDAR_PENDING,
                    ];


                    if (is_object($tree)) {
                        $tree->children[] = $cal;
                    }
                }
            }
        }
*/
        // append the virtual birthdays calendar
        if ($this->rc->config->get('calendar_contact_birthdays', false) && !($filter & self::FILTER_INSERTABLE)) {
            $id    = self::BIRTHDAY_CALENDAR_ID;
            $prefs = $this->rc->config->get('kolab_calendars', []);  // read local prefs

            if (!($filter & self::FILTER_ACTIVE) || !empty($prefs[$id]['active'])) {
                $calendars[$id] = [
                    'id'         => $id,
                    'name'       => $this->cal->gettext('birthdays'),
                    'listname'   => $this->cal->gettext('birthdays'),
                    'color'      => !empty($prefs[$id]['color']) ? $prefs[$id]['color'] : '87CEFA',
                    'active'     => !empty($prefs[$id]['active']),
                    'showalarms' => (bool) $this->rc->config->get('calendar_birthdays_alarm_type'),
                    'group'      => 'x-birthdays',
                    'editable'   => false,
                    'default'    => false,
                    'children'   => false,
                    'history'    => false,
                ];
            }
        }

        return $calendars;
    }

    /**
     * Get the caldav_calendar instance for the given calendar ID
     *
     * @param string Calendar identifier
     *
     * @return ?caldav_calendar Object nor null if calendar doesn't exist
     */
    public function get_calendar($id)
    {
        $this->_read_calendars();

        // create calendar object if necessary
        if (empty($this->calendars[$id])) {
            if (in_array($id, [self::INVITATIONS_CALENDAR_PENDING, self::INVITATIONS_CALENDAR_DECLINED])) {
                return new caldav_invitation_calendar($id, $this->cal);
            }

            // for unsubscribed calendar folders
            if ($id !== self::BIRTHDAY_CALENDAR_ID) {
                $calendar = caldav_calendar::factory($id, $this->cal);
                if ($calendar->ready) {
                    $this->calendars[$calendar->id] = $calendar;
                }
            }
        }

        return !empty($this->calendars[$id]) ? $this->calendars[$id] : null;
    }

    /**
     * Search for shared or otherwise not listed calendars the user has access
     *
     * @param string Search string
     * @param string Section/source to search
     *
     * @return array List of calendars
     */
    public function search_calendars($query, $source)
    {
        $this->calendars = [];
        $this->search_more_results = false;
/*
        // find unsubscribed IMAP folders that have "event" type
        if ($source == 'folders') {
            foreach ((array) $this->storage->search_folders('event', $query, ['other']) as $folder) {
                $calendar = new kolab_calendar($folder->name, $this->cal);
                $this->calendars[$calendar->id] = $calendar;
            }
        }
        // find other user's virtual calendars
        else if ($source == 'users') {
            // we have slightly more space, so display twice the number
            $limit = $this->rc->config->get('autocomplete_max', 15) * 2;

            foreach ($this->storage->search_users($query, 0, [], $limit, $count) as $user) {
                $calendar = new caldav_user_calendar($user, $this->cal);
                $this->calendars[$calendar->id] = $calendar;

                // search for calendar folders shared by this user
                foreach ($this->storage->list_user_folders($user, 'event', false) as $foldername) {
                    $cal = new caldav_calendar($foldername, $this->cal);
                    $this->calendars[$cal->id] = $cal;
                    $calendar->subscriptions = true;
                }
            }

            if ($count > $limit) {
                $this->search_more_results = true;
            }
        }

        // don't list the birthday calendar
        $this->rc->config->set('calendar_contact_birthdays', false);
        $this->rc->config->set('kolab_invitation_calendars', false);
*/
        return $this->list_calendars();
    }

    /**
     * Get events from source.
     *
     * @param int    Event's new start (unix timestamp)
     * @param int    Event's new end (unix timestamp)
     * @param string Search query (optional)
     * @param mixed  List of calendar IDs to load events from (either as array or comma-separated string)
     * @param bool   Include virtual events (optional)
     * @param int    Only list events modified since this time (unix timestamp)
     *
     * @return array A list of event records
     */
    public function load_events($start, $end, $search = null, $calendars = null, $virtual = 1, $modifiedsince = null)
    {
        if ($calendars && is_string($calendars)) {
            $calendars = explode(',', $calendars);
        }
        else if (!$calendars) {
            $this->_read_calendars();
            $calendars = array_keys($this->calendars);
        }

        $query      = [];
        $events     = [];
        $categories = [];

        if ($modifiedsince) {
            $query[] = ['changed', '>=', $modifiedsince];
        }

        foreach ($calendars as $cid) {
            if ($storage = $this->get_calendar($cid)) {
                $events = array_merge($events, $storage->list_events($start, $end, $search, $virtual, $query));
                $categories += $storage->categories;
            }
        }

        // add events from the address books birthday calendar
        if (in_array(self::BIRTHDAY_CALENDAR_ID, $calendars)) {
            $events = array_merge($events, $this->load_birthday_events($start, $end, $search, $modifiedsince));
        }

        // add new categories to user prefs
        $old_categories = $this->rc->config->get('calendar_categories', $this->default_categories);
        $newcats = array_udiff(
            array_keys($categories),
            array_keys($old_categories),
            function($a, $b) { return strcasecmp($a, $b); }
        );

        if (!empty($newcats)) {
            foreach ($newcats as $category) {
                $old_categories[$category] = '';  // no color set yet
            }
            $this->rc->user->save_prefs(['calendar_categories' => $old_categories]);
        }

        array_walk($events, 'caldav_driver::to_rcube_event');

        return $events;
    }

    /**
     * Create instances of a recurring event
     *
     * @param array    Hash array with event properties
     * @param DateTime Start date of the recurrence window
     * @param DateTime End date of the recurrence window
     *
     * @return array List of recurring event instances
     */
    public function get_recurring_events($event, $start, $end = null)
    {
        // load the given event data into a libkolabxml container
        $event_xml = new kolab_format_event();
        $event_xml->set($event);
        $event['_formatobj'] = $event_xml;

        $this->_read_calendars();
        $storage = reset($this->calendars);

        return $storage->get_recurring_events($event, $start, $end);
    }

    /**
     *
     */
    protected function get_recurrence_count($event, $dtstart)
    {
        // load the given event data into a libkolabxml container
        $event_xml = new kolab_format_event();
        $event_xml->set($event);
        $event['_formatobj'] = $event_xml;

        // use libkolab to compute recurring events
        $recurrence = new kolab_date_recurrence($event['_formatobj']);

        $count = 0;
        while (($next_event = $recurrence->next_instance()) && $next_event['start'] <= $dtstart && $count < 1000) {
            $count++;
        }

        return $count;
    }

    /**
     * Callback function to produce driver-specific calendar create/edit form
     *
     * @param string Request action 'form-edit|form-new'
     * @param array  Calendar properties (e.g. id, color)
     * @param array  Edit form fields
     *
     * @return string HTML content of the form
     */
    public function calendar_form($action, $calendar, $formfields)
    {
        $special_calendars = [
            self::BIRTHDAY_CALENDAR_ID,
            self::INVITATIONS_CALENDAR_PENDING,
            self::INVITATIONS_CALENDAR_DECLINED
        ];

        // show default dialog for birthday calendar
        if (in_array($calendar['id'], $special_calendars)) {
            if ($calendar['id'] != self::BIRTHDAY_CALENDAR_ID) {
                unset($formfields['showalarms']);
            }

            // General tab
            $form['props'] = [
                'name'   => $this->rc->gettext('properties'),
                'fields' => $formfields,
            ];

            return kolab_utils::folder_form($form, '', 'calendar');
        }

        $this->_read_calendars();

        if (!empty($calendar['id']) && ($cal = $this->calendars[$calendar['id']])) {
            $folder = $cal->get_realname(); // UTF7
            $color  = $cal->get_color();
        }
        else {
            $folder = '';
            $color  = '';
        }

        $hidden_fields[] = ['name' => 'oldname', 'value' => $folder];

        $form      = [];
        $protected = false; // TODO

        // Disable folder name input
        if ($protected) {
            $input_name = new html_hiddenfield(['name' => 'name', 'id' => 'calendar-name']);
            $formfields['name']['value'] = $this->storage->object_name($folder)
                . $input_name->show($folder);
        }

        // calendar name (default field)
        $form['props']['fields']['location'] = $formfields['name'];

        if ($protected) {
            // prevent user from moving folder
            $hidden_fields[] = ['name' => 'parent', 'value' => '']; // TODO
        }
        else {
            $select = $this->storage->folder_selector('event', ['name' => 'parent', 'id' => 'calendar-parent'], $folder);

            $form['props']['fields']['path'] = [
                'id'    => 'calendar-parent',
                'label' => $this->cal->gettext('parentcalendar'),
                'value' => $select->show(strlen($folder) ? '' : ''), // TODO
            ];
        }

        // calendar color (default field)
        $form['props']['fields']['color']  = $formfields['color'];
        $form['props']['fields']['alarms'] = $formfields['showalarms'];

        return kolab_utils::folder_form($form, $folder, 'calendar', $hidden_fields);
    }
}