<?php
/**
 * Manifest helper
 * @version $Id: manifest.php 837 2009-05-07 18:38:16Z elkuku $
 * @package EasyCreator
 * @subpackage Helpers
 *
 * @author Ian McLennan
 * @former package    IansTools - by Ian McLennan
 * @former subpackage ManifestMaker
 * @license		GNU/GPL
 */

//--No direct access
defined('_JEXEC') or die('=;)');

/**
 * Manifest
 *
 * @former-package    IansTools
 * @package packagename
 * @subpackage Models
 *
 * FULL Credits to Ian McLennan =;)
 */
class Manifest
{

	private $_manifest;

	//ADD NiK
	private $project = '';

	/**
	 * Constructor
	 *
	 * @access	public
	 * @return	void
	 */
	public function __construct()
	{
		$this->_manifest =& JFactory::getXMLParser();
	}//function

	private function &_buildElement( $elementName, $objName )
	{
		$node = $this->_manifest->createElement( $elementName );
		$text =( isset($this->project->$objName) ) ? $this->project->$objName : '';
		$node->setText( $text );
		return $node;
	}//function


	/**
	 * Method to create the manifest file
	 *
	 * @access	public
	 *
	 * @param JObject $project
	 *
	 * @return	bool true on success
	 */
	public function create($project )
	{
		if( ! $project->comtype )
		{
			$this->setError( 'No config type found' );
			return false;
		}
		$this->project = $project;

		if( ! $this->_manifest)
		{
			$this->setError( 'Could not create XML builder' );
			return false;
		}
		jimport( 'joomla.filesystem.folder' );

		if( ! $node = $this->_manifest->createElement( 'install' )) {
			$this->setError( 'Could not create node!' );
			return false;
		}

		$node->setAttribute( 'type', $this->project->comtype );

		$node->setAttribute( 'version', '1.5.0' );

		switch( $this->project->comtype )
		{
			case 'module':
				if( $this->project->comscope == 'admin')
				{
					$node->setAttribute( 'client', 'administrator' );
				}
			break;
			case 'plugin':
				$node->setAttribute( 'group', $this->project->comscope );
			break;
		}//switch

		$this->_manifest->setDocumentElement($node);

		if (!$root =& $this->_manifest->documentElement) {
			$this->setError( 'Could not obtain root element!' );
			return false;
		}

		$creditElements = array(
			  'name' => 'com_name'
			, 'version' => 'com_version'
			, 'description' => 'description'
			, 'license' => 'license'
			, 'author' => 'author'
			, 'authoremail' => 'authoremail'
			, 'authorurl' => 'authorurl'
			, 'copyright' => 'copyright'
			, 'creationDate' => 'creationDate'
		);

		foreach ($creditElements as $creditElement => $objName)
		{
			$root->appendChild( $this->_buildElement( $creditElement, $objName ) );
		}//foreach

		$basepath = JPath::clean( $this->project->basepath.DS);

		$installFile = JFolder::files( $basepath, '^install' );
		$subDir = '';
		if( ! count( $installFile ) && JFolder::exists( $basepath.'admin'.DS.'install' ))
		{
			$installFile = JFolder::files( $basepath.DS.'admin'.DS.'install', '^install' );
			$subDir = 'install/';
		}
		if (count( $installFile ))
		{
			$installFileElement =& $this->_manifest->createElement( 'installfile' );
			$installFileElement->setText( $subDir.$installFile[0] );
			$root->appendChild( $installFileElement );
		}

		if( $this->project->isNew )
		{
			$uninstallFile =( count($this->project->uninstallFile)) ? $this->project->uninstallFile : array();
		}
		else
		{
			$uninstallFile = JFolder::files( $basepath, '^uninstall' );
			$subDir = '';
			if( ! count( $uninstallFile ) && JFolder::exists( $basepath.'admin'.DS.'install' ))
			{
				$uninstallFile = JFolder::files( $basepath.DS.'admin'.DS.'install', '^uninstall' );
				$subDir = 'install/';
			}
		}
		if (count( $uninstallFile ))
		{
			$uninstallFileElement =& $this->_manifest->createElement( 'uninstallfile' );
			$uninstallFileElement->setText( $subDir.$uninstallFile[0] );
			$root->appendChild( $uninstallFileElement );
		}


		if( JFolder::exists( $basepath.'admin'.DS.'sql' ) || JFolder::exists( $basepath.'admin'.DS.'install'.DS.'sql' ))
		{
			$subDir = '';
			if (JFolder::exists( $basepath.'admin'.DS.'sql' ))
			{
				$sqlFiles = JFolder::files( $basepath.'admin'.DS.'sql', '^install' );
			}
			else if (JFolder::exists( $basepath.'admin'.DS.'install'.DS.'sql' ))
			{
				$sqlFiles = JFolder::files( $basepath.'admin'.DS.'install'.DS.'sql', '^install' );
				$subDir = 'install/';
			}
			if (count( $sqlFiles )) {
				$install =& $this->_manifest->createElement( 'install' );
				$sql =& $this->_manifest->createElement( 'sql' );
				$install->appendChild( $sql );
				$root->appendChild( $install );
				foreach($sqlFiles as $sqlFile) {
					if (strpos( $sqlFile, 'nonutf' ) || strpos( $sqlFile, 'compat' )) {
						$installFile =& $this->_manifest->createElement( 'file' );
						$installFile->setAttribute( 'driver', 'mysql' );
						$installFile->setText( $subDir.'sql/' . $sqlFile );
						$sql->appendChild( $installFile );
					} else {
						$installFile =& $this->_manifest->createElement( 'file' );
						$installFile->setAttribute( 'driver', 'mysql' );
						$installFile->setAttribute( 'charset', 'utf8' );
						$installFile->setText( $subDir.'sql/' . $sqlFile );
						$sql->appendChild( $installFile );
					}
				}
			}

			$subDir = '';
			if (JFolder::exists( $basepath.'admin'.DS.'sql' ))
			{
				$sqlFiles = JFolder::files( $basepath.'admin'.DS.'sql', '^uninstall' );
			}
			else if (JFolder::exists( $basepath.'admin'.DS.'install'.DS.'sql' ))
			{
				$sqlFiles = JFolder::files( $basepath.'admin'.DS.'install'.DS.'sql', '^uninstall' );
				$subDir = 'install/';
			}
			if (count( $sqlFiles ))
			{
				$install =& $this->_manifest->createElement('uninstall');
				$sql =& $this->_manifest->createElement('sql');
				$install->appendChild($sql);
				$root->appendChild($install);
				foreach($sqlFiles as $sqlFile)
				{
					if (strpos( $sqlFile, 'nonutf' ) || strpos( $sqlFile, 'compat'))
					{
						$installFile =& $this->_manifest->createElement('file');
						$installFile->setAttribute('driver', 'mysql');
						$installFile->setText($subDir.'sql/'.$sqlFile);
						$sql->appendChild($installFile);
					}
					else
					{
						$installFile =& $this->_manifest->createElement('file');
						$installFile->setAttribute('driver', 'mysql');
						$installFile->setAttribute('charset', 'utf8');
						$installFile->setText($subDir.'sql/'.$sqlFile);
						$sql->appendChild($installFile);
					}
				}//foreach
			}
		}

		$folders = JFolder::folders( $basepath );
		$languageFiles = array();
		$mediaFiles = array();

		/*
		 * Site files
		 */
		if (in_array( 'site', $folders ))
		{
			if( count(JFolder::files($basepath.'site', '.', true, false)))
			{
				$siteFolders = JFolder::folders($basepath.'site');
				$siteFiles = JFolder::files($basepath.'site');
				if (JFolder::exists( $basepath.'site'.DS.'language' )) {
					$languageFiles = JFolder::files( $basepath.'site'.DS.'language', '', true, true );
				}
				if (JFolder::exists( $basepath.'site'.DS.'media' )) {
					$mediaFiles = JFolder::files( $basepath.'site'.DS.'media', '', true, true );
				}
				$siteFileElement =& $this->_manifest->createElement('files');
				$siteFileElement->setAttribute( 'folder', 'site' );
				$root->appendChild( $siteFileElement );
	
				foreach ($siteFolders as $siteFolder)
				{
					$siteFolderElement =& $this->_manifest->createElement('folder');
					$siteFolderElement->setText( $siteFolder);
					$siteFileElement->appendChild( $siteFolderElement );
				}//foreach
				foreach($siteFiles as $siteFile)
				{
					$siteElement =& $this->_manifest->createElement('filename');
					$f = $siteFile;
					switch( $this->project->comtype )
					{
						case 'module':
							if($siteFile == $this->project->entryfile.'.php')
							{
								$siteElement->setAttribute('module', $this->project->entryfile);
							}
						break;
						case 'plugin':
							if($siteFile == $this->project->entryfile.'.php')
							{
								$siteElement->setAttribute('plugin', $this->project->entryfile);
							}
						break;
					}//switch
					$siteElement->setText($siteFile);
					$siteFileElement->appendChild($siteElement);
				}//foreach
			}
		}

		if( $this->project->isNew )
		{
			$languageFiles = $this->project->languageFiles['site'];
		}

		if (count( $languageFiles )) {
			$languagesElement =& $this->_manifest->createElement( 'languages' );
			$languagesElement->setAttribute( 'folder', 'site/language' );
			$root->appendChild( $languagesElement );
			$substrlen = strlen( $basepath.'site'.DS.'language'.DS );
			foreach($languageFiles as $languageFile) {
				$languageElement =& $this->_manifest->createElement( 'language' );
				$languageElement->setAttribute( 'tag', substr( basename($languageFile), 0, 5 ) );
				$languageElement->setText( str_replace(DS, '/', substr( $languageFile, $substrlen) ) );
				$languagesElement->appendChild( $languageElement );
			}
		}

		if (count( $mediaFiles )) {
			$mediaElement =& $this->_manifest->createElement( 'media' );
			$mediaElement->setAttribute( 'folder', 'site/media' );
			$root->appendChild( $mediaElement );
			$substrlen = strlen( $basepath.'site'.DS.'media'.DS );
			foreach($mediaFiles as $mediaFile) {
				$medElement =& $this->_manifest->createElement( 'filename' );
				$medElement->setText( str_replace(DS, '/', substr( $mediaFile, $substrlen) ) );
				$mediaElement->appendChild( $medElement );
			}
		}

		if( $this->project->comtype == 'component' || $this->project->comscope == 'admin')
		{
			$administration =& $this->_manifest->createElement( 'administration' );

			if( $this->project->comtype == 'component' )
			{
				$menu =& $this->_manifest->createElement( 'menu' );

				$def_menu =( isset($this->project->menu) ) ? $this->project->menu : '';
				if( $def_menu )
				{
					$menu->setText( $def_menu['text'] );
					$menu->setAttribute( 'img', $def_menu['img'] );
					$menu->setAttribute( 'link', $def_menu['link'] );
				} else
				{
					$menu->setText( $this->project->com_name );
				}
				$administration->appendChild( $menu );

				if( isset($this->project->submenu) && count($this->project->submenu))
				{
					$submenu =& $this->_manifest->createElement( 'submenu' );
					foreach( $this->project->submenu as $item )
					{
						$menu =& $this->_manifest->createElement( 'menu' );
						$menu->setText( $item['text'] );
						$menu->setAttribute( 'img', $item['img'] );
						$menu->setAttribute( 'link', $item['link'] );
						$submenu->appendChild( $menu );
					}//foreach
					$administration->appendChild( $submenu );
				}
			}
			$root->appendChild( $administration );
		}

		$languageFiles = array();

		/*
		 * Admin files
		 */
		if (in_array( 'admin', $folders ))
		{
			if( ! isset($administration) || ! method_exists($administration, 'appendChild'))
			{
				//--Admin element has not been created yet
				$administration =& $this->_manifest->createElement('administration');
				$root->appendChild( $administration );
			}
			$adminFolders = JFolder::folders($basepath.'admin');
			$adminFiles = JFolder::files($basepath.'admin');
			if (JFolder::exists( $basepath.'admin'.DS.'language' ))
			{
				$languageFiles = JFolder::files( $basepath.'admin'.DS.'language', '', true, true );
			}
			else
			{
				$languageFiles = array();
			}
			if (JFolder::exists( $basepath.'admin'.DS.'media' ))
			{
				$mediaFiles = JFolder::files( $basepath.'admin'.DS.'media', '', true, true );
			}
			else
			{
				$mediaFiles = array();
			}
			$adminFileElement =& $this->_manifest->createElement( 'files' );
			$adminFileElement->setAttribute( 'folder', 'admin' );
			$administration->appendChild( $adminFileElement );

			foreach ($adminFolders as $adminFolder)
			{
				$adminFolderElement =& $this->_manifest->createElement( 'folder' );
				$adminFolderElement->setText( $adminFolder);
				$adminFileElement->appendChild( $adminFolderElement );
			}//foreach
			foreach($adminFiles as $adminFile)
			{
				$adminElement =& $this->_manifest->createElement( 'filename' );
				if( $this->project->comtype == 'module')
				{
					if( $adminFile == $this->project->entryfile.'.php' )
					{
						$adminElement->setAttribute( 'module', $this->project->entryfile );
					}
				}
				$adminElement->setText($adminFile);
				$adminFileElement->appendChild($adminElement);
			}//foreach
		}
		if( $this->project->isNew)
		{
			if( $this->project->comtype == 'component' || $this->project->comscope == 'admin' )
			{
				$languageFiles = $this->project->languageFiles['admin'];
			}
		}

		if (count( $languageFiles ))
		{
			$languagesElement =& $this->_manifest->createElement( 'languages' );
			$languagesElement->setAttribute( 'folder', 'admin/language' );
			$administration->appendChild( $languagesElement );
			$substrlen = strlen( $basepath.'admin'.DS.'language'.DS );
			foreach($languageFiles as $languageFile)
			{
				$languageElement =& $this->_manifest->createElement( 'language' );
				$languageElement->setAttribute( 'tag', substr( basename($languageFile), 0, 5 ) );
				$languageElement->setText( str_replace(DS, '/', substr( $languageFile, $substrlen) ) );
				$languagesElement->appendChild( $languageElement );
			}//foreach
		}

		if (count( $mediaFiles ))
		{
			$mediaElement =& $this->_manifest->createElement( 'media' );
			$mediaElement->setAttribute( 'folder', 'admin/media' );
			$administration->appendChild( $mediaElement );
			$substrlen = strlen( $basepath.'admin'.DS.'media'.DS );
			foreach($mediaFiles as $mediaFile) {
				$medElement =& $this->_manifest->createElement( 'filename' );
				$medElement->setText( str_replace(DS, '/', substr( $mediaFile, $substrlen) ) );
				$mediaElement->appendChild( $medElement );
			}
		}

		/*
		 * Parameters
		 */
		if( JFile::exists(JPath::clean(JPATH_ROOT.DS.$this->project->installxml)))
		{
			JLoader::import('helpers.parameter', JPATH_COMPONENT);
			$params = new JParameter('', JPath::clean(JPATH_ROOT.DS.$this->project->installxml));
			if( $params->_xml )
			{
				foreach( $params->_xml as $groupName=>$group )
				{
					$paramsElement =& $this->_manifest->createElement('params');
					if( $groupName != '_default' )
					{
						$paramsElement->setAttribute('group', $groupName);
					}
					$root->appendChild($paramsElement);
					foreach ($group->_children as $param)
					{
						if( is_a($param, 'JSimpleXMLElement') )
						{
							$paramElement =& $this->_manifest->createElement('param');
							foreach ($param->_attributes as $k=>$v)
							{
								$paramElement->setAttribute( $k, $v );
							}//foreach
							if( count($param->_children) )
							{
								foreach( $param->_children as $child )
								{
									if( is_a($child, 'JSimpleXMLElement') )
									{
										$optionElement =& $this->_manifest->createElement('option');
										$optionElement->setAttribute( 'value', $child->_attributes['value'] );
										$optionElement->setText($child->_data);
										$paramElement->appendChild($optionElement);
									}
								}//foreach
							}
							$paramsElement->appendChild($paramElement);
						}
					}//foreach
				}//foreach
			}
		}

		/*
		 * Package - Modules section
		 */
		if( count($this->project->modules))
		{
			$modulesElement =& $this->_manifest->createElement('modules');
			$root->appendChild( $modulesElement );
			JLoader::import('helpers.project', JPATH_COMPONENT);
			$easyProject = new easyProject($ebc_project);

			foreach($this->project->modules as $module)
			{
				//--Get the project
				if( ! $modProject = $easyProject->getProject($module['name']) )
				{
					//--Something went wrong..
					JError::raiseWarning(100, JText::sprintf('Unable to load the project %s', $module['name']));

					return false;
				}

				$xml =& JFactory::getXMLParser('Simple');

				$f = JPATH_ROOT.DS.str_replace('/', DS, $modProject->installxml);
				if( ! $xml->loadFile($f) )
				{
					JError::raiseWarning(100, JText::sprintf('Unable to load the xml file %s', $f));
					unset ($xml);
					return false;
				}
				$modElement =& $this->_manifest->createElement('module');
				$modElement->setAttribute('module', $module['name']);
				$modElement->setAttribute('client', $module['client']);
				$modElement->setAttribute('title', $modProject->com_name);
				$modElement->setAttribute('position', $module['position']);
				if($module['ordering']) { $modElement->setAttribute('ordering', $module['ordering']); }

				$modulesElement->appendChild( $modElement );

				/*
				 * Files
				 * We get the file list 'by hand' as we do not expect any files in the xml file yet
				 */
				$b =( $module['client'] == 'site' ) ? JPATH_SITE : JPATH_ADMINISTRATOR;
				$modFolders = JFolder::folders($b.DS.'modules'.DS.$module['name']);
				$modFiles = JFolder::files( $b.DS.'modules'.DS.$module['name']);
				$modFilesElement =& $this->_manifest->createElement( 'files' );
				$modFilesElement->setAttribute( 'folder', $module['name'] );
				$modElement->appendChild( $modFilesElement );

				foreach ($modFolders as $modFolder)
				{
					$modFolderElement =& $this->_manifest->createElement('folder');
					$modFolderElement->setText($modFolder);
					$modFilesElement->appendChild($modFolderElement);
				}//foreach
				foreach($modFiles as $modFile)
				{
					$modFileElement =& $this->_manifest->createElement('file');
					$modFileElement->setText($modFile);
					$modFilesElement->appendChild($modFileElement);
				}//foreach

				/*
				 * Module language
				 * from xml file
				 */
				$origLanguagesElement = $xml->document->getElementByPath('languages');
				if (is_a($origLanguagesElement, 'JSimpleXMLElement') && count($origLanguagesElement->children()))
				{
					$modLangsElement =& $this->_manifest->createElement( 'languages' );
					$modElement->appendChild( $modLangsElement );
					if($origLanguagesElement->attributes('folder'))
					{
						$modLangsElement->setAttribute('folder', $module['name'].'/language');
					}

					$files = $origLanguagesElement->children();
					foreach ($files as $file)
					{
						$modFileElement =& $this->_manifest->createElement('language');
						if ($file->attributes('tag') != '')
						{
							$modFileElement->setAttribute('tag', $file->attributes('tag'));
						}
						$modFileElement->setText($file->data());
						$modLangsElement->appendChild( $modFileElement );
					}//foreach
				}
			}//foreach
		}

		/*
		 * Package - Plugins section
		 */
		if( count($this->project->plugins))
		{
			// TODO plugins section
			$pluginsElement =& $this->_manifest->createElement('plugins');
			$root->appendChild( $pluginsElement );
			JLoader::import('helpers.project', JPATH_COMPONENT);
			$easyProject = new easyProject();

			foreach($this->project->plugins as $item)
			{
				//--Get the project
				if( ! $tProject = $easyProject->getProject($item['name']) )
				{
					//--Something went wrong..
					JError::raiseWarning(100, JText::sprintf('Unable to load the project %s', $item['name']));

					return false;
				}

				$xml =& JFactory::getXMLParser('Simple');

				$f = JPATH_ROOT.DS.str_replace('/', DS, $tProject->installxml);
				if( ! $xml->loadFile($f) )
				{
					JError::raiseWarning(100, JText::sprintf('Unable to load the xml file %s', $f));
					unset ($xml);
					return false;
				}
				$plgElement =& $this->_manifest->createElement('plugin');
				$plgElement->setAttribute('plugin', $item['name']);
				$plgElement->setAttribute('group', $item['client']);
				$plgElement->setAttribute('title', $tProject->com_name);
				if($item['order']) { $plgElement->setAttribute('order', $item['order']); }

				$pluginsElement->appendChild( $plgElement );

				/*
				 * Files
				 * We get the file list 'by hand' as we do not expect any files in the xml file yet
				 */
				$plgFilesElement =& $this->_manifest->createElement('files');
				$plgFilesElement->setAttribute( 'folder', 'plg_'.$item['name'] );
				$plgElement->appendChild( $plgFilesElement );

				foreach ($tProject->copys as $copy)
				{
					$fName = JPATH_ROOT.DS.$copy['source'];
					if( JFolder::exists($fName))
					{
						$tName = str_replace('plugins'.DS.$item['client'].DS, '', $copy['source']);
						$plgFolderElement =& $this->_manifest->createElement('folder');
						$plgFolderElement->setText($tName);
						$plgFilesElement->appendChild($plgFolderElement);
					}
					else if( JFile::exists($fName) )
					{
						$tName = JFile::getName($fName);
						$plgFileElement =& $this->_manifest->createElement('file');
						$plgFileElement->setText($tName);
						$plgFilesElement->appendChild($plgFileElement);
					}
					else
					{
						//@todo error
	#					$this->_addLog('Not found<br />SRC: '.$fName,'FILE NOT FOUND');
					}
				}//foreach
				
				/*
				 * Plugin language
				 * from xml file
				 */
				$origLanguagesElement = $xml->document->getElementByPath('languages');
				if (is_a($origLanguagesElement, 'JSimpleXMLElement') && count($origLanguagesElement->children()))
				{
					$plgLangsElement =& $this->_manifest->createElement( 'languages' );
					$plgElement->appendChild( $plgLangsElement );
#					if($origLanguagesElement->attributes('folder'))
#					{
						$plgLangsElement->setAttribute('folder', 'plg_'.$item['name'].'/language');
#					}

					$files = $origLanguagesElement->children();
					foreach ($files as $file)
					{
						$plgFileElement =& $this->_manifest->createElement('language');
						if ($file->attributes('tag') != '')
						{
							$plgFileElement->setAttribute('tag', $file->attributes('tag'));
						}
						$plgFileElement->setText($file->data());
						$plgLangsElement->appendChild( $plgFileElement );
					}//foreach
				}
			}//foreach
		}

		$this->_manifest->setXMLDeclaration( '<?xml version="1.0" encoding="utf-8"?>' );

		if( $this->project->isNew )
		{
			//--New project
			$fileName = JPath::clean($this->project->installxml);
		}
		else
		{
			//--Building project
			$fileName = JFile::getName(JPath::clean($this->project->installxml));
		}

		if( ! $this->_manifest->saveXML_utf8( JPath::clean($basepath.strtolower($fileName)), true ))
		{
			$this->setError( 'Could not save XML file!' );
			return false;
		}
		return true;
	}

	/**
	 * ADD NiK
	 * @return string - normalized xml string
	 */
	function getNormalizedString($htmlSafe=false)
	{
		return $this->_manifest->toNormalizedString( $htmlSafe );
	}// function

}//class