";





		// Polices liées au thème
		$used = [
			'Bannière' 		=> $this->getData (['theme', 'header', 'font']),
			'Menu' 			=> $this->getData (['theme', 'menu', 'font']),
			'Titre ' 		=> $this->getData (['theme', 'title', 'font']),
			'Texte'   		=> $this->getData (['theme', 'text', 'font']),
			'Pied de page' 	=> $this->getData (['theme', 'footer', 'font']),
			'Titre (admin)' => $this->getData (['admin', 'fontTitle' ]),
			'Admin (texte)' => $this->getData (['admin', 'fontText' ])
		];

		// Parcourir les fontes disponibles et construire le tableau pour le formulaire
		foreach ($fonts as $fontId => $fontName) {

			// Fontes utilisées par les thèmes
			$fontUsed[$fontId] = '';
			foreach ($used as $key => $value) {
				if ( $value === $fontId) {
					$fontUsed[$fontId] .=  $key . '
';
				}
			}


			self::$fontsList [] = [
				'' . $fontName . '' ,
				$fontId,
				$fontUsed[$fontId],
				//array_key_exists($fontId, $fonts['imported']) ? 'Importée' : '',
				array_key_exists($fontId, $fonts['files']) ?
							 $fonts['files'][$fontId] : 
							 (array_key_exists($fontId, self::$fontsWebSafe) ? 'WebSafe' :	'CDN Fonts'),
				array_key_exists($fontId, $fonts['imported']) || array_key_exists($fontId, $fonts['files'])
					? 	template::button('themeFontDelete' . $fontId, [
							'class' => 'themeFontDelete buttonRed',
							'href' => helper::baseUrl() . $this->getUrl(0) . '/fontDelete/' . $fontId . '/' . $_SESSION['csrf'],
							'value' => template::ico('cancel'),
							'disabled' => !empty($fontUsed[$fontId])
						])
					: ''
			];
		}
		// Valeurs en sortie
		$this->addOutput([
			'title' => 'Gestion des fontes',
			'view' => 'fonts'
		]);
	}

	/**
	 * Ajouter une fonte
	 */
	public function fontAdd() {
		// Soumission du formulaire
		if ($this->isPost()) {

			$fontId = $this->getInput('fontAddFontId', null, true);
			$fontName = $this->getInput('fontAddFontName', null, true);
			$filePath = $this->getInput('fontAddFile', null);
			$e = explode ('/', $filePath);
			$file = $e[count($e) - 1 ];

			// Vérifier l'existence de fontId et validité de family namesi usage en ligne de cdnFonts
			$data = helper::getUrlContents('https://www.cdnfonts.com/' . $fontId . '.font');

			if ( $filePath === ''
				 && $fontName !== ''
				 && strpos($data, $fontName) === false
			) {

				// Valeurs en sortie
				$this->addOutput([
					'notification' => 'Erreur de nom de fonte ou d\'identifiant',
					'redirect' => helper::baseUrl() . 'theme/fontAdd',
					'state' => false
				]);

			} else {

				// Charger les données des fontes
				$files = $this->getData(['fonts', 'files']);
				$imported = $this->getData(['fonts', 'imported']);

				// Concaténation dans les tableaux existants
				$imported = array_merge([$fontId => $fontName], $imported);
				$files = array_merge([$fontId => $file], $files);

				// Copier la fonte si le nom du fichier est fourni
				if (!empty($filePath)) {
					copy ( self::FILE_DIR . 'source/' . $filePath, self::DATA_DIR . 'fonts/' . $file );
				}

				// Mettre à jour le fichier des fontes
				$this->setData(['fonts', 'imported', $imported ]);
				if (!empty($filePath) ) {
					$this->setData(['fonts', 'files', $files ]);
				}

				// Valeurs en sortie
				$this->addOutput([
					'notification' => 'La fonte a été importée',
					'redirect' => helper::baseUrl() . 'theme/fonts',
					'state' => true
				]);
			}
		}
		// Valeurs en sortie
		$this->addOutput([
			'title' => 'Ajouter une fonte',
			'view' => 'fontAdd'
		]);
	}

	/**
	 * Effacer une fonte
	 */
	public function fontDelete() {
		// Jeton incorrect
		if ($this->getUrl(3) !== $_SESSION['csrf']) {
			// Valeurs en sortie
			$this->addOutput([
				'redirect' => helper::baseUrl()  . 'theme/fonts',
				'notification' => 'Action non autorisée'
			]);
		}
		// Suppression
		else {

			// Charger les données des fontes
			$files = $this->getData(['fonts', 'files']);
			$imported = $this->getData(['fonts', 'imported']);

			// Effacer le fichier existant
			if ( file_exists(self::DATA_DIR . $files[$this->getUrl(2)]) ) {
				unlink(self::DATA_DIR . $files[$this->getUrl(2)]);
			}

			// Supprimer les entrées
			unset($files[$this->getUrl(2)]);
			unset($imported[$this->getUrl(2)]);

			// Mettre à jour le fichier des fontes
			$this->setData(['fonts', 'files', $files ]);
			$this->setData(['fonts', 'imported', $imported ]);
			// Valeurs en sortie
			$this->addOutput([
				'redirect' => helper::baseUrl()  . 'theme/fonts',
				'notification' => 'Fonte supprimée',
				'state' => true
			]);
		}
	}


	/**
	 * Réinitialisation de la personnalisation avancée
	 */
	public function reset() {
		// $url prend l'adresse sans le token
		$url = explode('&',$this->getUrl(2));

		if  ( isset($_GET['csrf'])
			 AND $_GET['csrf'] === $_SESSION['csrf']
			) {
			// Réinitialisation
			$redirect ='';
			switch ($url[0]) {
				case 'admin':
					$this->initData('admin');
					$redirect = helper::baseUrl() . 'theme/admin';
					break;
				case 'manage':
					$this->initData('theme');
					$redirect = helper::baseUrl() . 'theme/manage';
					break;
				case 'custom':
					unlink(self::DATA_DIR.'custom.css');
					$redirect = helper::baseUrl() . 'theme/advanced';
					break;
				default :
					$redirect = helper::baseUrl() . 'theme';
			}

			// Valeurs en sortie
			$this->addOutput([
				'notification' => 'Réinitialisation effectuée',
				'redirect' => $redirect,
				'state' => true
			]);
		} else {
			// Valeurs en sortie
			$this->addOutput([
				'notification' => 'Jeton incorrect'
			]);
		}
	}


	/**
	 * Options du site
	 */
	public function site() {
		// Soumission du formulaire
		if($this->isPost()) {
			$this->setData(['theme', 'title', [
				'font' => $this->getInput('themeTitleFont'),
				'textColor' => $this->getInput('themeTitleTextColor'),
				'fontWeight' => $this->getInput('themeTitleFontWeight'),
				'textTransform' => $this->getInput('themeTitleTextTransform')
			]]);
			$this->setData(['theme', 'text', [
				'font' => $this->getInput('themeTextFont'),
				'fontSize' => $this->getInput('themeTextFontSize'),
				'textColor' => $this->getInput('themeTextTextColor'),
				'linkColor'=> $this->getInput('themeTextLinkColor')
			]]);
			$this->setData(['theme', 'site', [
				'backgroundColor' => $this->getInput('themeSiteBackgroundColor'),
				'radius' => $this->getInput('themeSiteRadius'),
				'shadow' => $this->getInput('themeSiteShadow'),
				'width' => $this->getInput('themeSiteWidth'),
				'margin' => $this->getInput('themeSiteMargin',helper::FILTER_BOOLEAN)
			]]);
			$this->setData(['theme', 'button', [
				'backgroundColor' => $this->getInput('themeButtonBackgroundColor')
			]]);
			$this->setData(['theme', 'block', [
				'backgroundColor' => $this->getInput('themeBlockBackgroundColor'),
				'borderColor' => $this->getInput('themeBlockBorderColor')
			]]);
			// Valeurs en sortie
			$this->addOutput([
				'notification' => 'Modifications enregistrées',
				'redirect' => helper::baseUrl() . 'theme',
				'state' => true
			]);
		}
		// Lire les fontes installées
		$this->enumFonts();
		// Valeurs en sortie
		$this->addOutput([
			'title' => 'Personnalisation du site',
			'vendor' => [
				'tinycolorpicker',
				'tinymce'
			],
			'view' => 'site'
		]);
	}

	/**
	 * Import du thème
	 */
	public function manage() {
		if($this->isPost() ) {

			$zipFilename =	$this->getInput('themeManageImport', helper::FILTER_STRING_SHORT, true);
			$data = $this->import(self::FILE_DIR.'source/' . $zipFilename);
			if ($data['success']) {
				header("Refresh:0");
			} else {
				// Valeurs en sortie
				$this->addOutput([
					'notification' => $data['notification'],
					'state' => $data['success'],
					'title' => 'Gestion des thèmes',
					'view' => 'manage'
				]);;
			}
		}
		// Valeurs en sortie
		$this->addOutput([
			'title' => 'Gestion des thèmes',
			'view' => 'manage'
		]);
	}

	/**
	 * Importe un thème
	 * @param string Url du thème à télécharger
	 * @param @return array contenant $success = true ou false ; $ notification string message à afficher
	 */

	public function import($zipName = '') {

		if ($zipName !== '' &&
			file_exists($zipName)) {
			// Init variables de retour
			$success = false;
			$notification = '';
			// Dossier temporaire
			$tempFolder = uniqid();
			// Ouvrir le zip
			$zip = new ZipArchive();
			if ($zip->open($zipName) === TRUE) {
				mkdir (self::TEMP_DIR . $tempFolder, 0755);
				$zip->extractTo(self::TEMP_DIR . $tempFolder );
				$modele = '';
				// Archive de thème ?
				if (
					file_exists(self::TEMP_DIR . $tempFolder . '/site/data/custom.css')
					AND file_exists(self::TEMP_DIR . $tempFolder . '/site/data/theme.css')
					AND file_exists(self::TEMP_DIR . $tempFolder . '/site/data/theme.json')
					) {
						$modele = 'theme';
				}
				if(
					file_exists(self::TEMP_DIR . $tempFolder . '/site/data/admin.json')
					AND file_exists(self::TEMP_DIR . $tempFolder . '/site/data/admin.css')
				) {
						$modele = 'admin';

				}
				if (!empty($modele)
				) {
					// traiter l'archive
					$success = $zip->extractTo('.');

					// Substitution des fontes Google
					if ($modele = 'theme') {
						$c = $this->subFonts(self::DATA_DIR . 'theme.json');
						// Un remplacement nécessite la régénération de la feuille de style
						if ($c > 0
							AND file_exists(self::DATA_DIR . 'theme.css')
						) {
								unlink(self::DATA_DIR . 'theme.css');
						}
					}
					if ($modele = 'admin') {
						$c = $this->subFonts(self::DATA_DIR . 'admin.json');
						// Un remplacement nécessite la régénération de la feuille de style
						if ($c > 0
							AND file_exists(self::DATA_DIR . 'admin.css')
							) {
								unlink(self::DATA_DIR . 'admin.css');
						}
					}

					// traitement d'erreur
					$notification = $success ? 'Le thème  a été importé' : 'Erreur lors de l\'extraction, vérifiez les permissions.';


				} else {
					// pas une archive de thème
					$success = false;
					$notification = 'Ce n\'est pas l\'archive d\'un thème !';
				}
				// Supprimer le dossier temporaire même si le thème est invalide
				$this->removeDir(self::TEMP_DIR . $tempFolder);
				$zip->close();
			} else {
				// erreur à l'ouverture
				$success = false;
				$notification = 'Impossible d\'ouvrir l\'archive';
			}
			return (['success' => $success, 'notification' => $notification]);
		}

		return (['success' => false, 'notification' => 'Archive non spécifiée ou introuvable']);
	}



	/**
	 * Export du thème
	 */
	public function export() {
		// Make zip
			$zipFilename = $this->zipTheme($this->getUrl(2));
			// Téléchargement du ZIP
			header('Content-Description: File Transfer');
			header('Content-Type: application/octet-stream');
			header('Content-Transfer-Encoding: binary');
			header('Content-Disposition: attachment; filename="' . $zipFilename . '"');
			header('Content-Length: ' . filesize(self::TEMP_DIR . $zipFilename));
			readfile(self::TEMP_DIR . $zipFilename);
			// Nettoyage du dossier
			unlink (self::TEMP_DIR . $zipFilename);
			exit();
	}

	/**
	 * Export du thème
	 */
	public function save() {
		// Make zip
		$zipFilename = $this->zipTheme($this->getUrl(2));
		// Téléchargement du ZIP
		if (!is_dir(self::FILE_DIR.'source/theme')) {
			mkdir(self::FILE_DIR.'source/theme', 0755);
		}
		copy (self::TEMP_DIR . $zipFilename , self::FILE_DIR.'source/theme/' . $zipFilename);
		// Nettoyage du dossier
		unlink (self::TEMP_DIR . $zipFilename);
		// Valeurs en sortie
		$this->addOutput([
			'notification' => 'Archive '.$zipFilename.' sauvegardée avec succès',
			'redirect' => helper::baseUrl() . 'theme/manage',
			'state' => true
		]);
	}

	/**
	 * construction du zip Fonction appelée par export() et save()
	 * @param string $modele theme ou admin
	 */
	private function zipTheme($modele) {
		// Creation du dossier
		$zipFilename  =  $modele . date('Y-m-d-H-i-s', time()) . '.zip';
		$zip = new ZipArchive();
		if ($zip->open(self::TEMP_DIR . $zipFilename, ZipArchive::CREATE | ZipArchive::OVERWRITE ) === TRUE) {
			switch ($modele) {
				case 'admin':
					$zip->addFile(self::DATA_DIR.'admin.json',self::DATA_DIR.'admin.json');
					$zip->addFile(self::DATA_DIR.'admin.css',self::DATA_DIR.'admin.css');
					break;
				case 'theme':
					$zip->addFile(self::DATA_DIR.'theme.json',self::DATA_DIR.'theme.json');
					$zip->addFile(self::DATA_DIR.'theme.css',self::DATA_DIR.'theme.css');
					$zip->addFile(self::DATA_DIR.'custom.css',self::DATA_DIR.'custom.css');
					// Traite l'image dans le body
					if ($this->getData(['theme','body','image']) !== '' ) {
					$zip->addFile(self::FILE_DIR.'source/'.$this->getData(['theme','body','image']),
								self::FILE_DIR.'source/'.$this->getData(['theme','body','image'])
								);
					}
					// Traite l'image dans le header
					if ($this->getData(['theme','header','image']) !== '' ) {
					$zip->addFile(self::FILE_DIR.'source/'.$this->getData(['theme','header','image']),
								  self::FILE_DIR.'source/'.$this->getData(['theme','header','image'])
								);
					}
					// Traite les images du header perso
					if (!empty($this->getData(['theme','header','featureFiles'])) ) {
						foreach($this->getData(['theme','header','featureFiles']) as $value) {
							$zip->addFile(self::FILE_DIR . 'source/' . $value,
										  self::FILE_DIR . 'source/' . $value );
						}
					}
					break;
			}
			$ret = $zip->close();
		}
		return ($zipFilename);
	}

	/**
	 * Substitution des fontes de Google Fonts vers CdnFont grâce à un tableau de conversion
	 * Cette fonction est utilisée par l'import.
	 * @param string $file, nom du fichier json à convertir
	 * @return int nombre de substitution effectuées
	 */
	private function subFonts($file)   {
		// Tableau de substitution des fontes
		$fonts = [
			'Abril+Fatface' => 'abril-fatface',
			'Arimo' => 'arimo',
			'Arvo' => 'arvo',
			'Berkshire+Swash' => 'berkshire-swash',
			'Cabin' => 'genera',
			'Dancing+Script' => 'dancing-script',
			'Droid+Sans' => 'droid-sans-2',
			'Droid+Serif' => 'droid-serif-2',
			'Fira+Sans' => 'fira-sans',
			'Inconsolata' => 'inconsolata-2',
			'Indie+Flower' =>'indie-flower',
			'Josefin+Slab' => 'josefin-sans-std',
			'Lobster' => 'lobster-2',
			'Lora' => 'lora',
			'Lato' =>'lato',
			'Marvel' => 'montserrat-ace',
			'Old+Standard+TT' => 'old-standard-tt-3',
			'Open+Sans' =>'open-sans',
				// Corriger l'erreur de nom de police installée par défaut, il manquait un O en majuscule
			'open+Sans' =>'open-sans',
			'Oswald' =>'oswald-4',
			'PT+Mono' => 'pt-mono',
			'PT+Serif' =>'pt-serif',
			'Raleway' => 'raleway-5',
			'Rancho' => 'rancho',
			'Roboto' => 'Roboto',
			'Signika' => 'signika',
			'Ubuntu' => 'ubuntu',
			'Vollkorn' => 'vollkorn'
		];

		$data = file_get_contents($file);
		$count = 0;
		foreach ($fonts as $oldId => $newId){
			$data = str_replace($oldId, $newId, $data, $c);
			$count = $count + (int) $c;
		}
		// Sauvegarder la chaîne modifiée
		if ($count > 0) {
			file_put_contents($file, $data);
		}
		// Retourner le nombre d'occurrences
		return ($count);
	}

	// Retourne un tableau simple des fonts installées idfont avec le nom
	// Cette fonction est utile aux sélecteurs de fonts dans les formulaires.
	public function enumFonts() {
		// Récupère la liste des fontes installées
		$f = $this->getFonts();
		// Construit un tableau avec leur ID et leur famille
		foreach(['websafe', 'imported', 'files'] as $type) {
			foreach ($f[$type] as $fontId => $fontValue ) {
				$fonts [$fontId] = $fontValue['name'];
			}
		}
		ksort($fonts);
		self::$fontsList = $fonts;
	}

}