<?php
//=============================================================================
//
// Copyright Francois Laupretre <phk@tekwire.net>
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
//
//=============================================================================
/**
* @copyright Francois Laupretre <phk@tekwire.net>
* @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, V 2.0
* @category PHK
* @package PHK
*///==========================================================================

namespace PHK\Virtual {

if (!class_exists('PHK\Virtual\Tree',false))
{
//============================================================================
/**
* A virtual tree
*
* A virtual tree contains virtual nodes (files and directories)
*
* API status: Private
* Included in the PHK PHP runtime: Yes
* Implemented in the extension: No
*///==========================================================================

class Tree
{

public $fspace;		// Associated filespace

private $edata; // Exported data. Always contains a key for every node, even
				// in creator mode.

private $nodes;	// Tree nodes (key=path, value=Node object). Contains
				// only the unserialized nodes. In creator mode, contains
				// every node.

private static $char_to_class=array( 'D' => 'Dir', 'F' => 'File');

//---
// Create a tree from the edata stored in the PHK archive

public static function createFromEdata($serial_edata,\PHK\PkgFileSpace $fspace)
{
$tree=new self($fspace);

$tree->edata=unserialize($serial_edata);

return $tree;
}

//---

public function pathList()
{
return array_keys($this->edata);
}

//---

public function pathExists($rpath)
{
return array_key_exists($rpath,$this->edata);
}

//---

public function count()
{
return count($this->edata);
}

//---

public function walk($method)
{
$args=func_get_args();
array_shift($args);

foreach($this->pathList() as $path)
	{
	$node=$this->rlookup($path);
	call_user_func_array(array($node,$method),$args);
	}
}

//---
// Reduce the path to a canonical path - suppress '..' and '.' components
// Root=''
// Non-root: /xxx[/yyy...]

private function realpath($path)
{
$a=explode('/',trim($path,'/'));
$ra=array();
foreach($a as $comp)
	{
	switch($comp)
		{
		case '':
		case '.':
			break;
		case '..':
			if (count($ra)) array_pop($ra);
			break;
		default:
			$ra[]=$comp;
		}
	}
if (!count($ra)) return '';
return '/'.implode('/',$ra);
}

//---

public function lookup($path,$exception_flag=true)
{
return $this->rlookup(self::realpath($path),$exception_flag);
}

//---
// Lookup without path canonicalization - faster if self::realpath() has
// already been called

private function rlookup($path,$exception_flag=true)
{
if (array_key_exists($path,$this->edata))
	{
	if (!array_key_exists($path,$this->nodes))
		{
		$edata=$this->edata[$path];
		$class=__NAMESPACE__.'\\'.self::$char_to_class[$edata{0}];
		$node=$this->nodes[$path]=new $class($path,$this);
		$node->import(substr($edata,1));
		}
	return $this->nodes[$path];
	}

//echo "Lookup failed : <$path> <$rpath>\n";//TRACE
//print_r(array_keys($this->nodes));//TRACE
	
if ($exception_flag) throw new \Exception($path.': path not found');
else return null;
}

//---

public function lookupFile($path,$exception_flag=true)
{
$f=$this->lookup($path,$exception_flag);

if ((!is_null($f)) && (!($f instanceof File)))
	{
	if ($exception_flag) throw new \Exception($path.': No such file');
	else return null;
	}

return $f;
}

//---

public function displayHeader($html)
{
if ($html) echo '<table border=1 bordercolor="#BBBBBB" cellpadding=3 '
	.'cellspacing=0 style="border-collapse: collapse"><tr><th>T</th>'
	.'<th>Name</th><th>Size</th><th>Flags</th></tr>';
}

//---

public function displayFooter($html)
{
if ($html) echo '</table>';
}

//---
// $link = wether we display an hyperlink on file names (in HTML mode)

public function display($link)
{
$html=\PHK\Tools\Util::envIsWeb();

$this->displayHeader($html);
$this->walk('display',$html,$link);
$this->displayFooter($html);
}

//---

public function displayPackages()
{
$html=\PHK\Tools\Util::envIsWeb();

ob_start();
$this->walk('displayPackage',$html);
$data=ob_get_clean();

if ($data!=='')
	{
	$this->displayHeader($html);
	$this->walk('displayPackage',$html);
	$this->displayFooter($html);
	}
}

//---

public function dump($base)
{
$this->walk('dump',$base);
}

//---
// Same as dirname() function except:
// - Always use '/' as separator
// - Returns '' for 1st level paths ('/xxx')

public static function dirBaseName($path)
{
$dir=preg_replace(',/[^/]*$,','',$path);
$base=preg_replace(',^.*/,','',$path);
return array($dir,$base);
}

//---
// called from createEmpty() or createFromEdata() only => private

private function __construct($fspace)
{
$this->fspace=$fspace;
$this->nodes=array();
}

// <CREATOR> //---------------

// Check for a list of forbidden chars in node names. Especially important for
// '#*' which can create conflicts in mount points (for subpackages), and ';'
// which is used as separator when exporting the list of dir children.

public function addNode($path,$node)
{
$path=self::realpath($path);

if (strpbrk($path,'#*?!&~"|`\^@[]={}$;,<>')!==false)
	throw new \Exception("$path: Invalid characters in path");

if ($path != '')
	{
	list($dir,$basename)=self::dirBaseName($path);

	$dirnode=$this->rlookup($dir,false);
	if (is_null($dirnode)) $dirnode=$this->mkdir($dir);

	if (!($dirnode instanceof Dir))
		throw new \Exception("Cannot add node over a non-directory node ($dir)");

	$dirnode->addChild($basename);
	}

// Add the node

$this->edata[$path]=null;
$this->nodes[$path]=$node;
}

//---
// Create an empty tree

public static function createEmpty()
{
$tree=new self(null);
$tree->addNode('',new Dir('',$tree));

return $tree;
}

//---

public function export(\PHK\Build\Creator $phk,$map=null)
{
$edata=array();
$stacker=new \PHK\Build\DataStacker();

foreach($this->nodes as $path => $node)
	{
	$edata[$path]=array_search(substr(get_class($node),strlen(__NAMESPACE__)+1),self::$char_to_class)
		.$node->export($phk,$stacker,$map);
	}
ksort($edata); // To display files in the right order

return array(serialize($edata),$stacker->data);
}

//---
// target: absolute target path. '&' is replaced by source basename
// sapath: Absolute source path
// modifiers: array received from \PHK\Build\PSF\CmdOptions

public function mergeIntoFileTree($target,$sapath,$modifiers)
{
if (!file_exists($sapath))
	throw new \Exception($sapath.': Path not found');

$target=self::realpath(str_replace('&',basename($sapath),$target));

switch($type=filetype($sapath))
	{
	case 'file':
		if ($target=='') throw new \Exception('Cannot replace root dir with a file');
		$this->remove($target);
		$this->mkfile($target,\PHK\Tools\Util::readFile($sapath),$modifiers);
		break;

	case 'dir':
		foreach(\PHK\Tools\Util::scandir($sapath) as $subname)
			{
			$this->mergeIntoFileTree($target.'/'.$subname,$sapath.'/'.$subname
				,$modifiers);
			}
		break;

	default:
		\Phool\Display::info("$sapath : Unsupported file type ($type) - Ignored");
	}
}

//---

private function getSubtree($path)
{
$rpath=self::realpath($path);

if ($rpath=='') return $this->pathList();

$result=array();
$prefix=$rpath.'/';
$len=strlen($prefix);
foreach($this->pathList() as $p)
	{
	if (($p==$rpath)||((strlen($p)>=$len)&&(substr($p,0,$len)==$prefix)))
		$result[]=$p;
	}
return $result;
}

//---

public function modify($path,$modifiers)
{
$path=self::realpath($path);

foreach ($this->getSubtree($path) as $subpath)
	{
	$this->lookup($subpath)->modify($modifiers);
	}
}

//---
// If parent dir does not exist, addNode() will call us back to create it,
// and it goes on recursively until the root node is reached.

public function mkdir($path,$modifiers=array())
{
$rpath=self::realpath($path);

if (is_null($node=$this->rlookup($rpath,false))) // If node does not exist
	{
	$node=new Dir($path,$this);
	$node->modify($modifiers);
	$this->addNode($path,$node);
	}
else // If node already exists, check that it is a directory
	{
	if (($type=$node->type())!='dir')
		throw new \Exception("mkdir: $path is already a $type");
	}
return $node;
}

//---

public function mkfile($path,$data,$modifiers=array())
{
$rpath=self::realpath($path);

$node=new File($rpath,$this);
$node->setData($data);
$node->modify($modifiers);

$this->addNode($rpath,$node);

return $node;
}

//---

public function remove($path)
{
$rpath=self::realpath($path);
if ($rpath=='') throw new \Exception('Cannot remove root directory');

if (is_null($this->rlookup($rpath,false))) return; // Path does not exist

foreach($this->getSubtree($rpath) as $p)
	{
	unset($this->nodes[$p]);
	unset($this->edata[$p]);
	}

list($dir,$name)=self::dirBaseName($rpath);
$this->rlookup($dir)->removeChild($name);
}

// </CREATOR> //---------------

//---
} // End of class
//===========================================================================
} // End of class_exists
//===========================================================================
} // End of namespace
//===========================================================================
?>