<?php
/**
 * @class VOTableMgr

 * @version $Id: VOTableMgr.php 2916 2015-05-19 13:08:33Z elena $

 */

//set DEBUG_MODE to TRUE to have some log information
define("DEBUG_MODE", FALSE);

class VOTableMgr {

	private $xml, $xp;
	private $logVotable; // The log file.
	private $stream; // The stream in the VOTable
	private $c; // Current character position on the stream

	private $is_little_endian;

	private $votable_error = false;

	function load($fileName) {

		// error_log("Loading " . $fileName);

		$this->is_little_endian = array_values(unpack('L1L', pack('V', 1)))[0] == 1;

		// see http://php.net/manual/en/domdocument.load.php#91384

		$options = array(
			'http' => array(
				'method' => 'GET',
				'timeout' => '5',

				'user_agent' => 'PHP libxml agent',
				// If the query is wrong, epn-tap service returns an HTTP error code 400, along with xml containing some usefull informations.
				'ignore_errors' => true

			)

		);

		$context = stream_context_create($options);

		libxml_set_streams_context($context);

		$this->xml = new DomDocument();

		try {

			$load_res = $this->xml->load($fileName);

		} catch (Exception $e) {
			$this->votable_error = $e->message;

			return false;

		}

		$this->checkIDAttribute();

		$rootNamespace = $this->xml->lookupNamespaceUri($this->xml->namespaceURI);
		$this->xp = new domxpath($this->xml);
		$this->xp->registerNameSpace('x', $rootNamespace);

		return true;
	}

	function getVotableError() {
		return $this->votable_error;
	}

	function isValidSchema() {
		if ($this->votable_error != false) {

			return false;
		}

		if (!$this->xml) {
			$this->votable_error = "The returned file is not XML.";

			return false;
		}

		$infos = $this->xp->query($this->queryResourceInfo());
		foreach($infos as $info) {
			if($info->getAttribute('value') == 'ERROR') {

				$this->votable_error = $info->textContent;

				return false;

			}
		}

		//ToDo - BRE - add validation!!

		return true;

		 if (DEBUG_MODE)
			 libxml_use_internal_errors(true);

		 $vers = $this->getVersion();

		 $result = FALSE;

		 switch ($vers)
		 {
		 	 case '1.2' :
		 	 	 $result = $this->xml->schemaValidate(XMLPATH.'VOTable-1.2.xsd');
		 	 case '1.0' :
		 	 	 $result = $this->xml->schemaValidate(XMLPATH.'VOTable-1.0.xsd');
		 	 default :
		 		 $result = $this->xml->schemaValidate(XMLPATH.'VOTable-1.1.xsd');
		 }

		 if (DEBUG_MODE)
		 {
			 $errors = libxml_get_errors();

			 foreach ($errors as $error)
			 {
			 	 $msg = '';

				switch ($error->level)
				{
					case LIBXML_ERR_WARNING:
						$msg .= ("WARNING ".$error->code.": ");
						break;
					case LIBXML_ERR_ERROR:
						$msg .= ("ERROR ".$error->code.": ");
						break;
					case LIBXML_ERR_FATAL:
						$msg .= ("FATAL ".$error->code.": ");
						break;
				}
				$msg .= ($error->message." - In line : ".$error->line." - Of file : ".$error->file."\n");

				error_log($msg);

			 }

			 libxml_use_internal_errors(false);
		 }

		return $result;
	}

	protected function queryResource()
	{
		 return "//x:RESOURCE";
	}

	protected function queryResourceInfo()
	{
		return $this->queryResource()."/x:INFO";
	}

	protected function queryTable()
	{
		 return $this->queryResource()."/x:TABLE";
	}

	protected function queryDescription()
	{
		 return $this->queryTable()."/x:DESCRIPTION";
	}

	protected function queryFields()
	{
		 return $this->queryTable()."/x:FIELD";
	}

	protected function queryField($field_id)
	{
		 return $this->queryFields()."[@ID='".$field_id."']";
	}

	protected function queryFieldByName($field_id)
	{
		 return $this->queryFields()."[@name='".$field_id."']";
	}
	protected function queryFieldDescription($field_id)
	{
		 return $this->queryField($field_id)."/x:DESCRIPTION";
	}

	protected function queryData()
	{
		 return $this->queryTable()."/x:DATA";
	}

	protected function queryTableData()
	{
		 return $this->queryData()."/x:TABLEDATA";
	}

	protected function queryTR()
	{
		 return $this->queryTableData()."/x:TR";
	}

	protected function queryBinaryData() {
		return $this->queryData()."/x:BINARY";
	}

	protected function queryStream() {
		return $this->queryBinaryData()."/x:STREAM";
	}

	public function getVersion()
	{
		 if (!$this->xml)
		 		return '';
		 $root = $this->xml->documentElement;

		 return $root->getAttribute('version');
	}

	public function getDescription()
	{
		 if (!$this->xp)
			 return '';

		 $desc = $this->xp->query($this->queryDescription());

		 if ($desc->length < 1)
			 return '';

		 return $desc->item(0)->nodeValue;
	}

	private function get_row_size($field_node) {
		$datatype = $field_node->getAttribute("datatype");

		if($datatype == 'boolean') {
			return 1;
		}

		switch($datatype) {

			case 'unsignedByte':
			case 'char':
				$block_size = 1;
				break;
			case 'unicodeChar':
			case 'short':
				$block_size = 2;
				break;
			case 'int':
			case 'float':
				$block_size = 4;
				break;
			case 'long':
			case 'double':
			case 'float_complex':
				$block_size = 8;
				break;
			case 'double_complex':

				$block_size = 16;

			default:
				$block_size = 0;
				break;
		}

		if($field_node->getAttribute("arraysize") == NULL) {
			$array_size = $block_size;
		} else if("*" == $field_node->getAttribute("arraysize")) {

			$array_size = unpack("Ns", substr($this->stream, $this->c, 4))["s"] * $block_size;

			$this->c+=4;
		} else {
			$array_size = (int)($field_node->getAttribute("arraysize")) * $block_size;
		}
		return $array_size;
	}

	/** Get the VOTable stream content.*/

	public function parseStream() {

		if (! $this->isValidSchema()) {

			error_log('There is an error on the VOTable: ' . $this->votable_error);

			return null;

		}

		$data = Array();
		$fields = $this->xp->query($this->queryFields());

		$resource = $this->xp->query($this->queryResource());

		$nb_columns = $fields->length;
		$row = Array();
		$n_value = 0; // index of current value
		$this->c = 0; // initialize cursor position.
		$query_stream = $this->xp->query($this->queryStream())->item(0);

		if($query_stream == NULL) {
			$this->votable_error = "There is no STREAM node in the VOTable file.";

			return null;

		}

		$this->stream = base64_decode($query_stream->textContent);

		$stream_len = strlen($this->stream);

		if($stream_len == 0) {

			$this->votable_error = "no result";

			return null;

		}

		while($this->c < strlen($this->stream)) {
			$col_id = $n_value % $nb_columns;

			$field_node = $fields->item($col_id);

			if($col_id == 0) {
				$row = Array();
			}
			$row[$field_node->getAttribute("ID")] = $this->process_datablock($field_node);
			if($col_id == $nb_columns-1) {
				array_push($data, $row);

			}

			$n_value+=1;

		}

		return $data;
	}

	private function JDTodate($jd) {
		list($month, $day, $year) = split('/', JDToGregorian($jd));
		return "$day/$month/$year";
	}

	private function process_datablock($field_node) {
		$data_type = $field_node->getAttribute("datatype");
		$row_size = $this->get_row_size($field_node);

		$substr = substr($this->stream, $this->c, $row_size);

		switch ($data_type) {
			case 'boolean':
			case 'unsignedByte':

				$b = $substr;
				$res = $b == "T" || $b == "t" || $b == "1";

				break;
			case 'char':

				$res = $row_size!=0 ? utf8_encode($substr) : NULL;

			case 'unicodeChar':

				$res = $row_size!=0 ? utf8_encode(str_replace("\0", "", $substr)) : NULL;

				break;
			case 'short':

				$res = unpack("ss", $substr)["s"];

				break;
			case 'int':

				$res = unpack("Ns", $substr)["s"];

				break;
			case 'long':

				$res = unpack("Js", $substr)["s"];  // /!\ J -> PHP 5.6 only

				break;
			case 'float':

				$res = unpack("fs", $substr)["s"];

				// If machine is little endian:
				if($this->is_little_endian) {
					$res = unpack('f1f', strrev(pack('f', $res)))["f"];
				}

				break;
			case 'double':

				$res = unpack("ds", $substr)["s"];

				// If machine is little endian:
				if($this->is_little_endian) {
					$res = unpack('d1d', strrev(pack('d', $res)))["d"];
				}

				break;
			default:
				$res = NULL;

				error_log("Unknown character: $data_type");

				break;
		}
		$this->c+=$row_size;

		return (string)$res;

	}

	public function getFirstTR()
	{
		 if (!$this->xp)
			 return NULL;

		 /*$trs = $this->xp->query($this->queryTR());

		 if ($trs->length < 1)
			 return NULL;

		 return $trs->item(0);*/

		$tabledatas = $this->xp->query($this->queryTableData());
		 if ($tabledatas->length < 1)
			 return NULL;

		 $tabledata = $tabledatas->item(0);

		 $node = $tabledata->firstChild;

		 while($node && ($node->nodeType != 1) && ($node->nodeName != "TR"))
			$node = $node->nextSibling;

		return $node;
	}

	public function getNextTR($tr)
	{
		 if (!$this->xp)
			 return NULL;

		while($tr->nextSibling && ($tr->nextSibling->nodeType != 1) && ($node->nodeName != "TR"))
			$tr = $tr->nextSibling;

				return $tr->nextSibling;

	}

	public function getTDValueByFieldIndex($tr,$field_index)
	{
		 if (!$this->xp)
			 return NULL;

		 $tds = $tr->getElementsByTagName("TD");

		 if (($tds->length < 1) || ($field_index >= $tds->length))
			 return NULL;

		 return $tds->item($field_index)->nodeValue;
	}

	protected function isTimeField($field)
	{
		if (!$this->xp)
			 return FALSE;

		 return (($field->getAttribute("ucd") == "time.epoch") && ($field->getAttribute("xtype") == "dateTime"));
	}

	public function getTimeFieldIndex()
	{
		 if (!$this->xp)
			 return -1;

		 $fields = $this->xp->query($this->queryFields());

		 if ($fields->length < 1)
			 return -1;

		 for ($i = 0; $i < $fields->length; $i++)
			 if ($this->isTimeField($fields->item($i)))
				 return $i;

		 return -1;
	}

	protected function getFieldByID($field_id)
	{
		 if (!$this->xp)
			 return NULL;

		 $fields = $this->xp->query($this->queryFields());

		 if ($fields->length < 1)
			 return NULL;

		 foreach ($fields as $field)
			 if ($field->getAttribute("ID") == $field_id)
				 return $field;

		 return NULL;
	}

		protected function getFieldByName($field_id)
	{
		 if (!$this->xp)
			 return NULL;

		 $fields = $this->xp->query($this->queryFieldByName($field_id));

		 if ($fields->length < 1)
			 return NULL;

		 foreach ($fields as $field)
			 if ($field->getAttribute("name") == $field_id)
				 return $field;

		 return NULL;
	}

	protected function checkIDAttribute(){

			$fields = $this->xml->getElementsByTagName('FIELD');
			$i = 0;
			foreach ($fields as $field){

	$i++;
	if (!$field->hasAttribute("ID")){

			$field->setAttribute("ID", "col".$i);
	}
			}
			$this->xml->saveXML();

	}

	public function getFieldIndexByID($field_id)
	{
		 if (!$this->xp)
			 return -1;

		 $fields = $this->xp->query($this->queryFields());

		 if ($fields->length < 1)
			 return -1;

		 for ($i = 0; $i < $fields->length; $i++)
			 if ($fields->item($i)->getAttribute("ID") == $field_id)
				 return $i;

		 return -1;
	}

	public function getStartStop()
	{
		 if (!$this->xp)
			 return '0 0';

		$timeIndex = $this->getTimeFieldIndex();
		if ($timeIndex < 0)
			return '0 0';

		$tr = $this->getFirstTR();

		if (!$tr)
			return '0 0';

		$start = $this->getTDValueByFieldIndex($tr,$timeIndex);

		$stop = $start;
		while ($tr)
		{
			$stop = $this->getTDValueByFieldIndex($tr,$timeIndex);
			$tr = $this->getNextTR($tr);
		}

		if (!$start)
			$start = 0;
		else
			$start = strtotime($start);

		if (!$stop)
			$stop = 0;
		else
			$stop = strtotime($stop);

		return $start." ".$stop;
	}

	public function getFieldInfoByID($field_id)
	{
	 if (!$this->xp)
			 return array("id"		=> $field_id,
										"error" => "No file loaded");

								 $field = $this->getFieldByID($field_id);

		 if (!$field)
			$field = $this->getFieldByName($field_id);

		 if (!$field)
			 return array("id"		=> $field_id,
										"error" => "This field doesn't exist");
		 return $this->getFieldInfo($field);
	}


	public function getFieldInfo($field)
	{
		if (!$this->xp)
			return array("id"		=> $field_id,
			"error" => "No file loaded");
		$description = '';
		$desc = $field->getElementsByTagName("DESCRIPTION");
		if ($desc->length >= 1)
			$description = $desc->item(0)->nodeValue;

		$size = $field->getAttribute("arraysize");
		if ($size == '')
			$size = 1;
		else
			$size = intval($size);

		switch ($field->getAttribute("datatype"))
		{
			 case "short" :
			 	 $type = "SHORT";
			 	 break;
			 case "int" :
			 	 $type = "INTEGER";
			 	 break;
			 case "long"	 :
			 case "double" :
				 $type = "DOUBLE";
				 break;
			 default :
					$type = "FLOAT";
		}

	if (!$field->getAttribute("ID"))

		$id = "col".$n;

	else $id = $field->getAttribute("ID");

		 return array("id"		 => $field->getAttribute("ID"),
								 "type"				=> $type,
								 "name"				=> $field->getAttribute("name"),
								 "ucd"				 => $field->getAttribute("ucd"),
								 "unit"				=> $field->getAttribute("unit"),
								 "size"				=> $size,
								 "description" => $description
								);
	}

	public function getFieldsInfo()
	{
	 	 if (!$this->xp)
			 return array("error" => "No file loaded");

		$fields_info = array();

		 $fields = $this->xp->query($this->queryFields());

		 if ($fields->length < 1)
			 return $fields_info;

		foreach ($fields as $field)
		{
		 	if ($this->isTimeField($field))
				continue;

			array_push($fields_info,$this->getFieldInfo($field));
		}

		return $fields_info;
	}

	public function getSamplings()
	{
		 if (!$this->xp)
			 return array("minSampling" => 0,
									 "maxSampling" => 0);

		 $timeIndex = $this->getTimeFieldIndex();
		if ($timeIndex < 0)
			return array("minSampling" => 0,
									 "maxSampling" => 0);

		$tr = $this->getFirstTR();

		if (!$tr)
			return array("minSampling" => 0,
									 "maxSampling" => 0);

		$prevTime = 0;
		while ($tr)
		{
			$time = $this->getTDValueByFieldIndex($tr,$timeIndex);

			if ($time)
			{
				$time = strtotime($time);
				if (($prevTime > 0) && ($time-$prevTime > 0))
					$deltaT[$time-$prevTime]++;
				$prevTime = $time;
			}

			$tr = $this->getNextTR($tr);
		}

		$minSampling = +1.e31;
		$maxSampling = 0.0;

		foreach ($deltaT as $key => $value)
		{

		 if ($value/count($deltaT) < 0.10)
				continue;

			if ($key < $minSampling) $minSampling = $key;
			if ($key > $maxSampling) $maxSampling = $key;
		}

		return array("minSampling" => $minSampling,
								 "maxSampling" => $maxSampling);
	}

	public function args2vector($file, $paramID){

	$argsArr = explode('_', $paramID);

	$dom = new DOMDocument();
	$dom->load($file);
	$fields = $dom->getElementsByTagName('FIELD');
	$table = $dom->getElementsByTagName('TABLE')->item(0);
	$i=0;
	foreach ($fields as $field){
			if ($field->getAttribute('name') == $argsArr[0]){

	$unit = $field->getAttribute('unit');

	$ucd	= $field->getAttribute('ucd');
	$datatype	= $field->getAttribute('datatype');

	$firstTD = $i;

		}
		$i++;
	}
	if ($firstTD > 0){
		$table->removeChild($fields->item($firstTD + 2));
		$table->removeChild($fields->item($firstTD + 1));
		$table->removeChild($fields->item($firstTD));

		$i = 0;
		foreach ($fields as $field){

	$i++;

	if (strpos($field->getAttribute('ID'),'col') !== FALSE){

			$field->setAttribute('ID', 'col'.$i);
			$dom->saveXML();
	}
		}

		$group = $dom->createElement('GROUP');
		$group->appendChild(new DOMAttr('ID', 'info_'.$paramID));
		$table->appendChild($group);

		$param = $dom->createElement('PARAM');
		$param->appendChild(new DOMAttr('ID', 'components_'.$paramID));
		$param->appendChild(new DOMAttr('name', 'components_'.$paramID));
		$param->appendChild(new DOMAttr('datatype', 'char'));
		$param->appendChild(new DOMAttr('arraysize', '*'));
		$param->appendChild(new DOMAttr('value', $argsArr[0].' '.$argsArr[1].' '.$argsArr[2] ));
		$group->appendChild($param);

		$new_field = $dom->createElement('FIELD');
		$new_field->appendChild(new DOMAttr('ID', $paramID));
		$new_field->appendChild(new DOMAttr('name', $paramID));
		$new_field->appendChild(new DOMAttr('datatype', $datatype));
		$new_field->appendChild(new DOMAttr('arraysize', '3'));
		$new_field->appendChild(new DOMAttr('unit', $unit));
		$new_field->appendChild(new DOMAttr('ucd', $ucd));
		$new_field->appendChild(new DOMAttr('ref', 'info_'.$paramID));
		$table->appendChild($new_field);

		$trs = $dom->getElementsByTagName('TR');
		foreach($trs as $tr){
			$tds = $tr->getElementsByTagName('TD');
			$value = trim($tds->item($firstTD)->nodeValue).' '.trim($tds->item($firstTD + 1)->nodeValue).' '.trim($tds->item($firstTD + 2)->nodeValue);
			$toRemote	= $tds->item($firstTD);
			$tr->removeChild($toRemote);
			 $toRemote = $tds->item($firstTD);
			$tr->removeChild($toRemote);
			 $toRemote = $tds->item($firstTD);
			$tr->removeChild($toRemote);

			$td = $dom->createElement('TD', $value);
			$tr->appendChild($td);
		}

		$dom->save($file);
		}
	}

}

?>