<?php

declare(strict_types=1);

/**
 * @copyright Copyright (c) 2021, Watcha <contact@watcha.fr>
 *
 * @author Charlie Calendre <c-cal@watcha.fr>
 *
 * @license GNU AGPL version 3 or any later version
 *
 * 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/>.
 *
 */

namespace OCA\Watcha\Controller;

use Psr\Log\LoggerInterface;

use OCA\DAV\CalDAV\CalDavBackend;
use OCP\AppFramework\Controller;
use OCP\AppFramework\Http;
use OCP\AppFramework\Http\JSONResponse;
use OCP\IConfig;
use OCP\IDBConnection;
use OCP\IGroup;
use OCP\IGroupManager;
use OCP\IRequest;
use OCP\IUserManager;
use OCP\Util;
use Sabre\DAV\Exception\NotFound;
use Sabre\Uri;

use OCA\Watcha\Dav;
use OCA\Watcha\Exception\GenericException;

const CALENDAR_ORDER_KEY = "{http://apple.com/ns/ical/}calendar-order";
const DISPLAYNAME_KEY = "{DAV:}displayname";
const OWNER_PRINCIPAL_KEY = "{" . \OCA\DAV\DAV\Sharing\Plugin::NS_OWNCLOUD . "}owner-principal";
const SUPPORTED_CALENDAR_COMPONENT_SET_KEY = "{" . \OCA\DAV\CalDAV\Plugin::NS_CALDAV . "}supported-calendar-component-set";

class CalendarController extends Controller {
    /** @var string */
    private $userId;

    /** @var LoggerInterface */
    private $logger;

    /** @var CalDavBackend */
    private $caldav;

    /** @var IDBConnection */
    private $connection;

    /** @var IUserManager */
    private $userManager;

    /** @var IGroupManager */
    private $groupManager;

    /** @var IConfig */
    private $config;

    public function __construct(
        string $AppName,
        string $UserId,
        IRequest $request,
        LoggerInterface $logger,
        CalDavBackend $caldav,
        IDBConnection $connection,
        IUserManager $userManager,
        IGroupManager $groupManager,
        IConfig $config
    ) {
        parent::__construct($AppName, $request);
        $this->userId = $UserId;
        $this->logger = $logger;
        $this->caldav = $caldav;
        $this->connection = $connection;
        $this->userManager = $userManager;
        $this->groupManager = $groupManager;
        $this->config = $config;
    }

    /**
     * @NoAdminRequired
     * @NoCSRFRequired
     * 
     * @param string $userId
     * @return JSONResponse
     */
    public function list(string $userId) {
        $principalUri = "principals/users/$userId";
        $calendars = $this->caldav->getUsersOwnCalendars($principalUri);
        $fmtCalendars = [];
        foreach ($calendars as $calendar) {
            $fmtCalendars[] = [
                "id" => (int) $calendar["id"],
                "displayname" => $calendar[DISPLAYNAME_KEY],
                "components" => $calendar[SUPPORTED_CALENDAR_COMPONENT_SET_KEY]->getValue()
            ];
        }
        usort($fmtCalendars, function (array $a, array $b) {
            return strcmp(strtolower($a['displayname']), strtolower($b['displayname']));
        });
        return new JSONResponse($fmtCalendars);
    }

    /**
     * @NoAdminRequired
     * @NoCSRFRequired
     * 
     * @param string $userId
     * @param int $calendarId
     * @return JSONResponse
     */
    public function get(string $userId, int $calendarId) {
        $calendar = $this->getFormatedCalendar($calendarId);
        try {
            $displayName = $this->getDisplayName($userId, $calendarId);
        } catch (GenericException $e) {
            return new JSONResponse(["message" => $e->getMessage()], $e->getHTTPCode());
        }
        $calendar["displayname"] = $displayName;
        return new JSONResponse($calendar);
    }

    /**
     * @NoAdminRequired
     * @NoCSRFRequired
     * 
     * @param string $userId
     * @param int $calendarId
     * @return JSONResponse
     */
    public function reorder(string $userId, int $calendarId) {
        $calendar = $this->caldav->getCalendarById($calendarId);
        if (is_null($calendar)) {
            $this->logger->warning("calendar $calendarId no found, can't reorder it for user $userId");
            return;
        }
        $components = $calendar[SUPPORTED_CALENDAR_COMPONENT_SET_KEY]->getValue();
        if (in_array("VTODO", $components)) {
            list(, $ownerId) = Uri\split($calendar["principaluri"]);
            $calendarUri = $ownerId === $userId ? $calendar["uri"] : $this->computeUriForSharedCalendar($calendar["uri"], $ownerId);
            $value = "/calendars/$calendarUri";
            $this->config->setUserValue($userId, "tasks", "various_initialRoute", $value);
            $this->logger->info("todo list with URI $calendarUri defined as initial route for user $userId");
        }

        $query = $this->connection->getQueryBuilder();
        $fields = ["propertypath", "propertyvalue"];
        $query->select($fields)
            ->from("properties")
            ->where($query->expr()->eq("userid", $query->createNamedParameter($userId)))
            ->andWhere($query->expr()->eq("propertyname",  $query->createNamedParameter(CALENDAR_ORDER_KEY)))
            ->orderBy("propertyvalue", "ASC");

        $cursor = $query->execute();

        $ocProperties = array();

        while ($row = $cursor->fetch()) {
            $order = (int) $row["propertyvalue"];
            $path = (string) $row["propertypath"];
            $ocProperties[$path] = [
                "order" => $order
            ];
        }

        $cursor->closeCursor();

        $principalUri = "principals/users/$userId";
        $calendars = $this->caldav->getCalendarsForUser($principalUri);
        $orderedCalendars = array();

        foreach ($calendars as $calendar) {
            $owner = $calendar[OWNER_PRINCIPAL_KEY];
            $uri = $calendar["uri"];
            $path = "calendars/$userId/$uri";
            if ($owner !== $principalUri and array_key_exists($path, $ocProperties)) {
                $ocProperties[$path]["calendar"] = $calendar;
            } else {
                $orderedCalendars[] = $calendar;
            }
        }

        foreach ($ocProperties as $propertie) {
            $order = $propertie["order"];
            $calendar = $propertie["calendar"];
            array_splice($orderedCalendars, $order, 0, array($calendar));
        }

        $user = $this->userManager->get($userId);
        $server = Dav::getServerInstance($this->connection, $user);

        $i = 1;
        foreach ($orderedCalendars as $calendar) {
            $uri = $calendar["uri"];
            $path = "calendars/$userId/$uri";
            $order = (int) $calendar["id"] === $calendarId ? 0 : $i++;
            $properties = [CALENDAR_ORDER_KEY => $order];
            $server->updateProperties($path, $properties);
        }
        $this->logger->info("calendar $calendarId moved to top of list for user $userId");
        return new JSONResponse((object)[]);
    }

    /**
     * @NoAdminRequired
     * @NoCSRFRequired
     * 
     * @param string $mxRoomId
     * @param string $displayName
     * @param string[] $userIds (optional)
     * @return JSONResponse
     */
    public function createAndShare(string $mxRoomId, string $displayName, array $userIds = []) {
        $userId = $this->userId;
        $calendarUri = $this->computeIdFromMxRoomId($mxRoomId);
        $calendarId = $this->create($userId, $calendarUri, $displayName);
        $userIds[] = $this->userId;
        return $this->share($userId, $calendarId, $mxRoomId, $displayName, $userIds);
    }

    /**
     * @NoAdminRequired
     * @NoCSRFRequired
     * 
     * @param string $userId
     * @param int $calendarId
     * @param string $mxRoomId
     * @param string $displayName
     * @param string[] $userIds (optional)
     * @return JSONResponse
     */
    public function share(string $userId, int $calendarId, string $mxRoomId, string $displayName, array $userIds = []) {
        $ownerId = $this->getUserIdFromCalendarId($calendarId);
        if (is_null($ownerId)) {
            $message = "calendar $calendarId not found, can't share it";
            $this->logger->warning($message);
            return new JSONResponse(["message" => $message], Http::STATUS_NOT_FOUND);
        }
        if ($ownerId !== $userId) {
            $message = "calendar $calendarId is not owned by $userId, can't share it";
            $this->logger->warning($message);
            return new JSONResponse(["message" => $message], Http::STATUS_FORBIDDEN);
        }
        $groupId = $this->computeIdFromMxRoomId($mxRoomId);
        try {
            $this->createGroup($groupId, $displayName);
        } catch (GenericException $e) {
            return new JSONResponse(["message" => $e->getMessage()], $e->getHTTPCode());
        }
        # workaround for an upstream bug: users must be added to the group before
        # sharing the calendar to avoid it appearing empty when its members are listed later
        $this->addUsersToGroup($groupId, $userIds, $ownerId);
        $add = [
            array(
                "href" => "principal:principals/groups/$groupId",
                "commonName" => null,
                "summary" => null,
                "readOnly" => false,
            )
        ];
        try {
            $this->updateShares($calendarId, $add);
        } catch (GenericException | NotFound $e) {
            return new JSONResponse(["message" => $e->getMessage()], $e->getHTTPCode());
        }
        $this->renameForGroupMembers($groupId, $calendarId, $displayName);
        $calendar = $this->getFormatedCalendar($calendarId);
        return new JSONResponse($calendar);
    }

    /**
     * @NoAdminRequired
     * @NoCSRFRequired
     * 
     * @param int[] $calendarIds
     * @param string $mxRoomId
     * @param bool $deleteGroup (optional)
     * @return JSONResponse
     */
    public function unShare(array $calendarIds, string $mxRoomId, bool $deleteGroup = False) {
        $groupId = $this->computeIdFromMxRoomId($mxRoomId);
        foreach ($calendarIds as $calendarId) {
            if ($this->getUserIdFromCalendarId($calendarId) === $this->userId) {
                $this->delete($calendarId);
            } else {
                $remove = ["principal:principals/groups/$groupId"];
                $this->updateShares($calendarId, [], $remove);
            }
        }
        if ($deleteGroup) {
            try {
                $this->deleteGroup($groupId);
            } catch (GenericException $e) {
                return new JSONResponse(["message" => $e->getMessage()], $e->getHTTPCode());
            }
        }
        return new JSONResponse((object)[]);
    }

    /**
     * @NoAdminRequired
     * @NoCSRFRequired
     * 
     * @param string $userId
     * @param string $mxRoomId
     * @param int[] $calendarIds
     * @param string $displayName
     * @return JSONResponse
     */
    public function addUser(string $userId, string $mxRoomId, array $calendarIds, string $displayName) {
        $groupId = $this->computeIdFromMxRoomId($mxRoomId);
        foreach ($calendarIds as $calendarId) {
            $ownerId = $this->getUserIdFromCalendarId($calendarId);
            $this->addUsersToGroup($groupId, [$userId], $ownerId);
            try {
                $this->renameForUser($userId, $calendarId, $displayName);
            } catch (NotFound $e) {
                $this->logger->warning($e->getMessage());
            }
        }
        return new JSONResponse((object)[]);
    }

    /**
     * @NoAdminRequired
     * @NoCSRFRequired
     * 
     * @param string $userId
     * @param string $mxRoomId
     * @return JSONResponse
     */
    public function removeUser(string $userId, string $mxRoomId) {
        $groupId = $this->computeIdFromMxRoomId($mxRoomId);
        $this->removeUserFromGroup($groupId, $userId);
        return new JSONResponse((object)[]);
    }

    /**
     * @NoAdminRequired
     * @NoCSRFRequired
     * 
     * @param int[] $calendarIds
     * @param string $mxRoomId
     * @param string $displayName
     * @return JSONResponse
     */
    public function rename(array $calendarIds, string $mxRoomId, string $displayName) {
        $groupId = $this->computeIdFromMxRoomId($mxRoomId);
        $this->renameGroup($groupId, $displayName);
        foreach ($calendarIds as $calendarId) {
            $this->renameForGroupMembers($groupId, $calendarId, $displayName);
        }
        return new JSONResponse((object)[]);
    }

    /**
     * @param int $calendarId
     * @return array
     */
    private function getFormatedCalendar(int $calendarId) {
        $calendar = $this->caldav->getCalendarById($calendarId);
        return [
            "id" => (int) $calendar["id"],
            "components" => $calendar[SUPPORTED_CALENDAR_COMPONENT_SET_KEY]->getValue(),
            "is_personal" => $this->getUserIdFromCalendarId($calendarId) !== $this->userId
        ];
    }

    /**
     * @param string $userId
     * @param int $calendarId
     * @return JSONResponse
     */
    private function getDisplayName(string $userId, int $calendarId) {
        $user = $this->userManager->get($userId);
        $server = Dav::getServerInstance($this->connection, $user);
        $propertyNames = [DISPLAYNAME_KEY];
        $principalUri = "principals/users/$userId";
        $calendars = $this->caldav->getCalendarsForUser($principalUri);
        foreach ($calendars as $calendar) {
            if ((int) $calendar["id"] !== $calendarId) {
                continue;
            }
            $uri = $calendar["uri"];
            $path = "calendars/$userId/$uri";
            $properties = $server->getProperties($path, $propertyNames);
            return $properties[DISPLAYNAME_KEY];
        }
        $message = "calendar $calendarId not available for user $userId, can't get displayname";
        $this->logger->warning($message);
        throw new GenericException($message, Http::STATUS_FORBIDDEN);
    }

    /**
     * @param string $userId
     * @param string $calendarUri
     * @param string $displayName
     * @return int
     */
    private function create(string $userId, string $calendarUri, string $displayName) {
        $server = Dav::getServerInstance();
        $path = "calendars/$userId/$calendarUri";
        if ($server->tree->nodeExists($path)) {
            $this->logger->warning("calendar $path already exists");
            return $this->getCalendarIdFromUri($userId, $calendarUri);
        }
        $principalUri = "principals/users/$userId";
        $properties = [DISPLAYNAME_KEY => $displayName];
        $calendarId = $this->caldav->createCalendar($principalUri, $calendarUri, $properties);
        $this->logger->info("calendar $calendarId ($displayName) created");
        return $calendarId;
    }

    /**
     * @param int $calendarId
     * @return void
     */
    private function delete(int $calendarId) {
        if (is_null($this->caldav->getCalendarById($calendarId))) {
            $this->logger->warning("calendar $calendarId no found, can't delete it");
            return;
        }
        list($major,) = Util::getVersion();
        if ($major > 21) {
            $this->caldav->deleteCalendar($calendarId, true);
        } else {
            $this->caldav->deleteCalendar($calendarId);
        }
        $this->logger->info("calendar $calendarId deleted");
    }

    /**
     * @param int $calendarId
     * @param array $add
     * @param array $remove
     * @return void
     * @throws GenericException
     * @throws Sabre\DAV\Exception\NotFound
     */
    private function updateShares(int $calendarId, array $add = [], array $remove = []) {
        $server = Dav::getServerInstance();
        $userId = $this->getUserIdFromCalendarId($calendarId);
        if (is_null($userId)) {
            if ($add) {
                $exception = new GenericException("no calendar $calendarId to add a share to");
                $this->logger->error($exception->getMessage(), ["exception" => $exception]);
                throw $exception;
            }
            $this->logger->warning("no calendar $calendarId to remove a share to");
            return;
        }
        $calendar = $this->caldav->getCalendarById($calendarId);
        $uri = $calendar["uri"];
        $path = "calendars/$userId/$uri";
        $node = $server->tree->getNodeForPath($path);
        $node->updateShares($add, $remove);
        $this->logger->info("share(s) for calendar $calendarId updated (add: {add} | remove: {remove})", [
            "add" => json_encode($add, JSON_UNESCAPED_SLASHES), "remove" => json_encode($remove, JSON_UNESCAPED_SLASHES)
        ]);
    }

    /**
     * @param string $groupId
     * @param string $displayName
     * @return void
     * @throws GenericException
     */
    private function createGroup(string $groupId, string $displayName) {
        if ($this->groupManager->groupExists($groupId)) {
            $this->logger->warning("group $groupId already exists");
            return;
        }
        $group = $this->groupManager->createGroup($groupId);
        if (!$group instanceof IGroup) {
            $exception = new GenericException("can't create $groupId");
            $this->logger->error($exception->getMessage(), ["exception" => $exception]);
            throw $exception;
        }
        $group->setDisplayName($displayName);
        $this->logger->info("group $groupId ($displayName) created");
    }

    /**
     * @param string $groupId
     * @return void
     */
    private function deleteGroup(string $groupId) {
        $group = $this->groupManager->get($groupId);
        if (is_null($group)) {
            $this->logger->warning("group $groupId no found, can't delete it");
            return;
        }
        if (!$group->delete()) {
            $exception = new GenericException("can't delete group $groupId");
            $this->logger->error($exception->getMessage(), ["exception" => $exception]);
            throw $exception;
        }
        $this->logger->info("group $groupId deleted");
    }

    /**
     * @param string $groupId
     * @param string $displayName
     * @return void
     */
    private function renameGroup(string $groupId, string $displayName) {
        $group = $this->groupManager->get($groupId);
        if (is_null($group)) {
            $this->logger->warning("group $groupId no found, can't rename it");
            return;
        }
        $group->setDisplayName($displayName);
        $this->logger->info("group $groupId renamed to $displayName");
    }

    /**
     * @param string $groupId
     * @param string[] $userIds
     * @param string $ownerId
     * @return void
     */
    private function addUsersToGroup(string $groupId, array $userIds, string $ownerId) {
        $group = $this->groupManager->get($groupId);
        if (is_null($group)) {
            $this->logger->warning("group $groupId no found, can't add users");
            return;
        }
        foreach ($userIds as $userId) {
            # never add calendar owner other than the service account to group
            if ($userId === $ownerId and $ownerId !== $this->userId) {
                $this->logger->info("user $userId is the calendar owner, addition to group $groupId skipped");
                continue;
            }
            $user = $this->userManager->get($userId);
            if (is_null($user)) {
                $this->logger->warning("user $userId no found, can't add it to group $groupId");
                continue;
            }
            $group->addUser($user);
            $this->logger->info("user $userId added to group $groupId");
        }
    }

    /**
     * @param string $groupId
     * @param string $userId
     * @return void
     */
    private function removeUserFromGroup(string $groupId, string $userId) {
        $group = $this->groupManager->get($groupId);
        if (is_null($group)) {
            $this->logger->warning("group $groupId no found, can't remove user");
            return;
        }
        $user = $this->userManager->get($userId);
        if (is_null($user)) {
            $this->logger->warning("user $userId no found, can't remove it from group $groupId");
            return;
        }
        $group->removeUser($user);
        $this->logger->info("user $userId remove from group $groupId");
    }

    /**
     * @param string $groupId
     * @param int $calendarId
     * @param string $displayName
     * @return void
     */
    private function renameForGroupMembers(string $groupId, int $calendarId, string $displayName) {
        $group = $this->groupManager->get($groupId);
        if (is_null($group)) {
            $this->logger->warning("group $groupId no found, can't rename calendar $calendarId for its members");
            return;
        }
        $users = $group->getUsers();
        foreach ($users as $user) {
            $userId = $user->getUID();
            try {
                $this->renameForUser($userId, $calendarId, $displayName);
            } catch (NotFound $e) {
                $this->logger->warning($e->getMessage());
            }
        }
    }

    /**
     * @param string $userId
     * @param int $calendarId
     * @param string $displayName
     * @return void
     * @throws GenericException
     */
    private function renameForUser(string $userId, int $calendarId, string $displayName) {
        $user = $this->userManager->get($userId);
        if (is_null($user)) {
            $this->logger->warning("user $userId no found, can't rename calendar $calendarId for them");
            return;
        }
        $server = Dav::getServerInstance($this->connection, $user);
        $calendar = $this->caldav->getCalendarById($calendarId);
        if (is_null($calendar)) {
            $this->logger->warning("calendar $calendarId no found, can't rename it for user $userId");
            return;
        }
        list(, $ownerId) = Uri\split($calendar["principaluri"]);
        # never rename a personal calendar other than those of the service account
        if ($ownerId === $userId and $ownerId !== $this->userId) {
            return;
        }
        $calendarUri = $ownerId === $userId ? $calendar["uri"] : $this->computeUriForSharedCalendar($calendar["uri"], $ownerId);
        $path = "calendars/$userId/$calendarUri";
        $properties = [DISPLAYNAME_KEY => $displayName];
        $result = $server->updateProperties($path, $properties);
        if (!in_array($result[DISPLAYNAME_KEY], [200, 204])) {
            $exception = new GenericException("can't rename calendar with URI $calendarUri for user $userId");
            $this->logger->error($exception->getMessage(), ["exception" => $exception]);
            throw $exception;
        }
        $this->logger->info("calendar $calendarId renamed to $displayName for user $userId");
    }

    /**
     * @param int $calendarId
     * @return string|null
     */
    private function getUserIdFromCalendarId(int $calendarId) {
        $calendar = $this->caldav->getCalendarById($calendarId);
        if (is_null($calendar)) {
            $this->logger->warning("calendar $calendarId no found, can't parse user ID");
            return;
        }
        $principalUri = $calendar["principaluri"];
        list(, $userId) = Uri\split($principalUri);
        return $userId;
    }

    /**
     * @param string $userId
     * @param string $calendarUri
     * @return int|null
     */
    private function getCalendarIdFromUri(string $userId, string $calendarUri) {
        $principalUri = "principals/users/$userId";
        $calendar = $this->caldav->getCalendarByUri($principalUri, $calendarUri);
        if (is_null($calendar)) {
            $this->logger->warning("calendar $calendarUri owned by $userId no found, can't get ID");
            return;
        }
        return (int) $calendar["id"];
    }

    /**
     * @param string $calendarUri
     * @param string $ownerId
     * @return string
     */
    private function computeUriForSharedCalendar(string $calendarUri, string $ownerId) {
        return $calendarUri . "_shared_by_" . $ownerId;
    }

    /**
     * @param string $mxRoomId
     * @return string
     */
    private function computeIdFromMxRoomId(string $mxRoomId) {
        return hash("sha256", $mxRoomId);
    }
}