FreshRSS/app/Models/Feed.php

<?php
declare(strict_types=1);

class FreshRSS_Feed extends Minz_Model {
	use FreshRSS_AttributesTrait, FreshRSS_FilterActionsTrait;

	/**
	 * Normal RSS or Atom feed
	 * @var int
	 */
	public const KIND_RSS = 0;
	/**
	 * Invalid RSS or Atom feed
	 * @var int
	 */
	public const KIND_RSS_FORCED = 2;
	/**
	 * Normal HTML with XPath scraping
	 * @var int
	 */
	public const KIND_HTML_XPATH = 10;
	/**
	 * Normal XML with XPath scraping
	 * @var int
	 */
	public const KIND_XML_XPATH = 15;
	/**
	 * Normal JSON with XPath scraping
	 * @var int
	 */
	public const KIND_JSON_XPATH = 20;

	public const KIND_JSONFEED = 25;
	public const KIND_JSON_DOTNOTATION = 30;
	/** JSON embedded in HTML */
	public const KIND_HTML_XPATH_JSON_DOTNOTATION = 35;

	public const PRIORITY_IMPORTANT = 20;
	public const PRIORITY_MAIN_STREAM = 10;
	public const PRIORITY_CATEGORY = 0;
	public const PRIORITY_FEED = -5;
	public const PRIORITY_HIDDEN = -10;
	#[Deprecated('Use PRIORITY_HIDDEN instead')]
	public const PRIORITY_ARCHIVED = -10;

	public const TTL_DEFAULT = 0;

	public const ARCHIVING_RETENTION_COUNT_LIMIT = 10000;
	public const ARCHIVING_RETENTION_PERIOD = 'P3M';

	private int $id = 0;
	private string $url = '';
	private int $kind = 0;
	private int $categoryId = 0;
	private ?FreshRSS_Category $category = null;
	private int $nbEntries = -1;
	private int $nbNotRead = -1;
	private string $name = '';
	private string $website = '';
	private string $description = '';
	private int $lastUpdate = 0;
	private int $priority = self::PRIORITY_MAIN_STREAM;
	private string $pathEntries = '';
	private string $httpAuth = '';
	private int $error = 0;
	private int $ttl = self::TTL_DEFAULT;
	private bool $mute = false;
	private string $hash = '';
	private string $hashFavicon = '';
	private string $lockPath = '';
	private string $hubUrl = '';
	private string $selfUrl = '';

	/**
	 * @throws FreshRSS_BadUrl_Exception
	 */
	public function __construct(string $url, bool $validate = true) {
		if ($validate) {
			$this->_url($url);
		} else {
			$this->url = $url;
		}
	}

	public static function default(): FreshRSS_Feed {
		$f = new FreshRSS_Feed('http://example.net/', false);
		$f->faviconPrepare();
		return $f;
	}

	public function id(): int {
		return $this->id;
	}

	public function hash(): string {
		if ($this->hash == '') {
			$salt = FreshRSS_Context::systemConf()->salt;
			$params = $this->url . $this->proxyParam();
			$this->hash = sha1($salt . $params);
		}
		return $this->hash;
	}

	public function resetFaviconHash(): void {
		$this->hashFavicon(skipCache: true);
	}

	/** Must match the proxy of `FreshRSS_SimplePieCustom`, which stores `Retry-After`. */
	public function proxyParam(): string {
		$curl_options = array_replace(FreshRSS_Context::systemConf()->curl_options,
			FreshRSS_http_Util::sanitizeCurlParams($this->attributeArray('curl_params') ?? []));
		$proxyType = $curl_options[CURLOPT_PROXYTYPE] ?? 0;
		if (is_int($proxyType) && ($proxyType < 0 || $proxyType === 3)) {	// 3 is legacy for NONE
			return '';	// Proxy disabled for this feed
		}
		return is_string($curl_options[CURLOPT_PROXY] ?? null) ? $curl_options[CURLOPT_PROXY] : '';
	}

	/**
	* Resets the custom favicon to the default one. Also deletes the favicon when allowed by extension.
	*
	* @param array{'url'?:string,'kind'?:int,'category'?:int,'name'?:string,'website'?:string,'description'?:string,'lastUpdate'?:int,'priority'?:int,
	* 	'pathEntries'?:string,'httpAuth'?:string,'error'?:int,'ttl'?:int,'attributes'?:string|array<string,mixed>} &$values &$values
	*
	* @param bool $updateFeed Whether `updateFeed()` should be called immediately. If false, it must be handled manually.
	*
	* @return void
	*
	* @throws FreshRSS_Feed_Exception
	*/
	public function resetCustomFavicon(?array &$values = null, bool $updateFeed = true) {
		if (!$this->customFavicon()) {
			return;
		}
		if (!$this->attributeBoolean('customFaviconDisallowDel')) {
			FreshRSS_Feed::faviconDelete($this->hashFavicon());
		}
		$this->_attribute('customFavicon', false);
		$this->_attribute('customFaviconExt', null);
		$this->_attribute('customFaviconDisallowDel', false);
		if ($values !== null) {
			$values['attributes'] = $this->attributes();
			$feedDAO = FreshRSS_Factory::createFeedDao();
			if ($updateFeed && !$feedDAO->updateFeed($this->id(), $values)) {
				throw new FreshRSS_Feed_Exception();
			}
		}
		$this->resetFaviconHash();
	}

	/**
	* Set a custom favicon for the feed.
	*
	* @param string $contents Contents of the favicon file. Optional if $tmpPath is set.
	* @param string $tmpPath Use only when handling file uploads. (value from `tmp_name` goes here)
	*
	* @param array{'url'?:string,'kind'?:int,'category'?:int,'name'?:string,'website'?:string,'description'?:string,'lastUpdate'?:int,'priority'?:int,
	* 	'pathEntries'?:string,'httpAuth'?:string,'error'?:int,'ttl'?:int,'attributes'?:string|array<string,mixed>} &$values &$values
	*
	* @param bool $updateFeed Whether `updateFeed()` should be called immediately. If false, it must be handled manually.
	* @param string $extName The extension name of the calling extension.
	* @param bool $disallowDelete Whether the icon can be later deleted when it's being reset. Intended for use by extensions.
	* @param bool $overrideCustomIcon Whether a custom favicon set by a user can be overridden.
	*
	* @return string|null Path where the favicon can be found. Useful for checking if the favicon already exists, before downloading it for example.
	*
	* @throws FreshRSS_UnsupportedImageFormat_Exception
	* @throws FreshRSS_Feed_Exception
	*/
	public function setCustomFavicon(
		?string $contents = null,
		string $tmpPath = '',
		?array &$values = null,
		bool $updateFeed = true,
		?string $extName = null,
		bool $disallowDelete = false,
		bool $overrideCustomIcon = false
	): ?string {
		if ($contents === null && $tmpPath !== '') {
			$contents = file_get_contents($tmpPath);
		}

		$attributesOnly = $contents === null && $tmpPath === '';

		require_once LIB_PATH . '/favicons.php';
		if (!$attributesOnly && !isImgMime(is_string($contents) ? $contents : '')) {
			throw new FreshRSS_UnsupportedImageFormat_Exception();
		}

		$oldHash = '';
		$oldDisallowDelete = false;
		if ($this->customFavicon()) {
			/* If $overrideCustomFavicon is true, custom favicons set by extensions can be overridden,
			 * but not ones explicitly set by the user */
			if (!$overrideCustomIcon && $this->customFaviconExt() === null) {
				return null;
			}
			$oldHash = $this->hashFavicon(skipCache: true);
			$oldDisallowDelete = $this->attributeBoolean('customFaviconDisallowDel');
		}
		$this->_attribute('customFavicon', true);
		$this->_attribute('customFaviconExt', $extName);
		$this->_attribute('customFaviconDisallowDel', $disallowDelete);

		$newPath = FAVICONS_DIR . $this->hashFavicon(skipCache: true) . '.ico';
		if ($attributesOnly && !file_exists($newPath)) {
			$updateFeed = false;
		}

		if ($values !== null) {
			$values['attributes'] = $this->attributes();
			$feedDAO = FreshRSS_Factory::createFeedDao();
			if ($updateFeed && !$feedDAO->updateFeed($this->id(), $values)) {
				throw new FreshRSS_Feed_Exception();
			}
		}

		if ($tmpPath !== '') {
			move_uploaded_file($tmpPath, $newPath);
		} elseif ($contents !== null) {
			file_put_contents($newPath, $contents);
		}

		if ($oldHash !== '' && !$oldDisallowDelete) {
			FreshRSS_Feed::faviconDelete($oldHash);
		}

		return $newPath;
	}

	/**
	* Checks if the feed has a custom favicon set by an extension.
	* Additionally, it also checks if the extension that set the icon is still enabled
	* And if not, it resets attributes related to custom favicons.
	*
	* @return string|null The name of the extension that set the icon.
	*/
	public function customFaviconExt(): ?string {
		$customFaviconExt = $this->attributeString('customFaviconExt');
		if ($customFaviconExt !== null && !Minz_ExtensionManager::isExtensionEnabled($customFaviconExt)) {
			$this->_attribute('customFavicon', false);
			$this->_attribute('customFaviconExt', null);
			$this->_attribute('customFaviconDisallowDel', false);
			$customFaviconExt = null;
		}
		return $customFaviconExt;
	}

	public function customFavicon(): bool {
		$this->customFaviconExt();
		return $this->attributeBoolean('customFavicon') ?? false;
	}

	public function hashFavicon(bool $skipCache = false): string {
		if ($this->hashFavicon == '' || $skipCache) {
			$salt = FreshRSS_Context::systemConf()->salt;
			$params = '';
			if ($this->customFavicon()) {
				$current = $this->id . Minz_User::name();
				$hookParams = Minz_ExtensionManager::callHook(Minz_HookType::CustomFaviconHash, $this);
				$params = $hookParams !== null ? $hookParams : $current;
			} else {
				$feedIconUrl = $this->attributeString('feedIconUrl') ?? '';
				$params = $feedIconUrl !== '' ? $feedIconUrl . $this->proxyParam()
					: $this->website(fallback: true) . $this->proxyParam();
			}
			$hash = hash_hmac('sha256', is_string($params) ? $params : '', $salt, binary: true);
			$hash = substr($hash, 0, 8);	// Keep 64 bits
			$hash = strtr(rtrim(base64_encode($hash), '='), '+/', '-_');	// URL-safe base64
			$this->hashFavicon = $hash;	// Length 11
		}
		return $this->hashFavicon;
	}

	public function url(bool $includeCredentials = true): string {
		return $includeCredentials ? $this->url : \SimplePie\Misc::url_remove_credentials($this->url);
	}
	public function selfUrl(): string {
		return $this->selfUrl;
	}
	public function kind(): int {
		return $this->kind;
	}
	public function hubUrl(): string {
		return $this->hubUrl;
	}

	public function category(): ?FreshRSS_Category {
		if ($this->category === null && $this->categoryId > 0) {
			$catDAO = FreshRSS_Factory::createCategoryDao();
			$this->category = $catDAO->searchById($this->categoryId);
		}
		return $this->category;
	}

	public function categoryId(): int {
		return $this->category?->id() ?: $this->categoryId;
	}

	public function name(bool $raw = false): string {
		return $raw || $this->name != '' ? $this->name : (preg_replace('%^https?://(www[.])?%i', '', $this->url) ?? '');
	}

	/**
	 * @param bool $fallback true to return the URL of the feed if the Web site is blank
	 * @return string HTML-encoded URL of the Web site of the feed
	 */
	public function website(bool $fallback = false): string {
		$url = $this->website;
		if ($fallback && !preg_match('%^https?://.%i', $url)) {
			$url = $this->url;
		}
		return $url;
	}

	public function description(): string {
		return $this->description;
	}
	public function lastUpdate(): int {
		return $this->lastUpdate;
	}
	public function priority(): int {
		return $this->priority;
	}

	public function showUnreadCount(): bool {
		$sucGlobal = FreshRSS_Context::userConf()->show_unread_count;
		$isImportant = $this->priority >= self::PRIORITY_IMPORTANT;
		if ($isImportant && $sucGlobal !== 'none') {
			return true;
		}
		return $this->attributeBoolean('show_unread_count') ??
			$this->category()?->attributeBoolean('show_unread_count') ??
			($sucGlobal === 'all' || ($sucGlobal === 'important' && $isImportant));
	}

	/** @return string HTML-encoded CSS selector */
	public function pathEntries(): string {
		return $this->pathEntries;
	}
	/**
	 * @phpstan-return ($raw is true ? string : array{'username':string,'password':string})
	 * @return array{'username':string,'password':string}|string
	 */
	public function httpAuth(bool $raw = true): array|string {
		if ($raw) {
			return $this->httpAuth;
		} else {
			$pos_colon = strpos($this->httpAuth, ':');
			if ($pos_colon !== false) {
				$user = substr($this->httpAuth, 0, $pos_colon);
				$pass = substr($this->httpAuth, $pos_colon + 1);
			} else {
				$user = '';
				$pass = '';
			}

			return [
				'username' => $user,
				'password' => $pass,
				];
		}
	}

	/** @return array<int,mixed> */
	public function curlOptions(): array {
		$curl_options = [];
		if ($this->httpAuth !== '') {
			$curl_options[CURLOPT_USERPWD] = htmlspecialchars_decode($this->httpAuth, ENT_QUOTES);
		}
		return $curl_options;
	}

	/**
	 * Timestamp of last update error.
	 * Legacy: may return 1 if the feed has an error but the timestamp is not available.
	 */
	public function lastError(): int {
		return $this->error;
	}

	/**
	 * If the feed has an error
	 */
	public function inError(): bool {
		return $this->error > 0;
	}

	/**
	 * @param bool $raw true for database version combined with mute information, false otherwise
	 */
	public function ttl(bool $raw = false): int {
		if ($raw) {
			$ttl = $this->ttl;
			if ($this->mute && FreshRSS_Feed::TTL_DEFAULT === $ttl) {
				$ttl = FreshRSS_Context::userConf()->ttl_default;
			}
			return $ttl * ($this->mute ? -1 : 1);
		}
		if ($this->mute && $this->ttl === FreshRSS_Context::userConf()->ttl_default) {
			return FreshRSS_Feed::TTL_DEFAULT;
		}
		return $this->ttl;
	}

	public function mute(): bool {
		return $this->mute;
	}

	public function nbEntries(): int {
		if ($this->nbEntries < 0) {
			$feedDAO = FreshRSS_Factory::createFeedDao();
			$this->nbEntries = $feedDAO->countEntries($this->id());
		}

		return $this->nbEntries;
	}
	public function nbNotRead(): int {
		if ($this->nbNotRead < 0) {
			$feedDAO = FreshRSS_Factory::createFeedDao();
			$this->nbNotRead = $feedDAO->countNotRead($this->id());
		}

		return $this->nbNotRead;
	}

	/** @return int Timestamp of the newest article received for this feed, or 0 if none */
	public function newestArticleReceivedDate(): int {
		static $newestArticleReceivedDate = null;
		if (!is_int($newestArticleReceivedDate)) {
			$feedDAO = FreshRSS_Factory::createFeedDao();
			$newestArticleReceivedDate = $feedDAO->newestArticleReceivedDate($this->id());
		}
		return $newestArticleReceivedDate;
	}

	/** @return int Timestamp of the Last article published for this feed, or 0 if none */
	public function newestArticlePublicationDate(): int {
		static $newestArticlePublicationDate = null;
		if (!is_int($newestArticlePublicationDate)) {
			$feedDAO = FreshRSS_Factory::createFeedDao();
			$newestArticlePublicationDate = $feedDAO->newestArticlePublicationDate($this->id());
		}
		return $newestArticlePublicationDate;
	}

	public function faviconPrepare(bool $force = false): void {
		require_once LIB_PATH . '/favicons.php';
		if ($this->customFavicon()) {
			$this->migrateCustomFavicon();
			return;
		}
		$feedIconUrl = $this->attributeString('feedIconUrl') ?? '';
		$websiteUrl = $this->website(fallback: false);
		if ($websiteUrl === '' || $websiteUrl === $this->url) {
			// Get root URL from the feed URL
			$websiteUrl = preg_replace('%^(https?://[^/]+).*$%i', '$1/', $this->url) ?? $this->url;
		}
		$url = $feedIconUrl !== '' ? $feedIconUrl : $websiteUrl;

		$txt = FAVICONS_DIR . $this->hashFavicon() . '.txt';
		if (@file_get_contents($txt) !== $url) {
			file_put_contents($txt, $url);
		}
		if (FreshRSS_Context::$isCli || $force) {
			$ico = FAVICONS_DIR . $this->hashFavicon() . '.ico';
			$ico_mtime = @filemtime($ico);
			$txt_mtime = @filemtime($txt);
			if ($txt_mtime != false &&
				($ico_mtime == false || $ico_mtime < $txt_mtime || ($ico_mtime < time() - (14 * 86400)))) {
				// no ico file or we should download a new one.
				if ($feedIconUrl !== '' && download_favicon_from_image_url($feedIconUrl, $ico)) {
					return;
				}
				// Fall back to website favicon search
				if (!download_favicon($websiteUrl, $ico)) {
					touch($ico);
				}
			}
		}
	}

	/** Legacy favicon migration from FreshRSS < 1.31.0 */
	private function migrateCustomFavicon(): void {
		if (!$this->customFavicon()) {
			return;
		}
		$salt = FreshRSS_Context::systemConf()->salt;
		$params = $this->id . Minz_User::name();
		$hookParams = Minz_ExtensionManager::callHook(Minz_HookType::CustomFaviconHash, $this);
		if ($hookParams !== null) {
			$params = $hookParams;
		}
		$newPath = FAVICONS_DIR . $this->hashFavicon() . '.ico';
		if (!file_exists($newPath)) {
			$legacyHash = hash('crc32b', $salt . (is_string($params) ? $params : ''));
			$legacyPath = FAVICONS_DIR . $legacyHash . '.ico';
			if (is_file($legacyPath)) {
				@copy($legacyPath, $newPath);
			}
		}
	}

	public static function faviconDelete(string $hash): void {
		if (preg_match('/\\A[A-Za-z0-9_-]{1,11}\\z/', $hash) !== 1) {
			return;
		}
		$path = DATA_PATH . '/favicons/' . $hash;
		@unlink($path . '.ico');
		@unlink($path . '.txt');
	}
	public function favicon(bool $absolute = false): string {
		require_once LIB_PATH . '/favicons.php';
		$this->migrateCustomFavicon();
		$hash = $this->hashFavicon();
		$url = '/f.php?h=' . $hash;
		if ($this->customFavicon()
			// when the below attribute is set, icon won't be changing frequently so cache buster is not needed
			&& !$this->attributeBoolean('customFaviconDisallowDel')) {
			$url .= '&t=' . @filemtime(DATA_PATH . '/favicons/' . $hash . '.ico');
		}
		return Minz_Url::display($url, absolute: $absolute);
	}

	public function _id(int $value): void {
		$this->id = $value;
	}

	/**
	 * @throws FreshRSS_BadUrl_Exception
	 */
	public function _url(string $value, bool $validate = true): void {
		$this->hash = '';
		$this->hashFavicon = '';
		$url = $value;
		if ($validate) {
			$url = FreshRSS_http_Util::checkUrl($url);
		}
		if ($url == false) {
			throw new FreshRSS_BadUrl_Exception($value);
		}
		$this->url = $url;
	}

	public function _selfUrl(string $value): void {
		$this->selfUrl = $value;
	}

	public function _kind(int $value): void {
		$this->kind = $value;
	}

	public function _category(?FreshRSS_Category $cat): void {
		$this->category = $cat;
		$this->categoryId = $this->category == null ? 0 : $this->category->id();
	}

	/** @param int|numeric-string $id */
	public function _categoryId(int|string $id): void {
		$this->category = null;
		$this->categoryId = (int)$id;
	}

	public function _name(string $value): void {
		$this->name = $value == '' ? '' : trim($value);
	}
	public function _website(string $value, bool $validate = true): void {
		$this->hashFavicon = '';
		if ($validate) {
			$value = FreshRSS_http_Util::checkUrl($value);
		}
		if ($value == false) {
			$value = '';
		}
		$this->website = $value;
	}
	public function _description(string $value): void {
		$this->description = $value == '' ? '' : $value;
	}

	/**
	 * @param int|numeric-string $value
	 * 32-bit systems provide a string and will fail in year 2038
	 */
	public function _lastUpdate(int|string $value): void {
		$this->lastUpdate = (int)$value;
	}

	public function _priority(int $value): void {
		$this->priority = $value;
	}
	/** @param string $value HTML-encoded CSS selector */
	public function _pathEntries(string $value): void {
		$this->pathEntries = $value;
	}
	public function _httpAuth(#[\SensitiveParameter] string $value): void {
		$this->httpAuth = $value;
	}

	/**
	 * @param int|numeric-string $value
	 * 32-bit systems provide a string and will fail in year 2038
	 */
	public function _error(int|string $value): void {
		$this->error = (int)$value;
	}
	public function _mute(bool $value): void {
		$this->mute = $value;
	}
	public function _ttl(int $value): void {
		$value = min($value, 100_000_000);
		$this->ttl = abs($value);
		$this->mute = $value < self::TTL_DEFAULT;
	}

	public function _nbNotRead(int $value): void {
		$this->nbNotRead = $value;
	}
	public function _nbEntries(int $value): void {
		$this->nbEntries = $value;
	}

	public function defaultSort(): ?string {
		return $this->attributeString('defaultSort');
	}
	public function defaultOrder(): ?string {
		return $this->attributeString('defaultOrder');
	}

	/**
	 * @throws Minz_FileNotExistException
	 * @throws FreshRSS_Feed_Exception
	 */
	public function load(bool $loadDetails = false, bool $noCache = false): ?FreshRSS_SimplePieCustom {
		if ($this->url != '') {
			/**
			 * @throws Minz_FileNotExistException
			 */
			if (trim(CACHE_PATH) === '') {
				throw new Minz_FileNotExistException(
					'CACHE_PATH',
					Minz_Exception::ERROR
				);
			} else {
				$url = htmlspecialchars_decode($this->url, ENT_QUOTES);
				$forceFeed = str_ends_with($url, '#force_feed');
				if ($forceFeed) {
					$url = substr($url, 0, -11);
				}
				// Retry-After is stored for the URL as requested, not as stored for the feed
				if (($retryAfter = FreshRSS_http_Util::getRetryAfter($url, $this->proxyParam())) > 0) {
					throw new FreshRSS_Feed_Exception('For that domain, will first retry after ' . date('c', $retryAfter) .
						'. ' . $this->url(includeCredentials: false), code: 503);
				}
				$simplePie = new FreshRSS_SimplePieCustom($this->attributes(), $this->curlOptions());
				if ($forceFeed) {
					$simplePie->force_feed(true);
				}
				$simplePie->set_feed_url($url);
				if (!$loadDetails) {	//Only activates auto-discovery when adding a new feed
					$simplePie->set_autodiscovery_level(\SimplePie\SimplePie::LOCATOR_NONE);
				}
				if ($this->attributeBoolean('clear_cache')) {
					// Do not use `$simplePie->enable_cache(false);` as it would prevent caching in multiuser context
					$this->clearCache();
				}
				Minz_ExtensionManager::callHook(Minz_HookType::SimplepieBeforeInit, $simplePie, $this);
				$simplePieResult = $simplePie->init();
				Minz_ExtensionManager::callHook(Minz_HookType::SimplepieAfterInit, $simplePie, $this, $simplePieResult);

				if ($simplePieResult === false || $simplePie->get_hash() === '' || !empty($simplePie->error())) {
					if ($simplePie->status_code() === 429) {
						$errorMessage = 'HTTP 429 Too Many Requests!';
					} elseif ($simplePie->status_code() === 503) {
						$errorMessage = 'HTTP 503 Service Unavailable!';
					} else {
						$errorMessage = $simplePie->error();
						if (empty($errorMessage)) {
							$errorMessage = '';
						} elseif (is_array($errorMessage)) {
							$errorMessage = json_encode($errorMessage, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_LINE_TERMINATORS) ?: '';
						}
					}
					throw new FreshRSS_Feed_Exception(
						($errorMessage == '' ? 'Unknown error for feed' : $errorMessage) .
							' [' . $this->url(includeCredentials: false) . ']',
						$simplePie->status_code()
					);
				}

				$links = $simplePie->get_links('self');
				$this->selfUrl = empty($links[0]) ? '' : (FreshRSS_http_Util::checkUrl($links[0]) ?: '');
				$links = $simplePie->get_links('hub');
				$this->hubUrl = empty($links[0]) ? '' : (FreshRSS_http_Util::checkUrl($links[0]) ?: '');

				if ($loadDetails) {
					// If auto-discovery was used, the URL has changed
					$subscribe_url = $simplePie->subscribe_url(false) ?? '';

					if ($this->name(true) === '') {
						//HTML to HTML-PRE	//ENT_COMPAT except '&'
						$title = strtr(html_only_entity_decode($simplePie->get_title()), ['<' => '&lt;', '>' => '&gt;', '"' => '&quot;']);
						$this->_name($title == '' ? $this->url : $title);
					}
					if ($this->website() === '') {
						$this->_website(html_only_entity_decode($simplePie->get_link()));
					}
					if ($this->description() === '') {
						$this->_description(html_only_entity_decode($simplePie->get_description()));
					}
				} else {
					//The case of HTTP 301 Moved Permanently
					$subscribe_url = $simplePie->subscribe_url(true) ?? '';
				}

				$clean_url = \SimplePie\Misc::url_remove_credentials($subscribe_url);
				if ($subscribe_url !== '' && $subscribe_url !== $url) {
					$this->_url($clean_url);
				}

				if ($noCache || $simplePie->get_hash() !== $this->attributeString('SimplePieHash')) {
					// syslog(LOG_DEBUG, 'FreshRSS no cache ' . $simplePie->get_hash() . ' !== ' . $this->attributeString('SimplePieHash') . ' for ' . $clean_url);
					$this->_attribute('SimplePieHash', $simplePie->get_hash());
					return $simplePie;
				}
				if (FreshRSS_Context::systemConf()->simplepie_syslog_enabled) {
					syslog(LOG_DEBUG, 'FreshRSS SimplePie uses cache for ' . $clean_url);
				}
			}
		}
		return null;
	}

	/**
	 * Decide the GUID of an entry based on the feed’s policy.
	 * @param \SimplePie\Item $item The item to decide the GUID for.
	 * @param bool $fallback Whether to automatically switch to the next policy in case of blank GUID.
	 * @return string The decided GUID for the entry.
	 */
	protected function decideEntryGuid(\SimplePie\Item $item, bool $fallback = false): string {
		$unicityCriteria = $this->attributeString('unicityCriteria');
		if ($this->attributeBoolean('hasBadGuids')) {	// Legacy
			$unicityCriteria = 'link';
		}

		$entryId = safe_ascii($item->get_id(false, false));

		$guid = match ($unicityCriteria) {
			null => $entryId,
			'link' => $item->get_permalink() ?? '',
			'sha1:link_published'               => sha1($item->get_permalink() . $item->get_date('U')),
			'sha1:link_published_title'         => sha1($item->get_permalink() . $item->get_date('U') . $item->get_title()),
			'sha1:link_published_title_content' => sha1($item->get_permalink() . $item->get_date('U') . $item->get_title() . $item->get_content()),
			'sha1:title'                        => sha1($item->get_title() ?? ''),
			'sha1:title_published'              => sha1($item->get_title() . $item->get_date('U')),
			'sha1:title_published_content'      => sha1($item->get_title() . $item->get_date('U') . $item->get_content()),
			'sha1:content'                      => sha1($item->get_content() ?? ''),
			'sha1:content_published'            => sha1($item->get_content() . $item->get_date('U')),
			'sha1:published'                    => sha1((string)($item->get_date('U') ?? '')),
			default => $entryId,
		};

		$blankHash = 'da39a3ee5e6b4b0d3255bfef95601890afd80709';	// sha1('')
		if ($guid === $blankHash) {
			$guid = '';
		}

		if ($fallback && $guid === '') {
			if ($entryId !== '') {
				$guid = $entryId;
			} elseif (($item->get_permalink() ?? '') !== '') {
				$guid = sha1($item->get_permalink() . $item->get_date('U'));
			} elseif (($item->get_title() ?? '') !== '') {
				$guid = sha1($item->get_permalink() . $item->get_date('U') . $item->get_title());
			} else {
				$guid = sha1($item->get_permalink() . $item->get_date('U') . $item->get_title() . $item->get_content());
			}
			if ($guid === $blankHash) {
				$guid = '';
			}
		}

		return $guid;
	}

	/**
	 * @param float $invalidGuidsTolerance (default 0.05) The maximum ratio (rounded) of invalid GUIDs to tolerate before degrading the unicity criteria.
	 * Example for 0.05 (5% rounded): tolerate 0 invalid GUIDs for up to 9 articles, 1 for 10, 2 for 30, 3 for 50, 4 for 70, 5 for 90, 6 for 110, etc.
	 * The default value of 5% rounded was chosen to allow 1 invalid GUID for feeds of 10 articles, which is a frequently observed amount of articles.
	 * @return list<string>
	 */
	public function loadGuids(FreshRSS_SimplePieCustom $simplePie, float $invalidGuidsTolerance = 0.05): array {
		$invalidGuids = 0;
		$testGuids = [];
		$guids = [];

		$items = $simplePie->get_items();
		if (empty($items)) {
			return $guids;
		}
		for ($i = count($items) - 1; $i >= 0; $i--) {
			$item = $items[$i];
			if ($item == null) {
				continue;
			}
			$guid = $this->decideEntryGuid($item, fallback: true);
			if ($guid === '' || !empty($testGuids['_' . $guid])) {
				$invalidGuids++;
				Minz_Log::debug('Invalid GUID [' . $guid . '] for feed ' . $this->url);
			}
			$testGuids['_' . $guid] = true;
			$guids[] = $guid;
		}

		if ($invalidGuids > 0) {
			Minz_Log::warning("Feed has {$invalidGuids} invalid GUIDs: " . $this->url(includeCredentials: false));
			if (!$this->attributeBoolean('unicityCriteriaForced') && $invalidGuids > round($invalidGuidsTolerance * count($items))) {
				$unicityCriteria = $this->attributeString('unicityCriteria');
				if ($this->attributeBoolean('hasBadGuids')) {	// Legacy
					$unicityCriteria = 'link';
				}

				// Automatic fallback to next (degraded) unicity criteria
				$newUnicityCriteria = match ($unicityCriteria) {
					null => 'sha1:link_published',
					'link' => 'sha1:link_published',
					'sha1:link_published' => 'sha1:link_published_title',
					default => $unicityCriteria,
				};

				if ($newUnicityCriteria !== $unicityCriteria) {
					$this->_attribute('hasBadGuids', null);	// Remove legacy
					$this->_attribute('unicityCriteria', $newUnicityCriteria);
					Minz_Log::warning('Feed unicity policy degraded (' . ($unicityCriteria ?: 'id') . ' → ' . $newUnicityCriteria . '): ' .
						$this->url(includeCredentials: false));
					return $this->loadGuids($simplePie, $invalidGuidsTolerance);
				}
			}
			$this->_error(time());
		}

		return $guids;
	}

	/** @return Traversable<FreshRSS_Entry> */
	public function loadEntries(FreshRSS_SimplePieCustom $simplePie): Traversable {
		$items = $simplePie->get_items();
		if (empty($items)) {
			return;
		}
		// We want chronological order and SimplePie uses reverse order.
		for ($i = count($items) - 1; $i >= 0; $i--) {
			$item = $items[$i];
			if ($item == null) {
				continue;
			}
			$title = html_only_entity_decode(strip_tags($item->get_title() ?? ''));
			$authors = $item->get_authors();
			$link = $item->get_permalink();
			$date = $item->get_date('U');
			if (!is_numeric($date)) {
				$date = 0;
			}

			//Tag processing (tag == category)
			$categories = $item->get_categories();
			$tags = [];
			if (is_array($categories)) {
				foreach ($categories as $category) {
					$text = html_only_entity_decode($category->get_label());
					//Some feeds use a single category with comma-separated tags
					$labels = explode(',', $text);
					if (!empty($labels)) {
						foreach ($labels as $label) {
							$tags[] = trim($label);
						}
					}
				}
				$tags = array_unique($tags);
			}

			$content = html_only_entity_decode($item->get_content());

			$attributeThumbnail = $item->get_thumbnail() ?? [];
			if (empty($attributeThumbnail['url']) || !is_string($attributeThumbnail['url']) ||
				!\SimplePie\Misc::is_remote_uri($attributeThumbnail['url'])) {
				$attributeThumbnail['url'] = '';
			}

			$attributeEnclosures = [];
			// Keep only one representation per `<media:group>` (the `isDefault` one, or the first one)
			$enclosures = $item->get_enclosures(excludeMediaGroupAlternatives: true);
			if (!empty($enclosures)) {
				foreach ($enclosures as $enclosure) {
					$elink = $enclosure->get_link();
					if (is_string($elink) && $elink !== '' && \SimplePie\Misc::is_remote_uri($elink)) {
						$etitle = $enclosure->get_title() ?? '';
						$credits = $enclosure->get_credits() ?? null;
						$description = $enclosure->get_description() ?? '';
						$mime = strtolower($enclosure->get_type() ?? '');
						$medium = strtolower($enclosure->get_medium() ?? '');
						$height = $enclosure->get_height();
						$width = $enclosure->get_width();
						$length = $enclosure->get_length();

						$attributeEnclosure = [
							'url' => $elink,
						];
						if ($etitle != '') {
							$attributeEnclosure['title'] = $etitle;
						}
						if (is_array($credits)) {
							$attributeEnclosure['credit'] = [];
							foreach ($credits as $credit) {
								$attributeEnclosure['credit'][] = $credit->get_name();
							}
						}
						if ($description != '') {
							$attributeEnclosure['description'] = $description;
						}
						if ($mime != '') {
							$attributeEnclosure['type'] = $mime;
						}
						if ($medium != '') {
							$attributeEnclosure['medium'] = $medium;
						}
						if ($length != '') {
							$attributeEnclosure['length'] = (int)$length;
						}
						if ($height != '') {
							$attributeEnclosure['height'] = (int)$height;
						}
						if ($width != '') {
							$attributeEnclosure['width'] = (int)$width;
						}

						if (!empty($enclosure->get_thumbnails())) {
							foreach ($enclosure->get_thumbnails() as $thumbnail) {
								if (is_string($thumbnail) && \SimplePie\Misc::is_remote_uri($thumbnail) &&
									$thumbnail !== $attributeThumbnail['url']) {
									$attributeEnclosure['thumbnails'][] = $thumbnail;
								}
							}
						}

						$attributeEnclosures[] = $attributeEnclosure;
					}
				}
			}

			$guid = $this->decideEntryGuid($item, fallback: true);
			unset($item);

			$authorNames = '';
			if (is_array($authors)) {
				foreach ($authors as $author) {
					$authorName = $author->name != '' ? $author->name : $author->email;
					if (is_string($authorName) && $authorName !== '') {
						$authorNames .= html_only_entity_decode(strip_tags($authorName)) . '; ';
					}
				}
			}
			$authorNames = substr($authorNames, 0, -2) ?: '';

			$entry = new FreshRSS_Entry(
				$this->id(),
				$guid,
				$title == '' ? '' : $title,
				$authorNames,
				$content == '' ? '' : $content,
				$link == null ? '' : $link,
				$date ?: time()
			);
			$entry->_tags($tags);
			$entry->_feed($this);
			if (!empty($attributeThumbnail['url'])) {
				$entry->_attribute('thumbnail', $attributeThumbnail);
			}
			$entry->_attribute('enclosures', $attributeEnclosures);
			$entry->hash();	//Must be computed before loading full content
			$entry->loadCompleteContent();	// Optionally load full content for truncated feeds

			yield $entry;
		}
	}

	/**
	 * Given a feed content generated from a FreshRSS_View
	 * returns a SimplePie initialized already with that content
	 * @param string $feedContent the content of the feed, typically generated via FreshRSS_View::renderToString()
	 */
	private function simplePieFromContent(string $feedContent): FreshRSS_SimplePieCustom {
		$simplePie = new FreshRSS_SimplePieCustom();
		$simplePie->enable_cache(false);
		$simplePie->set_raw_data($feedContent);
		$simplePie->init();
		return $simplePie;
	}

	/** @return array<string,string> */
	private function dotNotationForStandardJsonFeed(): array {
		return [
			'feedTitle' => 'title',
			'feedImage' => 'icon',
			'feedImageFallback' => 'favicon',
			'item' => 'items',
			'itemTitle' => 'title',
			'itemContent' => 'content_text',
			'itemContentHTML' => 'content_html',
			'itemUri' => 'url',
			'itemTimestamp' => 'date_published',
			'itemTimeFormat' => DateTimeInterface::RFC3339_EXTENDED,
			'itemThumbnail' => 'image',
			'itemCategories' => 'tags',
			'itemUid' => 'id',
			'itemAttachment' => 'attachments',
			'itemAttachmentUrl' => 'url',
			'itemAttachmentType' => 'mime_type',
			'itemAttachmentLength' => 'size_in_bytes',
		];
	}

	private function extractJsonFromHtml(string $html): ?string {
		$xPathToJson = $this->attributeString('xPathToJson') ?? '';
		if ($xPathToJson === '') {
			return null;
		}

		$doc = new DOMDocument();
		$doc->recover = true;
		$doc->strictErrorChecking = false;
		if (!$doc->loadHTML($html, LIBXML_NONET | LIBXML_NOERROR | LIBXML_NOWARNING)) {
			return null;
		}

		$xpath = new DOMXPath($doc);
		$jsonFragments = @$xpath->evaluate($xPathToJson);
		if ($jsonFragments === false) {
			return null;
		}
		if (is_string($jsonFragments)) {
			return $jsonFragments;
		}
		if ($jsonFragments instanceof DOMNodeList && $jsonFragments->length > 0) {
			// If the result is a list, then aggregate as a JSON array
			$result = [];
			foreach ($jsonFragments as $node) {
				if (!($node instanceof DOMNode)) {
					continue;
				}
				$json = json_decode($node->textContent, true);
				if (json_last_error() === JSON_ERROR_NONE && is_array($json)) {
					$result[] = $json;
				}
			}
			return json_encode($result, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE) ?: null;
		}
		return null;
	}

	public function loadJson(): ?FreshRSS_SimplePieCustom {
		if ($this->url == '') {
			return null;
		}
		$feedSourceUrl = htmlspecialchars_decode($this->url, ENT_QUOTES);
		if ($feedSourceUrl == null) {
			return null;
		}

		$httpAccept = $this->kind() === FreshRSS_Feed::KIND_HTML_XPATH_JSON_DOTNOTATION ? 'html' : 'json';
		$content = FreshRSS_http_Util::httpGet($feedSourceUrl, $this->cacheFilename(), $httpAccept, $this->attributes(), $this->curlOptions())['body'];
		if (strlen($content) <= 0) {
			return null;
		}

		if ($this->kind() === FreshRSS_Feed::KIND_HTML_XPATH_JSON_DOTNOTATION) {
			$content = $this->extractJsonFromHtml($content);
			if ($content == null) {
				return null;
			}
		}

		//check if the content is actual JSON
		$jf = json_decode($content, true);
		if (json_last_error() !== JSON_ERROR_NONE || !is_array($jf)) {
			return null;
		}

		/** @var array<string,string> $json_dotnotation */
		$json_dotnotation = $this->attributeArray('json_dotnotation') ?? [];
		$dotnotations = $this->kind() === FreshRSS_Feed::KIND_JSONFEED ? $this->dotNotationForStandardJsonFeed() : $json_dotnotation;

		$feedContent = FreshRSS_dotNotation_Util::convertJsonToRss($jf, $feedSourceUrl, $dotnotations, $this->name());
		if ($feedContent == null) {
			return null;
		}
		return $this->simplePieFromContent($feedContent);
	}

	public function loadHtmlXpath(): ?FreshRSS_SimplePieCustom {
		if ($this->url == '') {
			return null;
		}
		$feedSourceUrl = htmlspecialchars_decode($this->url, ENT_QUOTES);
		if ($feedSourceUrl == null) {
			return null;
		}

		// Same naming conventions than https://rss-bridge.github.io/rss-bridge/Bridge_API/XPathAbstract.html
		// https://rss-bridge.github.io/rss-bridge/Bridge_API/BridgeAbstract.html#collectdata
		/** @var array<string,string> $xPathSettings */
		$xPathSettings = $this->attributeArray('xpath');
		$xPathFeedTitle = $xPathSettings['feedTitle'] ?? '';
		$xPathItem = $xPathSettings['item'] ?? '';
		$xPathItemTitle = $xPathSettings['itemTitle'] ?? '';
		$xPathItemContent = $xPathSettings['itemContent'] ?? '';
		$xPathItemUri = $xPathSettings['itemUri'] ?? '';
		$xPathItemAuthor = $xPathSettings['itemAuthor'] ?? '';
		$xPathItemTimestamp = $xPathSettings['itemTimestamp'] ?? '';
		$xPathItemTimeFormat = $xPathSettings['itemTimeFormat'] ?? '';
		$xPathItemThumbnail = $xPathSettings['itemThumbnail'] ?? '';
		$xPathItemCategories = $xPathSettings['itemCategories'] ?? '';
		$xPathItemUid = $xPathSettings['itemUid'] ?? '';
		if ($xPathItem == '') {
			return null;
		}

		$httpAccept = $this->kind() === FreshRSS_Feed::KIND_XML_XPATH ? 'xml' : 'html';
		$html = FreshRSS_http_Util::httpGet($feedSourceUrl, $this->cacheFilename(), $httpAccept, $this->attributes(), $this->curlOptions())['body'];
		if (strlen($html) <= 0) {
			return null;
		}

		$view = new FreshRSS_View();
		$view->_path('index/rss.phtml');
		$view->internal_rendering = true;
		$view->rss_url = htmlspecialchars($feedSourceUrl, ENT_COMPAT, 'UTF-8');
		$view->html_url = $view->rss_url;
		$view->entries = [];

		try {
			$doc = new DOMDocument();
			$doc->recover = true;
			$doc->strictErrorChecking = false;
			$ok = false;

			switch ($this->kind()) {
				case FreshRSS_Feed::KIND_HTML_XPATH:
					$ok = $doc->loadHTML($html, LIBXML_NONET | LIBXML_NOERROR | LIBXML_NOWARNING) !== false;
					break;
				case FreshRSS_Feed::KIND_XML_XPATH:
					$ok = $doc->loadXML($html, LIBXML_NONET | LIBXML_NOERROR | LIBXML_NOWARNING) !== false;
					break;
			}

			if (!$ok) {
				return null;
			}

			$xpath = new DOMXPath($doc);
			$xpathEvaluateString = function (string $expression, ?DOMNode $contextNode = null) use ($xpath): string {
				$result = @$xpath->evaluate('normalize-space(' . $expression . ')', $contextNode);
				return is_string($result) ? $result : '';
			};

			$view->rss_title = $xPathFeedTitle == '' ? $this->name() :
				htmlspecialchars($xpathEvaluateString($xPathFeedTitle), ENT_COMPAT, 'UTF-8');
			$view->rss_base = htmlspecialchars(trim($xpathEvaluateString('//base/@href')), ENT_COMPAT, 'UTF-8');
			$nodes = $xpath->query($xPathItem);
			if ($nodes === false || $nodes->length === 0) {
				return null;
			}

			foreach ($nodes as $node) {
				if (!($node instanceof DOMNode)) {
					continue;
				}
				$item = [];
				$item['title'] = $xPathItemTitle == '' ? '' : $xpathEvaluateString($xPathItemTitle, $node);

				$item['content'] = '';
				if ($xPathItemContent != '') {
					$result = @$xpath->evaluate($xPathItemContent, $node);
					if ($result instanceof DOMNodeList) {
						// List of nodes, save as HTML
						$content = '';
						foreach ($result as $child) {
							if ($child instanceof DOMNode) {
								$content .= $doc->saveHTML($child) . "\n";
							}
						}
						$item['content'] = $content;
					} elseif (is_string($result) || is_int($result) || is_bool($result)) {
						// Typed expression, save as-is
						$item['content'] = (string)$result;
					}
				}

				$item['link'] = $xPathItemUri == '' ? '' : $xpathEvaluateString($xPathItemUri, $node);
				$item['author'] = $xPathItemAuthor == '' ? '' : $xpathEvaluateString($xPathItemAuthor, $node);
				$item['timestamp'] = $xPathItemTimestamp == '' ? '' : $xpathEvaluateString($xPathItemTimestamp, $node);
				if ($xPathItemTimeFormat != '') {
					if ($xPathItemTimeFormat === 'U' && strlen($item['timestamp']) > 10) {
						// Compatibility with Unix timestamp in milliseconds
						$item['timestamp'] = substr($item['timestamp'], 0, -3);
					}
					$dateTime = DateTime::createFromFormat($xPathItemTimeFormat, $item['timestamp']);
					if ($dateTime != false) {
						$item['timestamp'] = $dateTime->format(DateTime::ATOM);
					}
				}
				$item['thumbnail'] = $xPathItemThumbnail == '' ? '' : $xpathEvaluateString($xPathItemThumbnail, $node);
				if ($xPathItemCategories != '') {
					$itemCategories = @$xpath->evaluate($xPathItemCategories, $node);
					if (is_string($itemCategories) && $itemCategories !== '') {
						$item['tags'] = [$itemCategories];
					} elseif ($itemCategories instanceof DOMNodeList && $itemCategories->length > 0) {
						$item['tags'] = [];
						foreach ($itemCategories as $itemCategory) {
							if ($itemCategory instanceof DOMNode) {
								$item['tags'][] = $itemCategory->textContent;
							}
						}
					}
				}
				if ($xPathItemUid != '') {
					$item['guid'] = $xpathEvaluateString($xPathItemUid, $node);
				}
				if (empty($item['guid'])) {
					$item['guid'] = 'urn:sha1:' . sha1($item['title'] . $item['content'] . $item['link']);
				}

				if ($item['title'] != '' || $item['content'] != '' || $item['link'] != '') {
					// HTML-encoding/escaping of the relevant fields (all except 'content')
					foreach (['author', 'guid', 'link', 'thumbnail', 'timestamp', 'title'] as $key) {
						if (isset($item[$key])) {
							$item[$key] = htmlspecialchars($item[$key], ENT_COMPAT, 'UTF-8');
						}
					}
					if (isset($item['tags'])) {
						$item['tags'] = Minz_Helper::htmlspecialchars_utf8($item['tags']);
					}
					// CDATA protection
					$item['content'] = str_replace(']]>', ']]&gt;', $item['content']);
					$view->entries[] = FreshRSS_Entry::fromArray($item);
				}
			}
		} catch (Exception $ex) {
			Minz_Log::warning($ex->getMessage());
			return null;
		}
		return $this->simplePieFromContent($view->renderToString());
	}

	/**
	 * @return int|null The max number of unread articles to keep, or null if disabled.
	 */
	public function keepMaxUnread(): ?int {
		$keepMaxUnread = $this->attributeInt('keep_max_n_unread');
		if ($keepMaxUnread === null) {
			$keepMaxUnread = FreshRSS_Context::userConf()->mark_when['max_n_unread'];
		}
		return is_int($keepMaxUnread) && $keepMaxUnread >= 0 ? $keepMaxUnread : null;
	}

	/**
	 * @return int|false The number of articles marked as read, of false if error
	 */
	public function markAsReadMaxUnread(): int|false {
		$keepMaxUnread = $this->keepMaxUnread();
		if ($keepMaxUnread === null) {
			return false;
		}
		$feedDAO = FreshRSS_Factory::createFeedDao();
		$affected = $feedDAO->markAsReadMaxUnread($this->id(), $keepMaxUnread);
		return $affected;
	}

	/**
	 * Applies the *mark as read upon gone* policy, if enabled.
	 * Remember to call `updateCachedValues($id_feed)` or `updateCachedValues()` just after.
	 * @return int|false the number of lines affected, or false if not applicable
	 */
	public function markAsReadUponGone(bool $upstreamIsEmpty, int $minLastSeen = 0): int|false {
		$readUponGone = $this->attributeBoolean('read_upon_gone');
		if ($readUponGone === null) {
			$readUponGone = FreshRSS_Context::userConf()->mark_when['gone'];
		}
		if (!$readUponGone) {
			return false;
		}
		if ($upstreamIsEmpty) {
			if ($minLastSeen <= 0) {
				$minLastSeen = time();
			}
			$entryDAO = FreshRSS_Factory::createEntryDao();
			$affected = $entryDAO->markReadFeed($this->id(), $minLastSeen . '000000');
		} else {
			$feedDAO = FreshRSS_Factory::createFeedDao();
			$affected = $feedDAO->markAsReadNotSeen($this->id(), $minLastSeen);
		}
		if ($affected > 0) {
			Minz_Log::debug(__METHOD__ . " $affected items" . ($upstreamIsEmpty ? ' (all)' : '') . ' [' . $this->url(includeCredentials: false) . ']');
		}
		return $affected;
	}

	/**
	 * Remember to call `updateCachedValues($id_feed)` or `updateCachedValues()` just after
	 */
	public function cleanOldEntries(): int|false {
		/** @var array<string,bool|int|string>|null $archiving */
		$archiving = $this->attributeArray('archiving');
		if ($archiving === null) {
			$catDAO = FreshRSS_Factory::createCategoryDao();
			$category = $catDAO->searchById($this->categoryId);
			$archiving = $category === null ? null : $category->attributeArray('archiving');
			/** @var array<string,bool|int|string>|null $archiving */
			if ($archiving === null) {
				$archiving = FreshRSS_Context::userConf()->archiving;
			}
		}
		if (is_array($archiving)) {
			$entryDAO = FreshRSS_Factory::createEntryDao();
			$nb = $entryDAO->cleanOldEntries($this->id(), $archiving);
			if ($nb > 0) {
				Minz_Log::debug($nb . ' entries cleaned in feed [' . $this->url(false) . '] with: ' . json_encode($archiving));
			}
			return $nb;
		}
		return false;
	}

	/**
	 * @param string $url Overridden URL. Will default to the feed URL.
	 * @throws FreshRSS_Context_Exception
	 */
	public function cacheFilename(string $url = ''): string {
		$simplePie = new FreshRSS_SimplePieCustom($this->attributes(), $this->curlOptions());
		if ($url !== '') {
			$filename = $simplePie->get_cache_filename($url);
			return CACHE_PATH . '/' . $filename . '.html';
		}
		$url = htmlspecialchars_decode($this->url);
		$filename = $simplePie->get_cache_filename($url);
		switch ($this->kind) {
			case FreshRSS_Feed::KIND_HTML_XPATH:
			case FreshRSS_Feed::KIND_HTML_XPATH_JSON_DOTNOTATION:
				return CACHE_PATH . '/' . $filename . '.html';
			case FreshRSS_Feed::KIND_XML_XPATH:
				return CACHE_PATH . '/' . $filename . '.xml';
			case FreshRSS_Feed::KIND_JSON_DOTNOTATION:
			case FreshRSS_Feed::KIND_JSON_XPATH:
			case FreshRSS_Feed::KIND_JSONFEED:
				return CACHE_PATH . '/' . $filename . '.json';
			case FreshRSS_Feed::KIND_RSS:
			case FreshRSS_Feed::KIND_RSS_FORCED:
				return CACHE_PATH . '/' . $filename . '.spc';
			default:
				return CACHE_PATH . '/' . $filename . '.raw';
		}
	}

	private function faviconRebuild(): void {
		if ($this->customFavicon()) {
			return;
		}
		FreshRSS_Feed::faviconDelete($this->hashFavicon());
		$this->faviconPrepare(true);
	}

	public function clearCache(): bool {
		$this->faviconRebuild();
		return @unlink($this->cacheFilename());
	}

	/** @return int|false */
	public function cacheModifiedTime(): int|false {
		$filename = $this->cacheFilename();
		clearstatcache(true, $filename);
		return @filemtime($filename);
	}

	public function lock(): bool {
		$this->lockPath = TMP_PATH . '/' . $this->hash() . '.freshrss.lock';
		if (file_exists($this->lockPath) && ((time() - (@filemtime($this->lockPath) ?: 0)) > 3600)) {
			@unlink($this->lockPath);
		}
		if (($handle = @fopen($this->lockPath, 'x')) === false) {
			return false;
		}
		//register_shutdown_function('unlink', $this->lockPath);
		@fclose($handle);
		return true;
	}

	public function unlock(): bool {
		return @unlink($this->lockPath);
	}

	//<WebSub>

	/**
	 * WebSub subscription state for the current user, or false when not subscribed
	 * @return array<string,mixed>|false
	 */
	private function pubSubHubbubState(): array|false {
		$currentUser = Minz_User::name() ?? '';
		if ($currentUser === '') {
			return false;
		}
		$url = $this->selfUrl ?: $this->url;
		$path = PSHB_PATH . '/feeds/' . sha1($url);
		if (($hubFile = @file_get_contents($path . '/!hub.json')) != false) {
			/** @var array<string,mixed> $hubJson */
			$hubJson = json_decode($hubFile, true);
			if (is_array($hubJson) &&
				(empty($hubJson['lease_end']) || $hubJson['lease_end'] > time()) &&
				file_exists($path . '/' . $currentUser . '.txt')) {
				return $hubJson;
			}
		}
		return false;
	}

	/**
	 * Whether WebSub is activated for this feed and this user, and validated by a successfully received push
	 */
	public function pubSubHubbubEnabled(): bool {
		$hubJson = $this->pubSubHubbubState();
		return is_array($hubJson) && empty($hubJson['error']);
	}

	/**
	 * Whether WebSub is activated for this feed and this user, but waiting for first successful push
	 */
	public function pubSubHubbubPending(): bool {
		$hubJson = $this->pubSubHubbubState();
		return is_array($hubJson) && !empty($hubJson['error']);
	}

	public function pubSubHubbubError(bool $error = true): bool {
		$url = $this->selfUrl ?: $this->url;
		$hubFilename = PSHB_PATH . '/feeds/' . sha1($url) . '/!hub.json';
		$hubFile = @file_get_contents($hubFilename);
		$hubJson = is_string($hubFile) ? json_decode($hubFile, true) : null;
		if (is_array($hubJson) && (!isset($hubJson['error']) || $hubJson['error'] !== $error)) {
			$hubJson['error'] = $error;
			file_put_contents($hubFilename, json_encode($hubJson));
			Minz_Log::warning('Set error to ' . ($error ? 1 : 0) . ' for ' . $url, PSHB_LOG);
		}
		return false;
	}

	private static function isSameHost(string $url1, string $url2): bool {
		$hubHost  = parse_url($url1, PHP_URL_HOST);
		$baseHost = parse_url($url2, PHP_URL_HOST);
		return ($hubHost != null && $baseHost != null && strcasecmp($hubHost, $baseHost) === 0);
	}

	public function pubSubHubbubPrepare(): string|false {
		$key = '';
		$baseUrl = FreshRSS_Context::systemConf()->base_url;
		// If they have the same host, they can reach each other (e.g., localhost to localhost)
		if ((Minz_Request::serverIsPublic($baseUrl) || self::isSameHost($this->hubUrl, $baseUrl)) &&
			$this->hubUrl !== '' && $this->selfUrl !== '' && @is_dir(PSHB_PATH)) {
			$path = PSHB_PATH . '/feeds/' . sha1($this->selfUrl);
			$hubFilename = $path . '/!hub.json';
			$currentUser = Minz_User::name() ?? '';
			if (($hubFile = @file_get_contents($hubFilename)) != false) {
				$hubJson = json_decode($hubFile, true);
				if (!is_array($hubJson) || empty($hubJson['key']) || !is_string($hubJson['key']) || !ctype_xdigit($hubJson['key'])) {
					$text = 'Invalid JSON for WebSub: ' . $this->url;
					Minz_Log::warning($text);
					Minz_Log::warning($text, PSHB_LOG);
					return false;
				}
				if (($hubJson['hub'] ?? null) !== $this->hubUrl) {
					if (FreshRSS_user_Controller::checkUsername($currentUser) && file_exists($path . '/' . $currentUser . '.txt')) {
						unlink($path . '/' . $currentUser . '.txt');
					}
					$text = 'WebSub: Hub ' . $this->hubUrl . ' currently advertised by ' . $this->url .
						' does not match the hub file! Not subscribing ' . $currentUser;
					Minz_Log::warning($text);
					Minz_Log::warning($text, PSHB_LOG);
					return false;
				}
				if (!empty($hubJson['lease_end']) && is_int($hubJson['lease_end']) && $hubJson['lease_end'] < (time() + (3600 * 23))) {	//TODO: Make a better policy
					$text = 'WebSub lease ends at '
						. date('c', empty($hubJson['lease_end']) ? time() : $hubJson['lease_end'])
						. ' and needs renewal: ' . $this->url;
					Minz_Log::warning($text);
					Minz_Log::warning($text, PSHB_LOG);
					$key = $hubJson['key'];	//To renew our lease
				} elseif (((!empty($hubJson['error'])) || empty($hubJson['lease_end'])) &&
					(empty($hubJson['lease_start']) || $hubJson['lease_start'] < time() - (3600 * 23))) {	//Do not renew too often
					$key = $hubJson['key'];	//To renew our lease
				}
			} else {	// First-time subscription
				@mkdir($path, 0770, true);
				$key = bin2hex(random_bytes(32));
				$hubJson = [
					'hub' => $this->hubUrl,
					'key' => $key,
				];
				// hub.secret SHOULD only be specified when the request was made over HTTPS
				// https://www.w3.org/TR/websub/#subscription-parameter-details
				if (str_starts_with(strtolower($this->hubUrl), 'https://')) {
					$hubJson['secret'] = bin2hex(random_bytes(32));	// length < 200
				}
				file_put_contents($hubFilename, json_encode($hubJson));
				@mkdir(PSHB_PATH . '/keys/', 0770, true);
				file_put_contents(PSHB_PATH . '/keys/' . $key . '.txt', $this->selfUrl);
				$text = 'WebSub prepared for ' . $this->url;
				Minz_Log::debug($text);
				Minz_Log::debug($text, PSHB_LOG);
			}
			if (FreshRSS_user_Controller::checkUsername($currentUser) && !file_exists($path . '/' . $currentUser . '.txt')) {
				touch($path . '/' . $currentUser . '.txt');
			}
		}
		return $key;
	}

	//Parameter true to subscribe, false to unsubscribe.
	public function pubSubHubbubSubscribe(bool $state): bool {
		if ($state) {
			$url = $this->selfUrl ?: $this->url;
		} else {
			$url = $this->url;	//Always use current URL during unsubscribe
		}
		$baseUrl = FreshRSS_Context::systemConf()->base_url;
		// If they have the same host, they can reach each other (e.g., localhost to localhost)
		if ($url !== '' && (Minz_Request::serverIsPublic($baseUrl) || self::isSameHost($url, $baseUrl) || !$state)) {
			$hubFilename = PSHB_PATH . '/feeds/' . sha1($url) . '/!hub.json';
			$hubFile = @file_get_contents($hubFilename);
			if ($hubFile === false) {
				Minz_Log::warning('JSON not found for WebSub: ' . $this->url);
				return false;
			}
			$hubJson = json_decode($hubFile, true);
			if (!is_array($hubJson) || empty($hubJson['key']) || !is_string($hubJson['key']) || !ctype_xdigit($hubJson['key']) ||
				empty($hubJson['hub']) || !is_string($hubJson['hub'])) {
				Minz_Log::warning('Invalid JSON for WebSub: ' . $this->url);
				return false;
			}
			$callbackUrl = FreshRSS_http_Util::checkUrl(Minz_Request::getBaseUrl() . '/api/pshb.php?k=' . $hubJson['key']);
			if ($callbackUrl == '') {
				Minz_Log::warning('Invalid callback for WebSub: ' . $this->url);
				return false;
			}
			$postFields = [
				'hub.verify' => 'sync',
				'hub.mode' => $state ? 'subscribe' : 'unsubscribe',
				'hub.topic' => $url,
				'hub.callback' => $callbackUrl,
			];
			$newSecret = null;
			if ($state) {	// Subscribe
				// Legacy (before support of hub.secret) case of renewing an unsigned subscription.
				// hub.secret SHOULD only be specified when the request was made over HTTPS
				if (str_starts_with(strtolower($hubJson['hub']), 'https://')) {
					if (empty($hubJson['secret']) || !is_string($hubJson['secret'])) {
						// We keep the existing subscription (without secret) until the hub confirmation.
						$newSecret = bin2hex(random_bytes(32));	// length < 200
						$postFields['hub.secret'] = $newSecret;
					} else {
						$postFields['hub.secret'] = $hubJson['secret'];
					}
				}
			}
			if (!$state) {	// Unsubscribe
				$hubJson['lease_end'] = time() - 60;
				file_put_contents($hubFilename, json_encode($hubJson));
			}
			$response = FreshRSS_http_Util::httpGet($hubJson['hub'], null, 'html', [], [
				CURLOPT_POSTFIELDS => http_build_query($postFields),
				CURLOPT_MAXREDIRS => 10,
			]);

			Minz_Log::warning('WebSub ' . ($state ? 'subscribe' : 'unsubscribe') . ' to ' . $url .
				' via hub ' . $hubJson['hub'] .
				' with callback ' . $callbackUrl . ': ' . $response['status'] . ' ' . $response['body'], PSHB_LOG);

			if ($response['method'] === 'POST' && str_starts_with('' . $response['status'], '2')) {
				if ($newSecret !== null) {	// Legacy (before support of hub.secret) case.
					// Reload because hub verification (hub.verify=sync) may have updated $hubFile in the meantime
					$hJson = json_decode((string)@file_get_contents($hubFilename), true);
					if (is_array($hJson)) {
						// Save secret only after hub confirmation
						$hJson['secret'] = $newSecret;
						file_put_contents($hubFilename, json_encode($hJson));
					} else {
						Minz_Log::warning('Could not save hub.secret for WebSub: ' . $this->url, PSHB_LOG);
					}
				}
				return true;
			} else {
				$hubJson['lease_start'] = time();	//Prevent trying again too soon
				$hubJson['error'] = true;
				file_put_contents($hubFilename, json_encode($hubJson));
				return false;
			}
		}
		return false;
	}

	//</WebSub>
}