<?php

/***************************************************************************\
 *  SPIP, Système de publication pour l'internet                           *
 *                                                                         *
 *  Copyright © avec tendresse depuis 2001                                 *
 *  Arnaud Martin, Antoine Pitrou, Philippe Rivière, Emmanuel Saint-James  *
 *                                                                         *
 *  Ce programme est un logiciel libre distribué sous licence GNU/GPL.     *
\***************************************************************************/

use Spip\Afficher\Minipage\Admin as MinipageAdmin;

if (!defined('_ECRIRE_INC_VERSION')) {
	return;
}

/**
 * Le format souhaite : tmp/cache/ab/cd
 * soit au maximum 16^4 fichiers dans 256 repertoires
 * Attention a modifier simultanement le sanity check de
 * la fonction retire_cache() de inc/invalideur
 *
 * @param array $contexte
 * @param array $page
 * @return string
 */
function generer_nom_fichier_cache($contexte, $page) {
	$u = md5(var_export([$contexte, $page], true));

	return $u . '.cache';
}

/**
 * Calcule le chemin hashe du fichier cache
 * Le format souhaite : tmp/cache/ab/cd
 * soit au maximum 16^4 fichiers dans 256 repertoires
 * mais la longueur est configurable via un define qui permer d'avoir une taille de 16^_CACHE_PROFONDEUR_STOCKAGE
 *
 * Attention a modifier simultanement le sanity check de
 * la fonction retire_cache() de inc/invalideur
 *
 * @return string
 */
function cache_chemin_fichier($nom_cache, $ecrire = false) {
	static $l1, $l2;
	if ($l1 === null) {
		$length = (defined('_CACHE_PROFONDEUR_STOCKAGE') ? min(8, max(_CACHE_PROFONDEUR_STOCKAGE, 2)) : 4);
		$l1 = intval(floor($length / 2));
		$l2 = $length - $l1;
	}
	$d = substr($nom_cache, 0, $l1);
	$u = substr($nom_cache, $l1, $l2);

	if ($ecrire) {
		$rep = sous_repertoire(_DIR_CACHE, '', false, true);
		$rep = sous_repertoire($rep, 'calcul/', false, true);
		$rep = sous_repertoire($rep, $d, false, true);
	} else {
		// en lecture on essaye pas de creer les repertoires, on va au plus vite
		$rep = _DIR_CACHE . "calcul/$d/";
	}

	return $rep . $u . '.cache';
}

/**
 * ecrire le cache dans un casier
 *
 * @param string $nom_cache
 * @return bool
 */
function ecrire_cache($nom_cache, $valeur) {
	return ecrire_fichier(
		cache_chemin_fichier($nom_cache, true),
		serialize(['nom_cache' => $nom_cache, 'valeur' => $valeur])
	);
}

/**
 * lire le cache depuis un casier
 *
 * @param string $nom_cache
 * @return mixed
 */
function lire_cache($nom_cache) {
	$tmp = [];
	if (
		file_exists($f = cache_chemin_fichier($nom_cache))
		and lire_fichier($f, $tmp)
		and $tmp = unserialize($tmp)
		and $tmp['nom_cache'] == $nom_cache
		and isset($tmp['valeur'])
	) {
		return $tmp['valeur'];
	}

	return false;
}

function supprime_fichier_cache($nom_cache) {
	return supprimer_fichier(cache_chemin_fichier($nom_cache));
}

// Parano : on signe le cache, afin d'interdire un hack d'injection
// dans notre memcache
function cache_signature(&$page) {
	if (!isset($GLOBALS['meta']['cache_signature'])) {
		include_spip('inc/acces');
		include_spip('auth/sha256.inc');
		ecrire_meta(
			'cache_signature',
			spip_sha256($_SERVER['DOCUMENT_ROOT'] . ($_SERVER['SERVER_SIGNATURE'] ?? '') . creer_uniqid()),
			'non'
		);
	}

	return crc32($GLOBALS['meta']['cache_signature'] . $page['texte']);
}

/**
 * Faut-il compresser ce cache ? A partir de 16ko ca vaut le coup
 * (pas de passage par reference car on veut conserver la version non compressee
 * pour l'afficher)
 * on positionne un flag gz si on comprime, pour savoir si on doit decompresser ou pas
 *
 * @param array $page
 * @return array
 */
function gzip_page($page) {
	if (function_exists('gzcompress') and strlen($page['texte']) > 16 * 1024) {
		$page['gz'] = true;
		$page['texte'] = gzcompress($page['texte']);
	} else {
		$page['gz'] = false;
	}

	return $page;
}

/**
 * Faut-il decompresser ce cache ?
 * (passage par reference pour alleger)
 * on met a jour le flag gz quand on decompresse, pour ne pas risquer
 * de decompresser deux fois de suite un cache (ce qui echoue)
 *
 * @param array $page
 */
function gunzip_page(&$page) {
	if ($page['gz']) {
		$page['texte'] = gzuncompress($page['texte']);
		$page['gz'] = false; // ne pas gzuncompress deux fois une meme page
	}
}

/**
 * gestion des delais d'expiration du cache...
 * $page passee par reference pour accelerer
 *
 * @param array $page
 * @param int $date
 * @return int
 * 1 si il faut mettre le cache a jour
 * 0 si le cache est valide
 * -1 si il faut calculer sans stocker en cache
 */
function cache_valide(&$page, $date) {
	$now = $_SERVER['REQUEST_TIME'];

	// Apparition d'un nouvel article post-date ?
	if (
		isset($GLOBALS['meta']['post_dates'])
		and $GLOBALS['meta']['post_dates'] == 'non'
		and isset($GLOBALS['meta']['date_prochain_postdate'])
		and $now > $GLOBALS['meta']['date_prochain_postdate']
	) {
		spip_log('Un article post-date invalide le cache');
		include_spip('inc/rubriques');
		calculer_prochain_postdate(true);
	}

	if (defined('_VAR_NOCACHE') and _VAR_NOCACHE) {
		return -1;
	}
	if (isset($GLOBALS['meta']['cache_inhib']) and $_SERVER['REQUEST_TIME'] < $GLOBALS['meta']['cache_inhib']) {
		return -1;
	}
	if (defined('_NO_CACHE')) {
		return (_NO_CACHE == 0 and !isset($page['texte'])) ? 1 : _NO_CACHE;
	}

	// pas de cache ? on le met a jour, sauf pour les bots (on leur calcule la page sans mise en cache)
	if (!$page or !isset($page['texte']) or !isset($page['entetes']['X-Spip-Cache'])) {
		return _IS_BOT ? -1 : 1;
	}

	// controle de la signature
	if ($page['sig'] !== cache_signature($page)) {
		return _IS_BOT ? -1 : 1;
	}

	// #CACHE{n,statique} => on n'invalide pas avec derniere_modif
	// cf. ecrire/public/balises.php, balise_CACHE_dist()
	if (!isset($page['entetes']['X-Spip-Statique']) or $page['entetes']['X-Spip-Statique'] !== 'oui') {
		// Cache invalide par la meta 'derniere_modif'
		// sauf pour les bots, qui utilisent toujours le cache
		if (
			!_IS_BOT
			and $GLOBALS['derniere_modif_invalide']
			and isset($GLOBALS['meta']['derniere_modif'])
			and $date < $GLOBALS['meta']['derniere_modif']
		) {
			return 1;
		}
	}

	// Sinon comparer l'age du fichier a sa duree de cache
	$duree = (int) $page['entetes']['X-Spip-Cache'];
	$cache_mark = max($GLOBALS['meta']['cache_mark'] ?? 0, $GLOBALS['meta']['cache_bot_invalide'] ?? 0);
	if ($duree == 0) {  #CACHE{0}
		return -1;
	} // sauf pour les bots, qui utilisent toujours le cache

	if (
		(!_IS_BOT and $date + $duree < $now)
		# le cache est anterieur a la derniere purge : l'ignorer, meme pour les bots
		or $date < $cache_mark
	) {
		return _IS_BOT ? -1 : 1;
	}
	return 0;

}

/**
 * Creer le fichier cache
 * Passage par reference de $page par souci d'economie
 *
 * @param array $page
 * @param string $chemin_cache
 */
function creer_cache(&$page, &$chemin_cache) {

	// Ne rien faire si on est en preview, debug, ou si une erreur
	// grave s'est presentee (compilation du squelette, MySQL, etc)
	// le cas var_nocache ne devrait jamais arriver ici (securite)
	// le cas spip_interdire_cache correspond a une ereur SQL grave non anticipable
	if (
		(defined('_VAR_NOCACHE') and _VAR_NOCACHE)
		or defined('spip_interdire_cache')
	) {
		return;
	}

	// Si la page c1234 a un invalideur de session 'zz', sauver dans
	// 'tmp/cache/MD5(chemin_cache)_zz'
	if (
		isset($page['invalideurs'])
		and isset($page['invalideurs']['session'])
	) {
		// on verifie que le contenu du chemin cache indique seulement
		// "cache sessionne" ; sa date indique la date de validite
		// des caches sessionnes
		if (!$tmp = lire_cache($chemin_cache)) {
			spip_log('Creation cache sessionne ' . $chemin_cache);
			$tmp = [
				'invalideurs' => ['session' => ''],
				'lastmodified' => $_SERVER['REQUEST_TIME'],
			];
			ecrire_cache($chemin_cache, $tmp);
		}
		$chemin_cache = generer_nom_fichier_cache(
			['chemin_cache' => $chemin_cache],
			['session' => $page['invalideurs']['session']]
		);
	}

	// ajouter la date de production dans le cache lui meme
	// (qui contient deja sa duree de validite)
	$page['lastmodified'] = $_SERVER['REQUEST_TIME'];

	// compresser le contenu si besoin
	$pagez = gzip_page($page);

	// signer le contenu
	$pagez['sig'] = cache_signature($pagez);

	// l'enregistrer, compresse ou non...
	$ok = ecrire_cache($chemin_cache, $pagez);

	spip_log((_IS_BOT ? 'Bot:' : '') . "Creation du cache $chemin_cache pour "
		. $page['entetes']['X-Spip-Cache'] . ' secondes' . ($ok ? '' : ' (erreur!)'), _LOG_INFO);

	// Inserer ses invalideurs
	include_spip('inc/invalideur');
	maj_invalideurs($chemin_cache, $page);
}

/**
 * purger un petit cache (tidy ou recherche) qui ne doit pas contenir de
 * vieux fichiers ; (cette fonction ne sert que dans des plugins obsoletes)
 *
 * @param string $prefix
 * @param int $duree
 */
function nettoyer_petit_cache($prefix, $duree = 300) {
	// determiner le repertoire a purger : 'tmp/CACHE/rech/'
	$dircache = sous_repertoire(_DIR_CACHE, $prefix);
	if (spip_touch($dircache . 'purger_' . $prefix, $duree, true)) {
		foreach (preg_files($dircache, '[.]txt$') as $f) {
			if ($duree < $_SERVER['REQUEST_TIME'] - (@file_exists($f) ? @filemtime($f) : 0)) {
				spip_unlink($f);
			}
		}
	}
}

/**
 * Interface du gestionnaire de cache
 * Si son 3e argument est non vide, elle passe la main a creer_cache
 * Sinon, elle recoit un contexte (ou le construit a partir de REQUEST_URI)
 * et affecte les 4 autres parametres recus par reference:
 * - use_cache qui vaut
 *     -1 s'il faut calculer la page sans la mettre en cache
 *      0 si on peut utiliser un cache existant
 *      1 s'il faut calculer la page et la mettre en cache
 * - chemin_cache qui est le chemin d'acces au fichier ou vide si pas cachable
 * - page qui est le tableau decrivant la page, si le cache la contenait
 * - lastmodified qui vaut la date de derniere modif du fichier.
 * Elle retourne '' si tout va bien
 * un message d'erreur si le calcul de la page est totalement impossible
 *
 * @param array $contexte
 * @param int $use_cache
 * @param string $chemin_cache
 * @param array $page
 * @param int $lastmodified
 * @return string|void
 */
function public_cacher_dist($contexte, &$use_cache, &$chemin_cache, &$page, &$lastmodified) {

	# fonction de cache minimale : dire "non on ne met rien en cache"
	# $use_cache = -1; return;

	// Second appel, destine a l'enregistrement du cache sur le disque
	if (isset($chemin_cache)) {
		creer_cache($page, $chemin_cache);
		return;
	}

	// Toute la suite correspond au premier appel
	$contexte_implicite = $page['contexte_implicite'];

	// Cas ignorant le cache car completement dynamique
	if (
		(!empty($_SERVER['REQUEST_METHOD']) and $_SERVER['REQUEST_METHOD'] === 'POST')
		or _request('connect')
	) {
		$use_cache = -1;
		$lastmodified = 0;
		$chemin_cache = '';
		$page = [];

		return;
	}

	// Controler l'existence d'un cache nous correspondant
	$chemin_cache = generer_nom_fichier_cache($contexte, $page);
	$lastmodified = 0;

	// charger le cache s'il existe (et si il a bien le bon hash = anticollision)
	if (!$page = lire_cache($chemin_cache)) {
		$page = [];
	}

	// s'il est sessionne, charger celui correspondant a notre session
	if (
		isset($page['invalideurs'])
		and isset($page['invalideurs']['session'])
	) {
		$chemin_cache_session = generer_nom_fichier_cache(
			['chemin_cache' => $chemin_cache],
			['session' => spip_session()]
		);
		if (
			$page_session = lire_cache($chemin_cache_session)
			and $page_session['lastmodified'] >= $page['lastmodified']
		) {
			$page = $page_session;
		} else {
			$page = [];
		}
	}

	// Faut-il effacer des pages invalidees (en particulier ce cache-ci) ?
	if (isset($GLOBALS['meta']['invalider'])) {
		// ne le faire que si la base est disponible
		if (spip_connect()) {
			include_spip('inc/invalideur');
			retire_caches($chemin_cache); # API invalideur inutile
			supprime_fichier_cache($chemin_cache);
			if (isset($chemin_cache_session) and $chemin_cache_session) {
				supprime_fichier_cache($chemin_cache_session);
			}
		}
	}

	// Si un calcul, recalcul [ou preview, mais c'est recalcul] est demande,
	// on supprime le cache
	if (
		defined('_VAR_MODE') &&
		_VAR_MODE &&
		(isset($_COOKIE['spip_session']) ||
			isset($_COOKIE['spip_admin']) ||
			@file_exists(_ACCESS_FILE_NAME))
	) {
		$page = ['contexte_implicite' => $contexte_implicite]; // ignorer le cache deja lu
		include_spip('inc/invalideur');
		retire_caches($chemin_cache); # API invalideur inutile
		supprime_fichier_cache($chemin_cache);
		if (isset($chemin_cache_session) and $chemin_cache_session) {
			supprime_fichier_cache($chemin_cache_session);
		}
	}

	// $delais par defaut
	// pour toutes les pages sans #CACHE{} hors modeles/ et espace privé
	// qui sont a cache nul par defaut
	if (!isset($GLOBALS['delais'])) {
		if (!defined('_DUREE_CACHE_DEFAUT')) {
			define('_DUREE_CACHE_DEFAUT', 24 * 3600);
		}
		$GLOBALS['delais'] = _DUREE_CACHE_DEFAUT;
	}

	// determiner la validite de la page
	if ($page) {
		$use_cache = cache_valide($page, $page['lastmodified'] ?? 0);
		// le contexte implicite n'est pas stocke dans le cache, mais il y a equivalence
		// par le nom du cache. On le reinjecte donc ici pour utilisation eventuelle au calcul
		$page['contexte_implicite'] = $contexte_implicite;
		if (!$use_cache) {
			// $page est un cache utilisable
			gunzip_page($page);

			return;
		}
	} else {
		$page = ['contexte_implicite' => $contexte_implicite];
		$use_cache = cache_valide($page, 0); // fichier cache absent : provoque le calcul
	}

	// Si pas valide mais pas de connexion a la base, le garder quand meme
	if (!spip_connect()) {
		if (isset($page['texte'])) {
			gunzip_page($page);
			$use_cache = 0;
		} else {
			spip_log("Erreur base de donnees, impossible utiliser $chemin_cache");
			$minipage = new MinipageAdmin();

			return $minipage->page(_T('titre_probleme_technique'), ['titre' => _T('info_travaux_titre'), 'status' => 503]);
		}
	}

	if ($use_cache < 0) {
		$chemin_cache = '';
	}

	return;
}
