<?php
/**
 * @author Björn Schießle <bjoern@schiessle.org>
 * @author Joas Schilling <coding@schilljs.com>
 * @author phisch <git@philippschaffrath.de>
 * @author Roeland Jago Douma <rullzer@owncloud.com>
 * @author Vincent Petry <pvince81@owncloud.com>
 * @author Piotr Mrowczynski <piotr@owncloud.com>
 *
 * @copyright Copyright (c) 2018, ownCloud GmbH
 * @license AGPL-3.0
 *
 * This code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License, version 3,
 * as published by the Free Software Foundation.
 *
 * 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, version 3,
 * along with this program.  If not, see <http://www.gnu.org/licenses/>
 *
 */
namespace OC\Share20;

use OCP\Files\File;
use OCP\Share\IAttributes;
use OCP\Share\IShare;
use OCP\Share\IShareProvider;
use OC\Share20\Exception\InvalidShare;
use OC\Share20\Exception\ProviderException;
use OCP\Share\Exceptions\ShareNotFound;
use OC\Share20\Exception\BackendError;
use OCP\DB\QueryBuilder\IQueryBuilder;
use OCP\IGroup;
use OCP\IGroupManager;
use OCP\IUserManager;
use OCP\Files\IRootFolder;
use OCP\IDBConnection;
use OCP\Files\Node;

/**
 * Class DefaultShareProvider
 *
 * @package OC\Share20
 */
class DefaultShareProvider implements IShareProvider {
	// Special share type for user modified group shares
	public const SHARE_TYPE_USERGROUP = 2;

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

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

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

	/** @var IRootFolder */
	private $rootFolder;

	/**
	 * DefaultShareProvider constructor.
	 *
	 * @param IDBConnection $connection
	 * @param IUserManager $userManager
	 * @param IGroupManager $groupManager
	 * @param IRootFolder $rootFolder
	 */
	public function __construct(
		IDBConnection $connection,
		IUserManager $userManager,
		IGroupManager $groupManager,
		IRootFolder $rootFolder
	) {
		$this->dbConn = $connection;
		$this->userManager = $userManager;
		$this->groupManager = $groupManager;
		$this->rootFolder = $rootFolder;
	}

	/**
	 * Return the identifier of this provider.
	 *
	 * @return string Containing only [a-zA-Z0-9]
	 */
	public function identifier() {
		return 'ocinternal';
	}

	/**
	 * Share a path
	 *
	 * @param \OCP\Share\IShare $share
	 * @return \OCP\Share\IShare The share object
	 * @throws ShareNotFound
	 * @throws InvalidArgumentException if the share validation failed
	 * @throws \Exception
	 */
	public function create(\OCP\Share\IShare $share) {
		$this->validate($share);
		$qb = $this->dbConn->getQueryBuilder();

		$qb->insert('share');
		$qb->setValue('share_type', $qb->createNamedParameter($share->getShareType()));

		//If an expiration date is set store it
		if ($share->getExpirationDate() !== null) {
			$qb->setValue('expiration', $qb->createNamedParameter($share->getExpirationDate(), 'datetime'));
		}

		if ($share->getShareType() === \OCP\Share::SHARE_TYPE_USER) {
			//Set the UID of the user we share with
			$qb->setValue('share_with', $qb->createNamedParameter($share->getSharedWith()));
			$qb->setValue('accepted', $share->getState());
		} elseif ($share->getShareType() === \OCP\Share::SHARE_TYPE_GROUP) {
			//Set the GID of the group we share with
			$qb->setValue('share_with', $qb->createNamedParameter($share->getSharedWith()));
			$qb->setValue('accepted', $share->getState());
		} elseif ($share->getShareType() === \OCP\Share::SHARE_TYPE_LINK) {
			//Set the token of the share
			$qb->setValue('token', $qb->createNamedParameter($share->getToken()));

			//If a password is set store it
			if ($share->getPassword() !== null) {
				$qb->setValue('share_with', $qb->createNamedParameter($share->getPassword()));
			}

			if (\method_exists($share, 'getParent')) {
				/* @phan-suppress-next-line PhanUndeclaredMethod */
				$qb->setValue('parent', $qb->createNamedParameter($share->getParent()));
			}

			// Set user-defined name
			$qb->setValue('share_name', $qb->createNamedParameter($share->getName()));
		} else {
			throw new \Exception('invalid share type!');
		}

		// Set what is shares
		$qb->setValue('item_type', $qb->createParameter('itemType'));
		if ($share->getNode() instanceof \OCP\Files\File) {
			$qb->setParameter('itemType', 'file');
		} else {
			$qb->setParameter('itemType', 'folder');
		}

		// Set the file id
		$qb->setValue('item_source', $qb->createNamedParameter($share->getNode()->getId()));
		$qb->setValue('file_source', $qb->createNamedParameter($share->getNode()->getId()));

		// set the permissions
		$qb->setValue('permissions', $qb->createNamedParameter($share->getPermissions()));

		// set share attributes
		$shareAttributes = $this->formatShareAttributes(
			$share->getAttributes()
		);
		$qb->setValue('attributes', $qb->createNamedParameter($shareAttributes));

		// Set who created this share
		$qb->setValue('uid_initiator', $qb->createNamedParameter($share->getSharedBy()));

		// Set who is the owner of this file/folder (and this the owner of the share)
		$qb->setValue('uid_owner', $qb->createNamedParameter($share->getShareOwner()));

		// Set the file target
		$qb->setValue('file_target', $qb->createNamedParameter($share->getTarget()));

		// Set the time this share was created
		$qb->setValue('stime', $qb->createNamedParameter(\time()));

		// insert the data and fetch the id of the share
		$this->dbConn->beginTransaction();
		$qb->execute();
		$id = $this->dbConn->lastInsertId('*PREFIX*share');

		// Now fetch the inserted share and create a complete share object
		$qb = $this->dbConn->getQueryBuilder();
		$qb->select('*')
			->from('share')
			->where($qb->expr()->eq('id', $qb->createNamedParameter($id)));

		$cursor = $qb->execute();
		$data = $cursor->fetch();
		$this->dbConn->commit();
		$cursor->closeCursor();

		if ($data === false) {
			throw new ShareNotFound();
		}

		$share = $this->createShare($data);
		return $share;
	}

	/**
	 * Update a share
	 *
	 * @param \OCP\Share\IShare $share
	 * @return \OCP\Share\IShare The share object
	 * @throws InvalidArgumentException if the share validation failed
	 */
	public function update(\OCP\Share\IShare $share) {
		$this->validate($share);

		$shareAttributes = $this->formatShareAttributes(
			$share->getAttributes()
		);

		if ($share->getShareType() === \OCP\Share::SHARE_TYPE_USER) {
			/*
			 * We allow updating the recipient on user shares.
			 */
			$qb = $this->dbConn->getQueryBuilder();
			$qb->update('share')
				->where($qb->expr()->eq('id', $qb->createNamedParameter($share->getId())))
				->set('share_with', $qb->createNamedParameter($share->getSharedWith()))
				->set('uid_owner', $qb->createNamedParameter($share->getShareOwner()))
				->set('uid_initiator', $qb->createNamedParameter($share->getSharedBy()))
				->set('permissions', $qb->createNamedParameter($share->getPermissions()))
				->set('expiration', $qb->createNamedParameter($share->getExpirationDate(), IQueryBuilder::PARAM_DATE))
				->set('attributes', $qb->createNamedParameter($shareAttributes))
				->set('item_source', $qb->createNamedParameter($share->getNode()->getId()))
				->set('file_source', $qb->createNamedParameter($share->getNode()->getId()))
				->set('accepted', $qb->createNamedParameter($share->getState()))
				->set('mail_send', $qb->createNamedParameter((int) $share->getMailSend()))
				->execute();
		} elseif ($share->getShareType() === \OCP\Share::SHARE_TYPE_GROUP) {
			$qb = $this->dbConn->getQueryBuilder();
			$qb->update('share')
				->where($qb->expr()->eq('id', $qb->createNamedParameter($share->getId())))
				->set('uid_owner', $qb->createNamedParameter($share->getShareOwner()))
				->set('uid_initiator', $qb->createNamedParameter($share->getSharedBy()))
				->set('permissions', $qb->createNamedParameter($share->getPermissions()))
				->set('expiration', $qb->createNamedParameter($share->getExpirationDate(), IQueryBuilder::PARAM_DATE))
				->set('attributes', $qb->createNamedParameter($shareAttributes))
				->set('item_source', $qb->createNamedParameter($share->getNode()->getId()))
				->set('file_source', $qb->createNamedParameter($share->getNode()->getId()))
				->set('accepted', $qb->createNamedParameter($share->getState()))
				->set('mail_send', $qb->createNamedParameter((int) $share->getMailSend()))
				->execute();

			/*
			 * Update all user defined group shares
			 */
			$qb = $this->dbConn->getQueryBuilder();
			$qb->update('share')
				->where($qb->expr()->eq('parent', $qb->createNamedParameter($share->getId())))
				->andWhere($qb->expr()->neq('share_type', $qb->createNamedParameter(\OCP\Share::SHARE_TYPE_LINK)))  // links could be attached and must be excluded
				->set('uid_owner', $qb->createNamedParameter($share->getShareOwner()))
				->set('uid_initiator', $qb->createNamedParameter($share->getSharedBy()))
				->set('item_source', $qb->createNamedParameter($share->getNode()->getId()))
				->set('file_source', $qb->createNamedParameter($share->getNode()->getId()))
				->execute();

			/*
			 * Now update the permissions for all children
			 */
			$qb = $this->dbConn->getQueryBuilder();
			$qb->update('share')
				->where($qb->expr()->eq('parent', $qb->createNamedParameter($share->getId())))
				->andWhere($qb->expr()->neq('share_type', $qb->createNamedParameter(\OCP\Share::SHARE_TYPE_LINK)))  // links could be attached and must be excluded
				->set('permissions', $qb->createNamedParameter($share->getPermissions()))
				->set('expiration', $qb->createNamedParameter($share->getExpirationDate(), IQueryBuilder::PARAM_DATE))
				->set('attributes', $qb->createNamedParameter($shareAttributes))
				->execute();
		} elseif ($share->getShareType() === \OCP\Share::SHARE_TYPE_LINK) {
			$qb = $this->dbConn->getQueryBuilder();
			$qb->update('share')
				->where($qb->expr()->eq('id', $qb->createNamedParameter($share->getId())))
				->set('share_with', $qb->createNamedParameter($share->getPassword()))
				->set('uid_owner', $qb->createNamedParameter($share->getShareOwner()))
				->set('uid_initiator', $qb->createNamedParameter($share->getSharedBy()))
				->set('permissions', $qb->createNamedParameter($share->getPermissions()))
				->set('attributes', $qb->createNamedParameter($shareAttributes))
				->set('item_source', $qb->createNamedParameter($share->getNode()->getId()))
				->set('file_source', $qb->createNamedParameter($share->getNode()->getId()))
				->set('token', $qb->createNamedParameter($share->getToken()))
				->set('expiration', $qb->createNamedParameter($share->getExpirationDate(), IQueryBuilder::PARAM_DATE))
				->set('share_name', $qb->createNamedParameter($share->getName()))
				->execute();
		}

		return $share;
	}

	/**
	 * Get all children of this share
	 * FIXME: remove once https://github.com/owncloud/core/pull/21660 is in
	 *
	 * @param \OCP\Share\IShare $parent
	 * @return \OCP\Share\IShare[]
	 */
	public function getChildren(\OCP\Share\IShare $parent) {
		$children = [];

		$qb = $this->dbConn->getQueryBuilder();
		$qb->select('*')
			->from('share')
			->where($qb->expr()->eq('parent', $qb->createNamedParameter($parent->getId())))
			->andWhere(
				$qb->expr()->in(
					'share_type',
					$qb->createNamedParameter([
						\OCP\Share::SHARE_TYPE_USER,
						\OCP\Share::SHARE_TYPE_GROUP,
						\OCP\Share::SHARE_TYPE_LINK,
					], IQueryBuilder::PARAM_INT_ARRAY)
				)
			)
			->andWhere($qb->expr()->orX(
				$qb->expr()->eq('item_type', $qb->createNamedParameter('file')),
				$qb->expr()->eq('item_type', $qb->createNamedParameter('folder'))
			))
			->orderBy('id');

		$cursor = $qb->execute();
		while ($data = $cursor->fetch()) {
			$children[] = $this->createShare($data);
		}
		$cursor->closeCursor();

		return $children;
	}

	/**
	 * Delete a share
	 *
	 * @param \OCP\Share\IShare $share
	 */
	public function delete(\OCP\Share\IShare $share) {
		$qb = $this->dbConn->getQueryBuilder();
		$qb->delete('share')
			->where($qb->expr()->eq('id', $qb->createNamedParameter($share->getId())));

		/*
		 * If the share is a group share delete all possible
		 * user defined groups shares.
		 */
		if ($share->getShareType() === \OCP\Share::SHARE_TYPE_GROUP) {
			$qb->orWhere($qb->expr()->eq('parent', $qb->createNamedParameter($share->getId())));
		}

		$qb->execute();
	}

	/**
	 * Unshare a share from the recipient. If this is a group share
	 * this means we need a special entry in the share db.
	 *
	 * @param \OCP\Share\IShare $share
	 * @param string $recipient UserId of recipient
	 * @throws BackendError
	 * @throws ProviderException
	 */
	public function deleteFromSelf(\OCP\Share\IShare $share, $recipient) {
		if ($share->getShareType() === \OCP\Share::SHARE_TYPE_GROUP || $share->getShareType() === \OCP\Share::SHARE_TYPE_USER) {
			$share->setState(\OCP\Share::STATE_REJECTED);
			$this->updateForRecipient($share, $recipient);
		} else {
			throw new ProviderException('Invalid share type ' . $share->getShareType());
		}
	}

	/**
	 * @inheritdoc
	 */
	public function move(\OCP\Share\IShare $share, $recipient) {
		return $this->updateForRecipient($share, $recipient);
	}

	/**
	 * @inheritdoc
	 */
	public function updateForRecipient(\OCP\Share\IShare $share, $recipient) {
		if ($share->getShareType() === \OCP\Share::SHARE_TYPE_USER) {
			if ($share->getSharedWith() !== $recipient) {
				throw new ProviderException('Recipient does not match');
			}

			// Just update the target
			$qb = $this->dbConn->getQueryBuilder();
			$qb->update('share')
				->set('accepted', $qb->createNamedParameter($share->getState()))
				->set('file_target', $qb->createNamedParameter($share->getTarget()))
				->where($qb->expr()->eq('id', $qb->createNamedParameter($share->getId())))
				->execute();
		} elseif ($share->getShareType() === \OCP\Share::SHARE_TYPE_GROUP) {
			$group = $this->groupManager->get($share->getSharedWith());
			$user = $this->userManager->get($recipient);

			if ($group === null) {
				throw new ProviderException('Group "' . $share->getSharedWith() . '" does not exist');
			}

			if (!$group->inGroup($user)) {
				throw new ProviderException('Recipient not in receiving group');
			}

			$node = $share->getNode();

			$shareAttributes = $this->formatShareAttributes(
				$share->getAttributes()
			);

			// shareExpiration is either null or a formatted date
			$shareExpiration = $share->getExpirationDate();
			if ($shareExpiration !== null) {
				$shareExpiration = $shareExpiration->format('Y-m-d 00:00:00');
			}

			// Check if there is a usergroup share
			$this->dbConn->upsert(
				'*PREFIX*share',
				[
					'share_type' => self::SHARE_TYPE_USERGROUP,
					'share_with' => $recipient,
					'parent' => $share->getId(),
					'uid_owner' => $share->getShareOwner(),
					'uid_initiator' => $share->getSharedBy(),
					'item_type' => $node instanceof File ? 'file' : 'folder',
					'item_source' => $node->getId(),
					'file_source' => $node->getId(),
					'file_target' => $share->getTarget(),
					'attributes' => $shareAttributes,
					'permissions' => $share->getPermissions(),
					'expiration' => $shareExpiration,
					'stime' => $share->getShareTime()->getTimestamp(),
					'accepted' => $share->getState(),
				],
				[
					'share_type',
					'share_with',
					'parent'
				]
			);
		} else {
			throw new ProviderException('Can\'t update share of recipient for share type ' . $share->getShareType());
		}

		return $share;
	}

	/**
	 * @inheritdoc
	 */
	public function getAllSharesBy($userId, $shareTypes, $nodeIDs, $reshares) {
		$shares = [];
		$qb = $this->dbConn->getQueryBuilder();

		$qb->select('*')
			->from('share')
			->andWhere($qb->expr()->orX(
				$qb->expr()->eq('item_type', $qb->createNamedParameter('file')),
				$qb->expr()->eq('item_type', $qb->createNamedParameter('folder'))
			));

		$orX = $qb->expr()->orX();

		foreach ($shareTypes as $shareType) {
			$orX->add($qb->expr()->eq('share_type', $qb->createNamedParameter($shareType)));
		}

		$qb->andWhere($orX);

		/**
		 * Reshares for this user are shares where they are the owner.
		 */
		if ($reshares === false) {
			$qb->andWhere($qb->expr()->eq('uid_initiator', $qb->createNamedParameter($userId)));
		} else {
			$qb->andWhere(
				$qb->expr()->orX(
					$qb->expr()->eq('uid_owner', $qb->createNamedParameter($userId)),
					$qb->expr()->eq('uid_initiator', $qb->createNamedParameter($userId))
				)
			);
		}

		$qb->andWhere($qb->expr()->in('file_source', $qb->createParameter('file_source_ids')));

		$qb->orderBy('id');

		$nodeIdsChunks = \array_chunk($nodeIDs, 900);
		foreach ($nodeIdsChunks as $nodeIdsChunk) {
			$qb->setParameter('file_source_ids', $nodeIdsChunk, IQueryBuilder::PARAM_INT_ARRAY);

			$cursor = $qb->execute();
			while ($data = $cursor->fetch()) {
				$shares[] = $this->createShare($data);
			}
			$cursor->closeCursor();
		}

		return $shares;
	}

	/**
	 * @inheritdoc
	 */
	public function getSharesBy($userId, $shareType, $node, $reshares, $limit, $offset) {
		$qb = $this->dbConn->getQueryBuilder();
		$qb->select('*')
			->from('share')
			->andWhere($qb->expr()->orX(
				$qb->expr()->eq('item_type', $qb->createNamedParameter('file')),
				$qb->expr()->eq('item_type', $qb->createNamedParameter('folder'))
			));

		$qb->andWhere($qb->expr()->eq('share_type', $qb->createNamedParameter($shareType)));

		/**
		 * Reshares for this user are shares where they are the owner.
		 */
		if ($reshares === false) {
			$qb->andWhere($qb->expr()->eq('uid_initiator', $qb->createNamedParameter($userId)));
		} else {
			$qb->andWhere(
				$qb->expr()->orX(
					$qb->expr()->eq('uid_owner', $qb->createNamedParameter($userId)),
					$qb->expr()->eq('uid_initiator', $qb->createNamedParameter($userId))
				)
			);
		}

		if ($node !== null) {
			$qb->andWhere($qb->expr()->eq('file_source', $qb->createNamedParameter($node->getId())));
		}

		if ($limit !== -1) {
			$qb->setMaxResults($limit);
		}

		$qb->setFirstResult($offset);
		$qb->orderBy('id');

		$cursor = $qb->execute();
		$shares = [];
		while ($data = $cursor->fetch()) {
			$shares[] = $this->createShare($data);
		}
		$cursor->closeCursor();

		return $shares;
	}

	/**
	 * @inheritdoc
	 */
	public function getShareById($id, $recipientId = null) {
		if (!ctype_digit($id)) {
			// share id is defined as a field of type integer
			// if someone calls the API asking for a share id like "abc"
			// then there is no point trying to query the database,
			// and, depending on the database, the query may throw an exception
			// with a message like "invalid input syntax for type integer"
			// So throw ShareNotFound now.
			throw new ShareNotFound();
		}
		$qb = $this->dbConn->getQueryBuilder();

		$qb->select('*')
			->from('share')
			->where($qb->expr()->eq('id', $qb->createNamedParameter($id)))
			->andWhere(
				$qb->expr()->in(
					'share_type',
					$qb->createNamedParameter([
						\OCP\Share::SHARE_TYPE_USER,
						\OCP\Share::SHARE_TYPE_GROUP,
						\OCP\Share::SHARE_TYPE_LINK,
					], IQueryBuilder::PARAM_INT_ARRAY)
				)
			)
			->andWhere($qb->expr()->orX(
				$qb->expr()->eq('item_type', $qb->createNamedParameter('file')),
				$qb->expr()->eq('item_type', $qb->createNamedParameter('folder'))
			));

		$cursor = $qb->execute();
		$data = $cursor->fetch();
		$cursor->closeCursor();

		if ($data === false) {
			throw new ShareNotFound();
		}

		try {
			$share = $this->createShare($data);
		} catch (InvalidShare $e) {
			throw new ShareNotFound();
		}

		// If the recipient is set for a group share resolve to that user
		if ($recipientId !== null && $share->getShareType() === \OCP\Share::SHARE_TYPE_GROUP) {
			$resolvedShares = $this->resolveGroupShares([$share], $recipientId);
			if (\count($resolvedShares) === 1) {
				// If we pass to resolveGroupShares() an with one element,
				// we expect to receive exactly one element, otherwise it is error
				$share = $resolvedShares[0];
			} else {
				throw new ProviderException("ResolveGroupShares() returned wrong result");
			}
		}

		return $share;
	}

	/**
	 * Get shares for a given path
	 *
	 * @param \OCP\Files\Node $path
	 * @return \OCP\Share\IShare[]
	 */
	public function getSharesByPath(Node $path) {
		$qb = $this->dbConn->getQueryBuilder();

		$cursor = $qb->select('*')
			->from('share')
			->andWhere($qb->expr()->eq('file_source', $qb->createNamedParameter($path->getId())))
			->andWhere(
				$qb->expr()->orX(
					$qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share::SHARE_TYPE_USER)),
					$qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share::SHARE_TYPE_GROUP))
				)
			)
			->andWhere($qb->expr()->orX(
				$qb->expr()->eq('item_type', $qb->createNamedParameter('file')),
				$qb->expr()->eq('item_type', $qb->createNamedParameter('folder'))
			))
			->execute();

		$shares = [];
		while ($data = $cursor->fetch()) {
			$shares[] = $this->createShare($data);
		}
		$cursor->closeCursor();

		return $shares;
	}

	/**
	 * Returns whether the given database result can be interpreted as
	 * a share with accessible file (not trashed, not deleted)
	 */
	private function isAccessibleResult($data) {
		// exclude shares leading to deleted file entries
		if ($data['fileid'] === null) {
			return false;
		}

		// exclude shares leading to trashbin on home storages
		$pathSections = \explode('/', $data['path'], 2);
		// FIXME: would not detect rare md5'd home storage case properly
		$storagePrefix = \explode(':', $data['storage_string_id'], 2)[0];
		if ($pathSections[0] !== 'files' && \in_array($storagePrefix, ['home', 'object'], true)) {
			return false;
		}
		return true;
	}

	/*
	 * Get shared with user shares for the given userId and node
	 *
	 * @param string $userId
	 * @param Node|null $node
	 * @return DB\QueryBuilder\IQueryBuilder $qb
	 */
	public function getSharedWithUserQuery($userId, $node) {
		$qb = $this->dbConn->getQueryBuilder();
		$qb->select('s.*', 'f.fileid', 'f.path')
			->selectAlias('st.id', 'storage_string_id')
			->from('share', 's')
			->leftJoin('s', 'filecache', 'f', $qb->expr()->eq('s.file_source', 'f.fileid'))
			->leftJoin('f', 'storages', 'st', $qb->expr()->eq('f.storage', 'st.numeric_id'));

		// Order by id
		$qb->orderBy('s.id');

		$qb->where($qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share::SHARE_TYPE_USER)))
			->andWhere($qb->expr()->eq('share_with', $qb->createNamedParameter($userId)))
			->andWhere($qb->expr()->orX(
				$qb->expr()->eq('item_type', $qb->createNamedParameter('file')),
				$qb->expr()->eq('item_type', $qb->createNamedParameter('folder'))
			));

		// Filter by node if provided
		if ($node !== null) {
			$qb->andWhere($qb->expr()->eq('file_source', $qb->createNamedParameter($node->getId())));
		}

		return $qb;
	}

	/*
	 * Get shared with group shares for the given groups and node
	 *
	 * @param IGroup[] $groups
	 * @param Node|null $node
	 * @return DB\QueryBuilder\IQueryBuilder $qb
	 */
	private function getSharedWithGroupQuery($groups, $node) {
		$qb = $this->dbConn->getQueryBuilder();
		$qb->select('s.*', 'f.fileid', 'f.path')
			->selectAlias('st.id', 'storage_string_id')
			->from('share', 's')
			->leftJoin('s', 'filecache', 'f', $qb->expr()->eq('s.file_source', 'f.fileid'))
			->leftJoin('f', 'storages', 'st', $qb->expr()->eq('f.storage', 'st.numeric_id'))
			->orderBy('s.id');

		// Filter by node if provided
		if ($node !== null) {
			$qb->andWhere($qb->expr()->eq('file_source', $qb->createNamedParameter($node->getId())));
		}

		$groups = \array_map(function (IGroup $group) {
			return $group->getGID();
		}, $groups);

		$qb->andWhere($qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share::SHARE_TYPE_GROUP)))
			->andWhere($qb->expr()->in('share_with', $qb->createNamedParameter(
				$groups,
				IQueryBuilder::PARAM_STR_ARRAY
			)))
			->andWhere($qb->expr()->orX(
				$qb->expr()->eq('item_type', $qb->createNamedParameter('file')),
				$qb->expr()->eq('item_type', $qb->createNamedParameter('folder'))
			));

		return $qb;
	}

	/*
	 * Get shared with group and shared with user shares for the given groups, userId and node
	 *
	 * @param IGroup[] $groups
	 * @param string $userId
	 * @param Node|null $node
	 * @return DB\QueryBuilder\IQueryBuilder $qb
	 */
	private function getSharedWithUserGroupQuery($groups, $userId, $node) {
		$qb = $this->dbConn->getQueryBuilder();
		$qb->select('s.*', 'f.fileid', 'f.path')
			->selectAlias('st.id', 'storage_string_id')
			->from('share', 's')
			->leftJoin('s', 'filecache', 'f', $qb->expr()->eq('s.file_source', 'f.fileid'))
			->leftJoin('f', 'storages', 'st', $qb->expr()->eq('f.storage', 'st.numeric_id'))
			->orderBy('s.id');

		// Filter by node if provided
		if ($node !== null) {
			$qb->andWhere($qb->expr()->eq('file_source', $qb->createNamedParameter($node->getId())));
		}

		$groups = \array_map(function (IGroup $group) {
			return $group->getGID();
		}, $groups);

		$qb->andWhere($qb->expr()->orX(
			$qb->expr()->andX(
				$qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share::SHARE_TYPE_GROUP)),
				$qb->expr()->in('share_with', $qb->createNamedParameter(
					$groups,
					IQueryBuilder::PARAM_STR_ARRAY
				))
			),
			$qb->expr()->andX(
				$qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share::SHARE_TYPE_USER)),
				$qb->expr()->eq('share_with', $qb->createNamedParameter($userId))
			)
		));

		return $qb;
	}

	/**
	 * @inheritdoc
	 */
	public function getSharedWith($userId, $shareType, $node, $limit, $offset) {
		/** @var Share[] $shares */
		$shares = [];

		if ($shareType === \OCP\Share::SHARE_TYPE_USER) {
			// Create SharedWithUser query
			$qb = $this->getSharedWithUserQuery($userId, $node);

			// Set limit and offset
			if ($limit !== -1) {
				$qb->setMaxResults($limit);
			}
			$qb->setFirstResult($offset);

			$cursor = $qb->execute();

			while ($data = $cursor->fetch()) {
				if ($this->isAccessibleResult($data)) {
					$shares[] = $this->createShare($data);
				}
			}
			$cursor->closeCursor();
		} elseif ($shareType === \OCP\Share::SHARE_TYPE_GROUP) {
			$user = $this->userManager->get($userId);
			$allGroups = $this->groupManager->getUserGroups($user, 'sharing');

			/** @var Share[] $shares2 */
			$shares2 = [];

			$start = 0;
			while (true) {
				$groups = \array_slice($allGroups, $start, 100);
				$start += 100;

				if ($groups === []) {
					break;
				}

				// Create SharedWithGroups query
				$qb = $this->getSharedWithGroupQuery($groups, $node);
				$qb->setFirstResult(0);

				if ($limit !== -1) {
					$qb->setMaxResults($limit - \count($shares));
				}

				$cursor = $qb->execute();
				while ($data = $cursor->fetch()) {
					if ($offset > 0) {
						$offset--;
						continue;
					}

					if ($this->isAccessibleResult($data)) {
						$shares2[] = $this->createShare($data);
					}
				}
				$cursor->closeCursor();
			}

			//Resolve all group shares to user specific shares
			if (!empty($shares2)) {
				$resolvedGroupShares = $this->resolveGroupShares($shares2, $userId);
				$shares = \array_merge($shares, $resolvedGroupShares);
			}
		} else {
			throw new BackendError('Invalid backend');
		}

		return $shares;
	}

	/**
	 * @inheritdoc
	 */
	public function getAllSharedWith($userId, $node) {
		// Create array of sharedWith objects (target user -> $userId or group of which user is a member
		$user = $this->userManager->get($userId);

		// Check if user is member of some groups and chunk them
		$allGroups = $this->groupManager->getUserGroups($user, 'sharing');

		// Make chunks
		$sharedWithGroupChunks = \array_chunk($allGroups, 100);

		// Check how many group chunks do we need
		$sharedWithGroupChunksNo = \count($sharedWithGroupChunks);

		// If there are not groups, query only user, if there are groups, query both
		$chunkedResults = [];
		if ($sharedWithGroupChunksNo === 0) {
			// There are no groups, query only for user
			$qb = $this->getSharedWithUserQuery($userId, $node);
			$cursor = $qb->execute();
			$chunkedResults[] = $cursor->fetchAll();
			$cursor->closeCursor();
		} else {
			// There are groups, query both for user and for groups
			$userSharesRetrieved = false;
			for ($chunkNo = 0; $chunkNo < $sharedWithGroupChunksNo; $chunkNo++) {
				// Get respective group chunk
				$groups = $sharedWithGroupChunks[$chunkNo];

				// Check if user shares were already retrieved
				// One cannot retrieve user shares multiple times, since it will result in duplicated
				// user shares with each query
				if ($userSharesRetrieved === false) {
					$qb = $this->getSharedWithUserGroupQuery($groups, $userId, $node);
					$userSharesRetrieved = true;
				} else {
					$qb = $this->getSharedWithGroupQuery($groups, $node);
				}
				$cursor = $qb->execute();
				$chunkedResults[] = $cursor->fetchAll();
				$cursor->closeCursor();
			}
		}

		$resolvedShares = [];
		$groupShares = [];
		foreach ($chunkedResults as $resultBatch) {
			foreach ($resultBatch as $data) {
				if ($this->isAccessibleResult($data)) {
					$share = $this->createShare($data);
					if ($share->getShareType() === \OCP\Share::SHARE_TYPE_GROUP) {
						$groupShares[] = $share;
					} else {
						$resolvedShares[] = $share;
					}
				}
			}
		}

		//Resolve all group shares to user specific shares
		if (!empty($groupShares)) {
			$resolvedGroupShares = $this->resolveGroupShares($groupShares, $userId);
			$resolvedShares = \array_merge($resolvedShares, $resolvedGroupShares);
		}

		return $resolvedShares;
	}

	/**
	 * Get a share by token
	 *
	 * @param string $token
	 * @return \OCP\Share\IShare
	 * @throws ShareNotFound
	 */
	public function getShareByToken($token) {
		$qb = $this->dbConn->getQueryBuilder();

		$cursor = $qb->select('*')
			->from('share')
			->where($qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share::SHARE_TYPE_LINK)))
			->andWhere($qb->expr()->eq('token', $qb->createNamedParameter($token)))
			->andWhere($qb->expr()->orX(
				$qb->expr()->eq('item_type', $qb->createNamedParameter('file')),
				$qb->expr()->eq('item_type', $qb->createNamedParameter('folder'))
			))
			->execute();

		$data = $cursor->fetch();

		if ($data === false) {
			throw new ShareNotFound();
		}

		try {
			$share = $this->createShare($data);
		} catch (InvalidShare $e) {
			throw new ShareNotFound();
		}

		return $share;
	}

	/**
	 * @inheritDoc
	 */
	public function getSharesWithInvalidFileid(int $limit) {
		$validShareTypes = [
			\OCP\Share::SHARE_TYPE_USER,
			\OCP\Share::SHARE_TYPE_GROUP,
			\OCP\Share::SHARE_TYPE_LINK,
		];
		// other share types aren't handled by this provider

		$qb = $this->dbConn->getQueryBuilder();

		$qb = $qb->select('s.*')
			->from('share', 's')
			->leftJoin('s', 'filecache', 'f', $qb->expr()->eq('s.file_source', 'f.fileid'))
			->where($qb->expr()->isNull('f.fileid'))
			->andWhere(
				$qb->expr()->in(
					'share_type',
					$qb->createNamedParameter($validShareTypes, IQueryBuilder::PARAM_INT_ARRAY)
				)
			)
			->orderBy('s.id');

		if ($limit >= 0) {
			$qb->setMaxResults($limit);
		}
		$cursor = $qb->execute();

		$shares = [];
		while ($data = $cursor->fetch()) {
			$shares[] = $this->createShare($data);
		}
		$cursor->closeCursor();

		return $shares;
	}

	/**
	 * Create a share object from an database row
	 *
	 * @param mixed[] $data
	 * @return \OCP\Share\IShare
	 * @throws InvalidShare
	 */
	private function createShare($data) {
		$share = new Share($this->rootFolder, $this->userManager);
		$share->setId($data['id'])
			->setShareType((int)$data['share_type'])
			->setPermissions((int)$data['permissions'])
			->setTarget($data['file_target'])
			->setMailSend((bool)$data['mail_send']);

		$shareTime = new \DateTime();
		$shareTime->setTimestamp((int)$data['stime']);
		$share->setShareTime($shareTime);

		if ($share->getShareType() === \OCP\Share::SHARE_TYPE_USER) {
			$share->setSharedWith($data['share_with']);
		} elseif ($share->getShareType() === \OCP\Share::SHARE_TYPE_GROUP) {
			$share->setSharedWith($data['share_with']);
		} elseif ($share->getShareType() === \OCP\Share::SHARE_TYPE_LINK) {
			$share->setPassword($data['share_with']);
			$share->setToken($data['token']);
		}

		$share = $this->updateShareAttributes($share, $data['attributes']);

		$share->setSharedBy($data['uid_initiator']);
		$share->setShareOwner($data['uid_owner']);

		$share->setNodeId((int)$data['file_source']);
		$share->setNodeType($data['item_type']);
		$share->setName($data['share_name']);
		$share->setState((int)$data['accepted']);

		if ($data['expiration'] !== null) {
			$expiration = \DateTime::createFromFormat('Y-m-d H:i:s', $data['expiration']);
			$share->setExpirationDate($expiration);
		}

		$share->setProviderId($this->identifier());

		return $share;
	}

	/**
	 * Will return two maps:
	 * - $chunkedShareIds responsible to split shareIds into chunks containing 100 elements
	 * 	 e.g. $chunkedShareIds { { "4", "52", "54",... }[100], { .. }[2] }[2]
	 *
	 * - $shareIdToShareMap responsible to split shareIds into chunks containing 100 elements
	 * 	 e.g. $shareIdToShareMap { "4" => IShare, "52" => IShare, "54" => IShare, ... }[102]
	 *
	 * @param \OCP\Share\IShare[] $shares
	 * @return array $chunkedSharesToMaps e.g { $chunkedShareIds, $shareIdToShareMap }[2]
	 */
	private function chunkSharesToMaps($shares) {
		$chunkedShareIds = [];
		$shareIdToShareMap = [];
		$chunkId = 0;
		$shareNo = 0;
		foreach ($shares as $share) {
			// Map unique shareIds to IShare
			$shareId = $share->getId();
			$shareIdToShareMap[$shareId] = $share;

			// Chunk shareId array
			if ($shareNo >= 100) {
				// If we have over 100 shares in the array, start next chunk
				$shareNo = 0;
				$chunkId++;
			} else {
				// Increase number of shares in current array
				$shareNo++;
			}
			$chunkedShareIds[$chunkId][] = $shareId;
		}

		$chunkedSharesToMaps = [$chunkedShareIds, $shareIdToShareMap];
		return $chunkedSharesToMaps;
	}

	/**
	 * Resolve a group shares to a user specific share.
	 * Thus if the user moved their group share make sure this is properly reflected here,
	 * If $shares array contains exactly 2 elements, where
	 * only 1 will be changed(resolved), it returns exactly 2 elements, containing the resolved one.
	 *
	 * @param \OCP\Share\IShare[] $shares e.g. { IShare, IShare }[2]
	 * @param string $userId
	 * @return \OCP\Share\IShare[] $resolvedShares
	 * @throws ProviderException
	 */
	private function resolveGroupShares($shares, $userId) {
		$qb = $this->dbConn->getQueryBuilder();

		list($chunkedShareIds, $shareIdToShareMap) = $this->chunkSharesToMaps($shares);
		foreach ($chunkedShareIds as $shareIdsChunk) {
			$qb->select('*')
				->from('share')
				->where($qb->expr()->in('parent', $qb->createNamedParameter(
					$shareIdsChunk,
					IQueryBuilder::PARAM_STR_ARRAY
				)))
				->andWhere($qb->expr()->eq('share_type', $qb->createNamedParameter(self::SHARE_TYPE_USERGROUP)))
				->andWhere($qb->expr()->eq('share_with', $qb->createNamedParameter($userId)))
				->andWhere($qb->expr()->orX(
					$qb->expr()->eq('item_type', $qb->createNamedParameter('file')),
					$qb->expr()->eq('item_type', $qb->createNamedParameter('folder'))
				));

			$stmt = $qb->execute();

			// Resolve $shareIdToShareMap array containing group shares
			$shareParents = [];
			while ($data = $stmt->fetch()) {
				// Get share parent
				$shareParent = $data['parent'];

				// Ensure uniqueness of parents
				if (!isset($shareParents[$shareParent])) {
					$shareParents[$shareParent] = true;
				} else {
					throw new ProviderException('Parent of share should be unique');
				}

				// Resolve only shares contained in the map.
				// This will ensure that we return the same amount of shares in the input as in the output
				// If $shareParent is contained in $shareIdToShareMap, it means that needs resolving
				if (isset($shareIdToShareMap[$shareParent])) {
					$share = $shareIdToShareMap[$shareParent];
					$share->setState(\intval($data['accepted']));
					$share->setTarget($data['file_target']);
				}
			}
			$stmt->closeCursor();
		}

		$resolvedShares = \array_values($shareIdToShareMap);
		return $resolvedShares;
	}

	/**
	 * A user is deleted from the system
	 * So clean up the relevant shares.
	 *
	 * @param string $uid
	 * @param int $shareType
	 */
	public function userDeleted($uid, $shareType) {
		$qb = $this->dbConn->getQueryBuilder();

		$qb->delete('share');

		if ($shareType === \OCP\Share::SHARE_TYPE_USER) {
			/*
			 * Delete all user shares that are owned by this user
			 * or that are received by this user
			 */

			$qb->where($qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share::SHARE_TYPE_USER)));

			$qb->andWhere(
				$qb->expr()->orX(
					$qb->expr()->eq('uid_owner', $qb->createNamedParameter($uid)),
					$qb->expr()->eq('share_with', $qb->createNamedParameter($uid))
				)
			);
		} elseif ($shareType === \OCP\Share::SHARE_TYPE_GROUP) {
			/*
			 * Delete all group shares that are owned by this user
			 * Or special user group shares that are received by this user
			 */
			$qb->where(
				$qb->expr()->andX(
					$qb->expr()->orX(
						$qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share::SHARE_TYPE_GROUP)),
						$qb->expr()->eq('share_type', $qb->createNamedParameter(self::SHARE_TYPE_USERGROUP))
					),
					$qb->expr()->eq('uid_owner', $qb->createNamedParameter($uid))
				)
			);

			$qb->orWhere(
				$qb->expr()->andX(
					$qb->expr()->eq('share_type', $qb->createNamedParameter(self::SHARE_TYPE_USERGROUP)),
					$qb->expr()->eq('share_with', $qb->createNamedParameter($uid))
				)
			);
		} elseif ($shareType === \OCP\Share::SHARE_TYPE_LINK) {
			/*
			 * Delete all link shares owned by this user.
			 * And all link shares initiated by this user (until #22327 is in)
			 */
			$qb->where($qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share::SHARE_TYPE_LINK)));

			$qb->andWhere(
				$qb->expr()->orX(
					$qb->expr()->eq('uid_owner', $qb->createNamedParameter($uid)),
					$qb->expr()->eq('uid_initiator', $qb->createNamedParameter($uid))
				)
			);
		}

		$qb->execute();
	}

	/**
	 * Delete all shares received by this group. As well as any custom group
	 * shares for group members.
	 *
	 * @param string $gid
	 */
	public function groupDeleted($gid) {
		/*
		 * First delete all custom group shares for group members
		 */
		$qb = $this->dbConn->getQueryBuilder();
		$qb->select('id')
			->from('share')
			->where($qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share::SHARE_TYPE_GROUP)))
			->andWhere($qb->expr()->eq('share_with', $qb->createNamedParameter($gid)));

		$cursor = $qb->execute();
		$ids = [];
		while ($row = $cursor->fetch()) {
			$ids[] = (int)$row['id'];
		}
		$cursor->closeCursor();

		if (!empty($ids)) {
			$chunks = \array_chunk($ids, 100);
			foreach ($chunks as $chunk) {
				$qb->delete('share')
					->where($qb->expr()->eq('share_type', $qb->createNamedParameter(self::SHARE_TYPE_USERGROUP)))
					->andWhere($qb->expr()->in('parent', $qb->createNamedParameter($chunk, IQueryBuilder::PARAM_INT_ARRAY)));
				$qb->execute();
			}
		}

		/*
		 * Now delete all the group shares
		 */
		$qb = $this->dbConn->getQueryBuilder();
		$qb->delete('share')
			->where($qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share::SHARE_TYPE_GROUP)))
			->andWhere($qb->expr()->eq('share_with', $qb->createNamedParameter($gid)));
		$qb->execute();
	}

	/**
	 * Delete custom group shares to this group for this user
	 *
	 * @param string $uid
	 * @param string $gid
	 */
	public function userDeletedFromGroup($uid, $gid) {
		/*
		 * Get all group shares
		 */
		$qb = $this->dbConn->getQueryBuilder();
		$qb->select('id')
			->from('share')
			->where($qb->expr()->eq('share_type', $qb->createNamedParameter(\OCP\Share::SHARE_TYPE_GROUP)))
			->andWhere($qb->expr()->eq('share_with', $qb->createNamedParameter($gid)));

		$cursor = $qb->execute();
		$ids = [];
		while ($row = $cursor->fetch()) {
			$ids[] = (int)$row['id'];
		}
		$cursor->closeCursor();

		if (!empty($ids)) {
			$chunks = \array_chunk($ids, 100);
			foreach ($chunks as $chunk) {
				/*
				 * Delete all special shares wit this users for the found group shares
				 */
				$qb->delete('share')
					->where($qb->expr()->eq('share_type', $qb->createNamedParameter(self::SHARE_TYPE_USERGROUP)))
					->andWhere($qb->expr()->eq('share_with', $qb->createNamedParameter($uid)))
					->andWhere($qb->expr()->in('parent', $qb->createNamedParameter($chunk, IQueryBuilder::PARAM_INT_ARRAY)));
				$qb->execute();
			}
		}
	}

	/**
	 * Check whether the share object fits the expectations of this provider
	 *
	 * @param IShare $share share
	 *
	 * @throws InvalidArgumentException if the share validation failed
	 */
	private function validate($share) {
		if ($share->getName() !== null && \strlen($share->getName()) > 64) {
			throw new \InvalidArgumentException('Share name cannot be more than 64 characters');
		}

		// TODO: add more early validation for fields instead of relying on the DB
	}

	/**
	 * Load from database format (JSON string) to IAttributes
	 *
	 * @param IShare $share
	 * @param string|null $data
	 * @return IShare modified share
	 */
	private function updateShareAttributes(IShare $share, $data) {
		if ($data !== null) {
			$attributes = new ShareAttributes();
			$compressedAttributes = \json_decode($data, true);
			foreach ($compressedAttributes as $compressedAttribute) {
				$attributes->setAttribute(
					$compressedAttribute[0],
					$compressedAttribute[1],
					$compressedAttribute[2]
				);
			}
			$share->setAttributes($attributes);
		}

		return $share;
	}

	/**
	 * Format IAttributes to database format (JSON string)
	 *
	 * @param IAttributes|null $attributes
	 * @return string|null
	 */
	private function formatShareAttributes($attributes) {
		if ($attributes === null || empty($attributes->toArray())) {
			return null;
		}

		$compressedAttributes = [];
		foreach ($attributes->toArray() as $attribute) {
			$compressedAttributes[] = [
				0 => $attribute['scope'],
				1 => $attribute['key'],
				2 => $attribute['enabled']
			];
		}
		return \json_encode($compressedAttributes);
	}

	/**
	 * @inheritdoc
	 */
	public function getProviderCapabilities() {
		return [
			\OCP\Share::CONVERT_SHARE_TYPE_TO_STRING[\OCP\Share::SHARE_TYPE_USER] => [
				IShareProvider::CAPABILITY_STORE_EXPIRATION
			],
			\OCP\Share::CONVERT_SHARE_TYPE_TO_STRING[\OCP\Share::SHARE_TYPE_GROUP] => [
				IShareProvider::CAPABILITY_STORE_EXPIRATION
			],
			\OCP\Share::CONVERT_SHARE_TYPE_TO_STRING[\OCP\Share::SHARE_TYPE_LINK] => [
				IShareProvider::CAPABILITY_STORE_EXPIRATION,
				IShareProvider::CAPABILITY_STORE_PASSWORD
			],
		];
	}
}
