<?php
namespace Utility;



/**
 * Central registry for storing item during script execution.
 * @author andre.fourie
 *
 */
class Registry
{

	/**
	 * @var \Zend\Session\Container
	 */
	static protected $session;
	/**
	 * @var \Doctrine\ORM\EntityManager
	 */
	static protected $em;
	/**
	 * @var \Zend\ServiceManager\ServiceLocatorInterface
	 */
	static protected $sm;
	/**
	 * @var array
	 */
	static protected $container = array(
			'UseOnce' => array()
	);
	/**
	 * @var array
	 */
	static protected $config;


	/**
	 * Initiate session container.
	 */
	static protected function initSession()
	{
		is_null(self::$session)
			&& self::$session = new \Zend\Session\Container(__CLASS__);
	}

	/**
	 * Store an item.
	 * @param string $key
	 * @param unknown $value
	 * @return boolean
	 */
	static public function set($key, $value)
	{
		self::$container[$key] = $value;
		return true;
	}

	/**
	 * Retrieve an item.
	 * @param string $key
	 * @param unknown|null $default
	 * @return unknown|null
	 */
	static public function get($key, $default = null)
	{
		return isset(self::$container[$key])
			? self::$container[$key]
			: $default;
	}

	/**
	 * Set value for single retrieval.
	 * @param string $key
	 * @param unknown $value
	 */
	static public function setOnce($key, $value)
	{
		self::$container['UseOnce'][$key] = $value;
		return true;
	}

	/**
	 * Retrieve single use value. Value will be destroyed after this call.
	 * @param string $key
	 * @param unknown|null $default
	 * @return unknown|null
	 */
	static public function checkOnce($key, $default = null)
	{
		if (isset(self::$container['UseOnce'][$key]))
		{
			$value = self::$container['UseOnce'][$key];
			unset(self::$container['UseOnce'][$key]);
			return $value;
		}
		else
		{
			return $default;
		}
	}

	/**
	 * Set Doctrine Entity Manager for easy access.
	 * @param \Doctrine\ORM\EntityManager $em
	 * @return boolean
	 */
	static public function setEntityManager($em)
	{
		self::$em = $em;
		$config = new \Doctrine\ORM\Configuration();
		$config->setQueryCacheImpl(new \Doctrine\Common\Cache\FilesystemCache('data/DoctrineORMModule/QueryCache'));
		$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\FilesystemCache('data/DoctrineORMModule/MetaCache'));
		$config->setAutoGenerateProxyClasses(false);
		return true;
	}

	/**
	 * Retrieve Doctrine Entity Manager.
	 * @return \Doctrine\ORM\EntityManager
	 */
	static public function getEntityManager()
	{
		return self::$em;
	}

	/**
	 * Set Doctrine Entity Manager for easy access.
	 * @param \Zend\ServiceManager\ServiceLocatorInterface $sm
	 * @return boolean
	 */
	static public function setServiceManager($sm)
	{
		self::$sm = $sm;
		self::$em = self::$sm->get('doctrine.entitymanager.orm_default');
		$config = new \Doctrine\ORM\Configuration();
		$config->setQueryCacheImpl(new \Doctrine\Common\Cache\FilesystemCache('data/DoctrineORMModule/QueryCache'));
		$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\FilesystemCache('data/DoctrineORMModule/MetaCache'));
		$config->setAutoGenerateProxyClasses(false);
		//$config->ensureProductionSettings();
		return true;
	}

	/**
	 * Retrieve Doctrine Entity Manager.
	 * @return \Zend\ServiceManager\ServiceLocatorInterface
	 */
	static public function getServiceManager()
	{
		return self::$sm;
	}

	/**
	 * Set device session from token.
	 * @param string $token
	 * @throws \Exception
	 * @return boolean
	 */
	static public function setSession($token)
	{
		self::$session = null;
		$sm = new \Zend\Session\SessionManager();
		$sm->setId($token);
		self::initSession();
		if (!isset(self::$session->authData)
			|| self::$session->authData['authToken'] != $token)
		{
			throw new \Exception('Invalid session requested.');
		}
		return true;
	}

	/**
	 * Set authentication data in session for global accessibility.
	 * @param array $authData
	 * @return boolean
	 */
	static public function clearAuthData()
	{
		self::initSession();
		if (isset(self::$session->authData))
		{
			unset(self::$session->authData);
		}
		return true;
	}

	/**
	 * Clear grid data stored in session.
	 * @param array $authData
	 * @return boolean
	 */
	static public function clearSessionData()
	{
		self::initSession();
		if (isset(self::$session->sessData))
		{
			unset(self::$session->sessData);
		}
		return true;
	}

	/**
	 * Should session data be cleared?
	 * @param string $containerName
	 * @return boolean
	 */
	static public function initSessionStorage($containerName)
	{
		self::initSession();
		isset(self::$session->sessData)
			|| self::$session->sessData = array();
		if (!isset(self::$session->sessData[$containerName]))
		{
			self::$session->sessData[$containerName] = true;
			return true;
		}
		return false;
	}

	/**
	 * Set authentication data in session for global accessibility.
	 * @param array $authData
	 * @return boolean
	 */
	static public function setAuthData(array $authData)
	{
		self::initSession();
		$sm = new \Zend\Session\SessionManager();
		isset($authData['Sudo'])
			|| $authData['Sudo'] = array();
		$authData['authToken'] = $sm->getId();
		self::$session->authData = $authData;
		return true;
	}

	/**
	 * Set a data parameter in the authentication packet.
	 * @param string $param
	 * @param unknown $value
	 * @return boolean
	 */
	static public function setAuthParam($param, $value)
	{
		self::initSession();
		if (isset(self::$session->authData))
		{
			self::$session->authData[$param] = $value;
		}
		return isset(self::$session->authData);
	}

	/**
	 * Set a data parameter in the authentication packet.
	 * @param string $param
	 * @param unknown $value
	 * @return boolean
	 */
	static public function setAuthSudo($param, $label, $value)
	{
		self::initSession();
		if (isset(self::$session->authData))
		{
			self::$session->authData['Sudo'][$param] = $value;
			self::$session->authData['Sudo'][$param . 'Id'] = $value;
			self::$session->authData['Sudo'][$param . 'Name'] = $label;
			self::$session->authData['Sudo']['Names'][$param] = $label;
		}
		return isset(self::$session->authData);
	}

	/**
	 * Retrieve sudo filter.
	 * @param string $param
	 * @param unknown $default
	 * @return unknown
	 */
	static public function getSudo($param, $default)
	{
		self::initSession();
		return isset(self::$session->authData)
				&& isset(self::$session->authData['Sudo'][$param])
			? self::$session->authData['Sudo'][$param]
			: $default;
	}

	/**
	 * Retrieve authentication data.
	 * @return array|null
	 */
	static public function getAuthData()
	{
		self::initSession();
		return isset(self::$session->authData)
			? self::$session->authData
			: null;
	}

	/**
	 * Check if we have authentication data.
	 * @return boolean
	 */
	static public function isAuthenticated()
	{
		self::initSession();
		return isset(self::$session->authData);
	}

	/**
	 * Get an authentication parameter.
	 * @param string $key
	 * @return unknown|null
	 */
	static public function getAuthParam($key)
	{
		self::initSession();
		return isset(self::$session->authData) && isset(self::$session->authData[$key])
			? self::$session->authData[$key]
			: null;
	}

	/**
	 * Get authenticated user's user type.
	 * @return string|null
	 */
	static public function getUserType()
	{
		self::initSession();
		return isset(self::$session->authData) && isset(self::$session->authData['permissions']['name'])
			? self::$session->authData['permissions']['name']
			: null;
	}

	/**
	 * Resolve Company from session and sudo settings.
	 * @param integer|null $companyId
	 * @throws \Exception
	 * @return integer|object|null
	 */
	static public function resolveCompanyContext($companyId = null)
	{
		if (is_null(self::$em))
		{
			return $companyId;
		}
		self::initSession();
		if (!isset(self::$session->authData)
			|| (!is_null($companyId)
					&& 'Administrator' == self::$session->authData['userType']))
		{
			return !is_null($companyId)
				? self::$em->getReference(
						'\Company\Entity\Company',
						$companyId
						)
				: null;
		}
		if (is_null($companyId))
		{
			$companyFilter = \Utility\Registry::getSudo('Company', false);
			if (!$companyFilter)
			{
				return self::$em->getReference(
						'\Company\Entity\Company',
						self::$session->authData['company']['id']
				);
			}
			else
			{
				return self::$em->getReference(
						'\Company\Entity\Company',
						$companyFilter
				);
			}
		}
		else
		{
			$companyFilter = \Utility\Registry::getSudo('Company', false);
			if ('Administrator' != self::$session->authData['userType'] || !$companyFilter)
			{
				throw new \Exception('No dealership selected for actioning.');
			}
			return self::$em->getReference(
					'\Company\Entity\Company',
					$companyFilter
			);
		}
	}

	/**
	 * Resolve Profile from session and sudo settings.
	 * @param integer|null $profileId
	 * @throws \Exception
	 * @return \User\Entity\Profile|null
	 */
	static public function resolveProfileContext($profileId = null)
	{
		if (is_null(self::$em))
		{
			return $profileId;
		}
		self::initSession();
		if (!isset(self::$session->authData))
		{
			return !is_null($profileId)
				? self::$em->getReference(
						'\User\Entity\Profile',
						$profileId
						)
				: null;
		}
		else
		{
			$profileFilter = \Utility\Registry::getSudo('Profile', false);
			return ($profileFilter)
				? self::$em->getReference(
						'\User\Entity\Profile',
						$profileFilter
						)
				: self::$em->getReference(
						'\User\Entity\Profile',
						self::$session->authData['id']
						);
		}
	}

	/**
	 * Retrieve global config.
	 * @return array
	 */
	static public function getGlobalConfig()
	{
		is_null(self::$config)
			&& self::$config = array_merge(
				include __DIR__ . '/../../../../config/autoload/global.php',
				include __DIR__ . '/../../../../config/autoload/local.php'
				);
		return self::$config;
	}

	/**
	 * Add changable config data to global config.
	 * @param array $config
	 * @return boolean
	 */
	static public function addDynamicConfig(array $config)
	{
		self::getGlobalConfig();
		self::$config = array_merge(self::$config, $config);
		return true;
	}

	/**
	 * Retrieve section from global config.
	 * @param string $key
	 * @return unknown|null
	 */
	static public function getConfigParam($key)
	{
		self::getGlobalConfig();
		return isset(self::$config[$key])
			? self::$config[$key]
			: null;
	}

	/**
	 * Store data to file.
	 * @param  string  $key  Storage key
	 * @param  unknown $data Data to store
	 * @return void
	 */
	static public function storeJson($key, $data)
	{
		file_put_contents(getcwd() . '/data/file/' . $key . '.json', json_encode($data));
	}

	/**
	 * Retrieve data from file.
	 * @param  string  $key Storage key
	 * @return unknown      Stored data or null
	 */
	static public function fetchJson($key)
	{
		if (!file_exists(getcwd() . '/data/file/' . $key . '.json'))
		{
			return null;
		}
		$result = file_get_contents(getcwd() . '/data/file/' . $key . '.json');
		return json_decode($result, true);
	}

	/**
	 * Delete data file.
	 * @param  string  $key Storage key
	 * @return void
	 */
	static public function deleteJson($key)
	{
		if (file_exists(getcwd() . '/data/file/' . $key . '.json'))
		{
			unlink(getcwd() . '/data/file/' . $key . '.json');
		}
	}

	/**
	 * Cleanup files older than [hours].
	 * @param  integer $hours Number of hours
	 * @return void
	 */
	static public function cleanupJson($hours)
	{
		$files = glob(getcwd() . '/data/file/*');
		$now   = time();
		foreach ($files as $file)
		{
			if (is_file($file))
			{
				if ($now - filemtime($file) >= 60 * 60 * (int) $hours)
				{
					unlink($file);
				}
			}
		}
	}

}