<?php
/*
 * Copyright 2008 Marc Mongenet
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */

require_once 'defines.php';
require_once 'str.php';


define('PATH_NAME_STR', ALPHA_NUM_STR.'/._-');


function parse_w2ml_uri($str) {
	if (str_case_start_with($str, 'site:')) {
		return parse_site_uri($str);
	}
	elseif (str_case_start_with($str, 'exe:')) {
		return parse_exe_uri($str);
	}
	$uri = @parse_url($str);
	switch ($uri['scheme']) {
	case NULL:
	case 'file':
	case 'http';
		return $uri;
	default:
		return FALSE;
	}
}


function parse_site_uri($str) {
	$str_after_scheme = substr($str, 5);
	if ($str_after_scheme === FALSE ||
	    $str_after_scheme === '' ||
	    strlen($str_after_scheme) !== strspn($str_after_scheme, PATH_NAME_STR)) {
		return FALSE;
	}
	$uri = @parse_url('file:'.$str_after_scheme);
	if ($uri === FALSE || $uri['host'] !== NULL || $uri['path']{0} !== '/') {
		return FALSE;
	}
	$uri_path_segments = explode('/', $uri['path']);
	if (in_array('.',  $uri_path_segments, TRUE) ||
	    in_array('..', $uri_path_segments, TRUE)) {
		return FALSE;
	}
	$uri['scheme'] = 'site';
	return $uri;
}


function parse_exe_uri($str) {
	$str_after_scheme = substr($str, 4);
	if ($str_after_scheme === FALSE || $str_after_scheme === '') {
		return FALSE;
	}
	$uri['scheme'] = 'exe';
	$uri['path'] = $str_after_scheme;
	return $uri;
}


# Check that the file exists, is in W2ML document root.
function site_uri_to_path($uri) {
	$uri_path = $uri['path'];
	$full_file_name = realpath(REAL_W2ML_DOC_ROOT . $uri_path);
	if (!str_start_with($full_file_name, REAL_W2ML_DOC_ROOT)) {
		return FALSE;
	}
	return $full_file_name;
}


# Check that the file exists, is in W2ML document root.
function site_uri_to_file_name($uri) {
	$uri_path = $uri['path'];
	if (str_end_with($uri_path, '/')) {
		return FALSE;
	}
	$full_file_name = realpath(REAL_W2ML_DOC_ROOT . $uri_path);
	if (!str_start_with($full_file_name, REAL_W2ML_DOC_ROOT)) {
		return FALSE;
	}
	return $full_file_name;
}


/*
 * Return canonized $path. Canonization removes '.' and '..' segments. Examples:
 * ""            -> ""
 * "."           -> "."
 * ".."          -> ".."
 * "/"           -> "/"
 * "foo"         -> "foo"
 * "/foo"        -> "/foo"
 * "foo/"        -> "foo/"
 * "foo/bar"     -> "foo/bar"
 * "foo//bar"    -> "foo/bar"
 * "foo/./bar"   -> "foo/bar"
 * "foo/../bar"  -> "bar"
 * "//"          -> "/"
 * "/."          -> "/"
 * "/.."         -> "/"
 * "./"          -> "./"
 * "../"         -> "../"
 * "foo/.."      -> ""
 * "foo/../.."   -> ".."
 * "./foo"       -> "foo"
 */
function canonize_uri_path($path) {
	$segments = explode('/', $path); # Note: path "/" explodes to array('','').
	$segments_count = count($segments);
	$canon_segments = array();
	for ($n = 0; $n < $segments_count; ++$n) {
		$segment = $segments[$n];
		if ($segment === '') {
			if ($n === 0 || $n === $segments_count - 1) {
				# We are here iff path starts or ends with '/', and we want
				# to keep empty segments only on path extremities.
				$canon_segments[] = $segment;
			}
		}
		elseif ($segment === '.') {
			if ($n === 0) {
				# We keep only the first dot segment.
				$canon_segments[] = $segment;
			}
			elseif ($n === $segments_count - 1) {
				# So that 'foo/.' -> 'foo/' and not 'foo'.
				$canon_segments[] = '';
			}
		}
		elseif ($segment === '..') {
			$c = count($canon_segments);
			if ($c === 0 || $canon_segments[$c - 1] === '..') {
				# Dot-dot segments are kept only at the start of canonized path.
				$canon_segments[] = $segment;
			}
			elseif ($canon_segments[$c - 1] !== '') {
				# Dot-dot pop previous segment, except first empty segment,
				# i.e. "/.." path is canonized to "/" path.
				array_pop($canon_segments);
			}
		}
		else {
			$canon_segments[] = $segment;
		}
	}
	return implode('/', $canon_segments); # Note: array('','') implodes to "/".
}


# Return $path up to the last slash. Return './' if no slash.
function base_uri_path($path) {
	$last_slash_pos = strrpos($path, '/');
	if ($last_slash_pos === FALSE) {
		return './';
	}
	return substr($path, 0, $last_slash_pos + 1);
}


function combine_uri_pathes($path1, $path2) {
	$combined_path = $path2{0} === '/' ? $path2 : base_uri_path($path1).$path2;
	return canonize_uri_path($combined_path);
}


function combine_uris($uri1, $uri2) {
	if ($uri2['scheme'] !== NULL) {
		$combined_uri = $uri2;
	} else {
		$combined_uri = $uri1;
		$combined_uri['path'] = combine_uri_pathes($uri1['path'], $uri2['path']);
		$combined_uri['query'] = $uri2['query'];
		$combined_uri['fragment'] = $uri2['fragment'];
		# Reparse all to check URI validity.
		$combined_uri = parse_w2ml_uri(unparse_uri($combined_uri));
	}
	return $combined_uri;
}


function is_hierarchical_uri_scheme($scheme) {
	return $scheme === 'file'  ||
	       $scheme === 'ftp'   ||
	       $scheme === 'http'  ||
	       $scheme === 'https' ||
	       $scheme === 'site';
}


function unparse_uri_host($uri) {
	$res = '';
	$scheme = $uri['scheme'];
	if ($scheme !== NULL) {
		$res = $scheme . ':';
	}
	if (is_hierarchical_uri_scheme($scheme)) {
		$res .= '//';
	}
	if ($uri['user'] !== NULL) {
		$res .= $uri['user'];
		if ($uri['pass'] !== NULL) {
			$res .= ':' . $uri['pass'];
		}
		$res .= '@';
	}
	if ($uri['host'] !== NULL) {
		$res .= $uri['host'];
		if ($uri['port'] !== NULL) {
			$res .= ':' . $uri['port'];
		}
	}
	return $res;
}


function unparse_uri($uri) {
	$res = unparse_uri_host($uri);
	if ($uri['path'] !== NULL) {
		$res .= $uri['path'];
	}
	if ($uri['query'] !== NULL) {
		$res .= '?' . $uri['query'];
	}
	if ($uri['fragment'] !== NULL) {
		$res .= '#' . $uri['fragment'];
	}
	return $res;
}

?>