<?php
/**
 * @copyright Copyright (c) 2023, 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 OCA\Files\Command;

use OCP\IDBConnection;
use OCP\DB\QueryBuilder\IQueryBuilder;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Helper\ProgressBar;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * Remove the target storage from the oc_storages tables, and remove the
 * related files from the oc_filecache table.
 */
class RemoveStorageCache extends Command {
	private const DEFAULT_CHUNK_SIZE = 1000;

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

	public function __construct(IDBConnection $connection) {
		parent::__construct();
		$this->connection = $connection;
	}

	protected function configure() {
		$this
			->setName('files:remove-storage')
			->setDescription('Remove a storage from the storages table and related files from the filecache table.')
			->addArgument(
				'storage-id',
				InputArgument::OPTIONAL,
				'The numeric ID of the storage'
			)->addOption(
				'chunk-size',
				null,
				InputOption::VALUE_REQUIRED,
				'The number of rows that will be deleted at the same time.',
				self::DEFAULT_CHUNK_SIZE
			)->addOption(
				'show-candidates',
				null,
				InputOption::VALUE_NONE,
				'Show possible candidates for obsolete storages. This query can take a while.'
			);
	}

	protected function execute(InputInterface $input, OutputInterface $output): int {
		if ($input->getOption('show-candidates')) {
			$this->showCandidates($output);
			return 0;
		}

		$storage_id = \intval($input->getArgument('storage-id'));
		if ($storage_id <= 0) {
			$output->writeln('<error>A valid storage ID is required</error>');
			return 1;
		}

		$chunk_size = \intval($input->getOption('chunk-size'));
		if ($chunk_size <= 0) {
			$chunk_size = self::DEFAULT_CHUNK_SIZE;
		}

		$this->removeStorage($storage_id);
		$nfiles = $this->countCachedFiles($storage_id);

		if ($nfiles <= 0) {
			$output->writeln('No files found for the target storage');
			return 0;
		}

		$bar = new ProgressBar($output);
		$bar->start($nfiles);
		while (($maxId = $this->getMaxFileidInRange($storage_id, $chunk_size)) > 0) {
			$ndeleted = $this->removeCachedFiles($storage_id, $maxId);
			$bar->advance($ndeleted);
		}
		$bar->finish();
		return 0;
	}

	/**
	 * Remove the storage_id from the oc_storages table.
	 * @return int the number of rows deleted from the table
	 */
	private function removeStorage(int $storage_id) {
		$qb = $this->connection->getQueryBuilder();
		$result = $qb->delete('storages')
			->where($qb->expr()->eq('numeric_id', $qb->createNamedParameter($storage_id, IQueryBuilder::PARAM_INT)))
			->execute();
		return (int)$result;
	}

	/**
	 * Count the number of rows for the storage_id
	 * @return int the number of rows for the target storage
	 */
	private function countCachedFiles(int $storage_id) {
		$qb = $this->connection->getQueryBuilder();
		$result = $qb->select($qb->createFunction('count(*) as `count`'))
			->from('filecache')
			->where($qb->expr()->eq('storage', $qb->createNamedParameter($storage_id, IQueryBuilder::PARAM_INT)))
			->execute();

		$row = $result->fetchAssociative();
		$result->free();

		return (int)$row['count'];
	}

	/**
	 * Get the maximum fileid found in the first results of the storage_id
	 * If there is no file in the storage, 0 will be returned.
	 * The rows can be deleted by filtering by the storage_id and with
	 * the fileid lower or equal to the returned fileid
	 * @return int the maximum fileid found
	 */
	private function getMaxFileidInRange(int $storage_id, $maxResults) {
		$qb = $this->connection->getQueryBuilder();
		$result = $qb->select('fileid')
			->from('filecache')
			->where($qb->expr()->eq('storage', $qb->createNamedParameter($storage_id, IQueryBuilder::PARAM_INT)))
			->orderBy('fileid', 'ASC')
			->setMaxResults($maxResults)
			->execute();

		$maxId = 0;
		while (($row = $result->fetchAssociative()) !== false) {
			if ($maxId < (int)$row['fileid']) {
				$maxId = (int)$row['fileid'];
			}
		}

		$result->free();
		return $maxId;
	}

	/**
	 * Remove the files in the oc_filecache table with the target storage_id and
	 * with fileid lower or equal to the $max
	 * @return int the number of removed rows
	 */
	private function removeCachedFiles(int $storage_id, int $max) {
		$qb = $this->connection->getQueryBuilder();
		$result = $qb->delete('filecache')
			->where($qb->expr()->eq('storage', $qb->createNamedParameter($storage_id, IQueryBuilder::PARAM_INT)))
			->andWhere($qb->expr()->lte('fileid', $qb->createNamedParameter($max)))
			->execute();

		return (int)$result;
	}

	private function showCandidates(OutputInterface $output) {
		$qb = $this->connection->getQueryBuilder();
		$result = $qb->select(['f.storage', 's.id', $qb->createFunction('count(f.`storage`) as `count`')])
			->from('storages', 's')
			->leftJoin('s', 'mounts', 'm', $qb->expr()->eq('s.numeric_id', 'm.storage_id'))
			->rightJoin('s', 'filecache', 'f', $qb->expr()->eq('s.numeric_id', 'f.storage'))
			->where($qb->expr()->isNull('m.mount_point'))
			->groupBy('f.storage', 's.id')
			->execute();

		$table = new Table($output);
		$table->setHeaders(['storage-id', 'name', 'file_count']);
		while (($row = $result->fetchAssociative()) !== false) {
			$table->addRow([$row['storage'], $row['id'] ?? 'NULL', $row['count']]);
		}
		$table->render();
		$result->free();
	}
}
