<?php
# -- BEGIN LICENSE BLOCK ---------------------------------------
#
# This file is part of Dotclear 2.
#
# Copyright (c) 2003-2013 Olivier Meunier & Association Dotclear
# Licensed under the GPL version 2.0 license.
# See LICENSE file or
# http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
#
# -- END LICENSE BLOCK -----------------------------------------
if (!defined('DC_RC_PATH')) { return; }

/**
@ingroup DC_CORE
@brief Modules handler

Provides an object to handle modules (themes or plugins).
*/
class dcModules
{
	protected $path;
	protected $ns;
	protected $modules = array();
	protected $disabled = array();
	protected $errors = array();
	protected $modules_names = array();
	protected $all_modules = array();
	protected $disabled_mode = false;
	protected $disabled_meta = array();
	protected $to_disable = array();

	protected $id;
	protected $mroot;

	# Inclusion variables
	protected static $superglobals = array('GLOBALS','_SERVER','_GET','_POST','_COOKIE','_FILES','_ENV','_REQUEST','_SESSION');
	protected static $_k;
	protected static $_n;

	protected static $type = null;

	public $core;	///< <b>dcCore</b>	dcCore instance

	/**
	Object constructor.

	@param	core		<b>dcCore</b>	dcCore instance
	*/
	public function __construct($core)
	{
		$this->core =& $core;
	}

	/**
	 * Checks all modules dependencies
	 * 	Fills in the following information in module :
	 * 	  * cannot_enable : list reasons why module cannot be enabled. Not set if module can be enabled
	 * 	  * cannot_disable : list reasons why module cannot be disabled. Not set if module can be disabled
	 * 	  * implies : reverse dependencies
	 * @return array list of enabled modules with unmet dependencies, and that must be disabled.
	 */
	public function checkDependencies()
	{
		$this->to_disable = array();
		foreach ($this->all_modules as $k => &$m) {
			if (isset($m['requires'])) {
				$missing = array();
				foreach ($m['requires'] as &$dep) {
					if (!is_array($dep)) {
						$dep = array($dep);
					}
					// grab missing dependencies
					if (!isset($this->all_modules[$dep[0]])) {
						// module not present
						$missing[$dep[0]] = sprintf(__("Requires module %s which is not installed"), $dep[0]);
					} elseif ((count($dep)>1) && version_compare($this->all_modules[$dep[0]]['version'],$dep[1])==-1) {
						// module present, but version missing
						$missing[$dep[0]] = sprintf(__("Requires module %s version %s, but version %s is installed"), $dep[0],$dep[1],$m['version']);
					} elseif (!$this->all_modules[$dep[0]]['enabled']) {
						// module disabled
						$missing[$dep[0]] = sprintf(__("Requires module %s which is disabled"), $dep[0]);
					}
					$this->all_modules[$dep[0]]['implies'][]=$k;
				}
				if (count($missing)) {
					$m['cannot_enable']=$missing;
					if ($m['enabled']) {
						$this->to_disable[]=array('name' => $k,'reason'=> $missing);
					}
				}
			}
		}
		// Check modules that cannot be disabled
		foreach ($this->modules as $k => &$m) {
			if (isset($m['implies']) && $m['enabled']) {
				foreach ($m['implies'] as $im) {
					if (isset($this->all_modules[$im]) && $this->all_modules[$im]['enabled']) {
						$m['cannot_disable'][]=$im;
					}
				}
			}
		}
	}

	/**
	 * Checks all modules dependencies, and disable unmet dependencies
	 * @param  string $redir_url URL to redirect if modules are to disable
	 * @return boolean, true if a redirection has been performed
	 */
	public function disableDepModules($redir_url)
	{
		if (isset($_GET['dep'])) {
			// Avoid infinite redirects
			return false;
		}
		$reason = array();
		foreach ($this->to_disable as $module) {
			try{
				$this->deactivateModule($module['name']);
				$reason[] = sprintf("<li>%s : %s</li>",$module['name'],join(',',$module['reason']));
			} catch (Exception $e) {
			}
		}
		if (count($reason)) {
			$message = sprintf ("<p>%s</p><ul>%s</ul>",
				__('The following extensions have been disabled :'),
				join('',$reason)
			);
			dcPage::addWarningNotice($message,array('divtag' => true,'with_ts' => false));
			$url = $redir_url.(strpos($redir_url,"?") ? '&' : '?').'dep=1';
			http::redirect($url);
			return true;
		}
		return false;
	}

	/**
	Loads modules. <var>$path</var> could be a separated list of paths
	(path separator depends on your OS).

	<var>$ns</var> indicates if an additionnal file needs to be loaded on plugin
	load, value could be:
	- admin (loads module's _admin.php)
	- public (loads module's _public.php)
	- xmlrpc (loads module's _xmlrpc.php)

	<var>$lang</var> indicates if we need to load a lang file on plugin
	loading.
	*/
	public function loadModules($path,$ns=null,$lang=null)
	{
		$this->path = explode(PATH_SEPARATOR,$path);
		$this->ns = $ns;

		$disabled = isset($_SESSION['sess_safe_mode']) && $_SESSION['sess_safe_mode'];
		$disabled = $disabled && !get_parent_class($this) ? true : false;

		$ignored = array();

		foreach ($this->path as $root)
		{
			if (!is_dir($root) || !is_readable($root)) {
				continue;
			}

			if (substr($root,-1) != '/') {
				$root .= '/';
			}

			if (($d = @dir($root)) === false) {
				continue;
			}

			while (($entry = $d->read()) !== false)
			{
				$full_entry = $root.$entry;

				if ($entry != '.' && $entry != '..' && is_dir($full_entry)
				&& file_exists($full_entry.'/_define.php'))
				{
					if (!file_exists($full_entry.'/_disabled') && !$disabled)
					{
						$this->id = $entry;
						$this->mroot = $full_entry;
						require $full_entry.'/_define.php';
						$this->all_modules[$entry] =& $this->modules[$entry];
						$this->id = null;
						$this->mroot = null;
					}
					else
					{
						if (file_exists($full_entry.'/_define.php')) {
							$this->id = $entry;
							$this->mroot = $full_entry;
							$this->disabled_mode=true;
							require $full_entry.'/_define.php';
							$this->disabled_mode=false;
							$this->disabled[$entry] =  $this->disabled_meta;
							$this->all_modules[$entry] =& $this->disabled[$entry];
							$this->id = null;
							$this->mroot = null;
						}
					}
				}
			}
			$d->close();
		}
		$this->checkDependencies();
		# Sort plugins
		uasort($this->modules,array($this,'sortModules'));

		foreach ($this->modules as $id => $m)
		{
			# Load translation and _prepend
			if (file_exists($m['root'].'/_prepend.php'))
			{
				$r = $this->loadModuleFile($m['root'].'/_prepend.php');

				# If _prepend.php file returns null (ie. it has a void return statement)
				if (is_null($r)) {
					$ignored[] = $id;
					continue;
				}
				unset($r);
			}

			$this->loadModuleL10N($id,$lang,'main');
			if ($ns == 'admin') {
				$this->loadModuleL10Nresources($id,$lang);
				$this->core->adminurl->register('admin.plugin.'.$id,'plugin.php',array('p'=>$id));
			}
		}
		foreach ($this->modules as $id => $m)
		{
			# If _prepend.php file returns null (ie. it has a void return statement)
			if (in_array($id,$ignored)) {
				continue;
			}
			# Load ns_file
			$this->loadNsFile($id,$ns);
		}
	}

	public function requireDefine($dir,$id)
	{
		if (file_exists($dir.'/_define.php')) {
			$this->id = $id;
			require $dir.'/_define.php';
			$this->id = null;
		}
	}

	/**
	This method registers a module in modules list. You should use this to
	register a new module.

	<var>$permissions</var> is a comma separated list of permissions for your
	module. If <var>$permissions</var> is null, only super admin has access to
	this module.

	<var>$priority</var> is an integer. Modules are sorted by priority and name.
	Lowest priority comes first.

	@param	name			<b>string</b>		Module name
	@param	desc			<b>string</b>		Module description
	@param	author		<b>string</b>		Module author name
	@param	version		<b>string</b>		Module version
	@param	properties	<b>array</b>		extra properties
	(currently available keys : permissions, priority, type)
	*/
	public function registerModule($name,$desc,$author,$version, $properties = array())
	{
		if ($this->disabled_mode) {
			$this->disabled_meta = array_merge(
					$properties,
					array(
						'root' => $this->mroot,
						'name' => $name,
						'desc' => $desc,
						'author' => $author,
						'version' => $version,
						'enabled' => false,
						'root_writable' => is_writable($this->mroot)
					)
				);
			return;
		}
		# Fallback to legacy registerModule parameters
		if (!is_array($properties)) {
			$args = func_get_args();
			$properties = array();
			if (isset($args[4])) {
				$properties['permissions']=$args[4];
			}
			if (isset($args[5])) {
				$properties['priority']= (integer)$args[5];
			}
		}

		# Default module properties
		$properties = array_merge(
			array(
				'permissions' => null,
				'priority' => 1000,
				'standalone_config' => false,
				'type' => null,
				'enabled' => true,
				'requires' => array()
			), $properties
		);

		# Check module type
		if (self::$type !== null && $properties['type'] !== null && $properties['type'] != self::$type) {
			$this->errors[] = sprintf(
				__('Module "%s" has type "%s" that mismatch required module type "%s".'),
				'<strong>'.html::escapeHTML($name).'</strong>',
				'<em>'.html::escapeHTML($properties['type']).'</em>',
				'<em>'.html::escapeHTML(self::$type).'</em>'
			);
			return;
		}

		# Check module perms on admin side
		$permissions = $properties['permissions'];
		if ($this->ns == 'admin') {
			if ($permissions == '' && !$this->core->auth->isSuperAdmin()) {
				return;
			} elseif (!$this->core->auth->check($permissions,$this->core->blog->id)) {
				return;
			}
		}

		# Check module install on multiple path
		if ($this->id) {
			$module_exists = array_key_exists($name,$this->modules_names);
			$module_overwrite = $module_exists ? version_compare($this->modules_names[$name],$version,'<') : false;
			if (!$module_exists || ($module_exists && $module_overwrite)) {
				$this->modules_names[$name] = $version;
				$this->modules[$this->id] = array_merge(
					$properties,
					array(
						'root' => $this->mroot,
						'name' => $name,
						'desc' => $desc,
						'author' => $author,
						'version' => $version,
						'root_writable' => is_writable($this->mroot)
					)
				);
			}
			else {
				$path1 = path::real($this->moduleInfo($name,'root'));
				$path2 = path::real($this->mroot);
				$this->errors[] = sprintf(
					__('Module "%s" is installed twice in "%s" and "%s".'),
					'<strong>'.$name.'</strong>',
					'<em>'.$path1.'</em>',
					'<em>'.$path2.'</em>'
				);
			}
		}
	}

	public function resetModulesList()
	{
		$this->modules = array();
		$this->modules_names = array();
		$this->errors = array();
	}

	public static function installPackage($zip_file,dcModules &$modules)
	{
		$zip = new fileUnzip($zip_file);
		$zip->getList(false,'#(^|/)(__MACOSX|\.svn|\.hg|\.git|\.DS_Store|\.directory|Thumbs\.db)(/|$)#');

		$zip_root_dir = $zip->getRootDir();
		$define = '';
		if ($zip_root_dir != false) {
			$target = dirname($zip_file);
			$destination = $target.'/'.$zip_root_dir;
			$define = $zip_root_dir.'/_define.php';
			$has_define = $zip->hasFile($define);
		} else {
			$target = dirname($zip_file).'/'.preg_replace('/\.([^.]+)$/','',basename($zip_file));
			$destination = $target;
			$define = '_define.php';
			$has_define = $zip->hasFile($define);
		}

		if ($zip->isEmpty()) {
			$zip->close();
			unlink($zip_file);
			throw new Exception(__('Empty module zip file.'));
		}

		if (!$has_define) {
			$zip->close();
			unlink($zip_file);
			throw new Exception(__('The zip file does not appear to be a valid Dotclear module.'));
		}

		$ret_code = 1;

		if (!is_dir($destination))
		{
			try {
				files::makeDir($destination,true);

				$sandbox = clone $modules;
				$zip->unzip($define, $target.'/_define.php');

				$sandbox->resetModulesList();
				$sandbox->requireDefine($target,basename($destination));
				unlink($target.'/_define.php');

				$new_errors = $sandbox->getErrors();
				if (!empty($new_errors)) {
					$new_errors = is_array($new_errors) ? implode(" \n",$new_errors) : $new_errors;
					throw new Exception($new_errors);
				}

				files::deltree($destination);
			}
			catch(Exception $e)
			{
				$zip->close();
				unlink($zip_file);
				files::deltree($destination);
				throw new Exception($e->getMessage());
			}
		}
		else
		{
			# test for update
			$sandbox = clone $modules;
			$zip->unzip($define, $target.'/_define.php');

			$sandbox->resetModulesList();
			$sandbox->requireDefine($target,basename($destination));
			unlink($target.'/_define.php');
			$new_modules = $sandbox->getModules();

			if (!empty($new_modules))
			{
				$tmp = array_keys($new_modules);
				$id = $tmp[0];
				$cur_module = $modules->getModules($id);
				if (!empty($cur_module) && (defined('DC_DEV') && DC_DEV === true || dcUtils::versionsCompare($new_modules[$id]['version'], $cur_module['version'], '>', true)))
				{
					# delete old module
					if (!files::deltree($destination)) {
						throw new Exception(__('An error occurred during module deletion.'));
					}
					$ret_code = 2;
				}
				else
				{
					$zip->close();
					unlink($zip_file);
					throw new Exception(sprintf(__('Unable to upgrade "%s". (older or same version)'),basename($destination)));
				}
			}
			else
			{
				$zip->close();
				unlink($zip_file);
				throw new Exception(sprintf(__('Unable to read new _define.php file')));
			}
		}
		$zip->unzipAll($target);
		$zip->close();
		unlink($zip_file);
		return $ret_code;
	}

	/**
	This method installs all modules having a _install file.

	@see dcModules::installModule
	*/
	public function installModules()
	{
		$res = array('success'=>array(),'failure'=>array());
		foreach ($this->modules as $id => &$m)
		{
			$i = $this->installModule($id,$msg);
			if ($i === true) {
				$res['success'][$id] = true;
			} elseif ($i === false) {
				$res['failure'][$id] = $msg;
			}
		}

		return $res;
	}

	/**
	This method installs module with ID <var>$id</var> and having a _install
	file. This file should throw exception on failure or true if it installs
	successfully.

	<var>$msg</var> is an out parameter that handle installer message.

	@param	id		<b>string</b>		Module ID
	@param	msg		<b>string</b>		Module installer message
	@return	<b>boolean</b>
	*/
	public function installModule($id,&$msg)
	{
		try {
			$i = $this->loadModuleFile($this->modules[$id]['root'].'/_install.php');
			if ($i === true) {
				return true;
			}
		} catch (Exception $e) {
			$msg = $e->getMessage();
			return false;
		}

		return null;
	}

	public function deleteModule($id,$disabled=false)
	{
		if ($disabled) {
			$p =& $this->disabled;
		} else {
			$p =& $this->modules;
		}

		if (!isset($p[$id])) {
			throw new Exception(__('No such module.'));
		}

		if (!files::deltree($p[$id]['root'])) {
			throw new Exception(__('Cannot remove module files'));
		}
	}

	public function deactivateModule($id)
	{
		if (!isset($this->modules[$id])) {
			throw new Exception(__('No such module.'));
		}

		if (!$this->modules[$id]['root_writable']) {
			throw new Exception(__('Cannot deactivate plugin.'));
		}

		if (@file_put_contents($this->modules[$id]['root'].'/_disabled','')) {
			throw new Exception(__('Cannot deactivate plugin.'));
		}
	}

	public function activateModule($id)
	{
		if (!isset($this->disabled[$id])) {
			throw new Exception(__('No such module.'));
		}

		if (!$this->disabled[$id]['root_writable']) {
			throw new Exception(__('Cannot activate plugin.'));
		}

		if (@unlink($this->disabled[$id]['root'].'/_disabled') === false) {
			throw new Exception(__('Cannot activate plugin.'));
		}
	}

	/**
	This method will search for file <var>$file</var> in language
	<var>$lang</var> for module <var>$id</var>.

	<var>$file</var> should not have any extension.

	@param	id		<b>string</b>		Module ID
	@param	lang		<b>string</b>		Language code
	@param	file		<b>string</b>		File name (without extension)
	*/
	public function loadModuleL10N($id,$lang,$file)
	{
		if (!$lang || !isset($this->modules[$id])) {
			return;
		}

		$lfile = $this->modules[$id]['root'].'/locales/%s/%s';
		if (l10n::set(sprintf($lfile,$lang,$file)) === false && $lang != 'en') {
			l10n::set(sprintf($lfile,'en',$file));
		}
	}

	public function loadModuleL10Nresources($id,$lang)
	{
		if (!$lang || !isset($this->modules[$id])) {
			return;
		}

		$f = l10n::getFilePath($this->modules[$id]['root'].'/locales','resources.php',$lang);
		if ($f) {
			$this->loadModuleFile($f);
		}
	}

	/**
	Returns all modules associative array or only one module if <var>$id</var>
	is present.

	@param	id		<b>string</b>		Optionnal module ID
	@return	<b>array</b>
	*/
	public function getModules($id=null)
	{
		if ($id && isset($this->modules[$id])) {
			return $this->modules[$id];
		}
		return $this->modules;
	}

	/**
	Returns true if the module with ID <var>$id</var> exists.

	@param	id		<b>string</b>		Module ID
	@return	<b>boolean</b>
	*/
	public function moduleExists($id)
	{
		return isset($this->modules[$id]);
	}

	/**
	Returns all disabled modules in an array

	@return	<b>array</b>
	*/
	public function getDisabledModules()
	{
		return $this->disabled;
	}

	/**
	Returns root path for module with ID <var>$id</var>.

	@param	id		<b>string</b>		Module ID
	@return	<b>string</b>
	*/
	public function moduleRoot($id)
	{
		return $this->moduleInfo($id,'root');
	}

	/**
	Returns a module information that could be:
	- root
	- name
	- desc
	- author
	- version
	- permissions
	- priority

	@param	id		<b>string</b>		Module ID
	@param	info		<b>string</b>		Information to retrieve
	@return	<b>string</b>
	*/
	public function moduleInfo($id,$info)
	{
		return isset($this->modules[$id][$info]) ? $this->modules[$id][$info] : null;
	}

	/**
	Loads namespace <var>$ns</var> specific files for all modules.

	@param	ns		<b>string</b>		Namespace name
	*/
	public function loadNsFiles($ns=null)
	{
		foreach ($this->modules as $k => $v) {
			$this->loadNsFile($k,$ns);
		}
	}

	/**
	Loads namespace <var>$ns</var> specific file for module with ID
	<var>$id</var>

	@param	id		<b>string</b>		Module ID
	@param	ns		<b>string</b>		Namespace name
	*/
	public function loadNsFile($id,$ns=null)
	{
		switch ($ns) {
			case 'admin':
				$this->loadModuleFile($this->modules[$id]['root'].'/_admin.php');
				break;
			case 'public':
				$this->loadModuleFile($this->modules[$id]['root'].'/_public.php');
				break;
			case 'xmlrpc':
				$this->loadModuleFile($this->modules[$id]['root'].'/_xmlrpc.php');
				break;
		}
	}

	public function getErrors()
	{
		return $this->errors;
	}

	protected function loadModuleFile($________)
	{
		if (!file_exists($________)) {
			return;
		}

		self::$_k = array_keys($GLOBALS);

		foreach (self::$_k as self::$_n) {
			if (!in_array(self::$_n,self::$superglobals)) {
				global ${self::$_n};
			}
		}

		return require $________;
	}

	private function sortModules($a,$b)
	{
		if ($a['priority'] == $b['priority']) {
			return strcasecmp($a['name'],$b['name']);
		}

		return ($a['priority'] < $b['priority']) ? -1 : 1;
	}
}
