<?php
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

/**
 * File::Util
 *
 * PHP versions 4 and 5
 *
 * LICENSE: This source file is subject to version 3.0 of the PHP license
 * that is available through the world-wide-web at the following URI:
 * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
 * the PHP License and are unable to obtain it through the web, please
 * send a note to license@php.net so we can mail you a copy immediately.
 *
 * @category    File
 * @package     File
 * @author      Michael Wallner <mike@php.net>
 * @copyright   2004-2005 Michael Wallner
 * @license     http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version     CVS: $Id: Util.php 309134 2011-03-12 16:45:50Z dufuz $
 * @link        http://pear.php.net/package/File
 */

/**#@+
 * Sorting Constants
 */
define('FILE_SORT_NONE',    0);
define('FILE_SORT_REVERSE', 1);
define('FILE_SORT_NAME',    2);
define('FILE_SORT_SIZE',    4);
define('FILE_SORT_DATE',    8);
define('FILE_SORT_RANDOM',  16);
/**#@-*/

/**#@+
 * Listing Constants
 */
define('FILE_LIST_FILES',   1);
define('FILE_LIST_DIRS',    2);
define('FILE_LIST_DOTS',    4);
define('FILE_LIST_ALL',     FILE_LIST_FILES | FILE_LIST_DIRS | FILE_LIST_DOTS);
/**#@-*/

/**
 * @ignore
 */
define('FILE_WIN32', defined('OS_WINDOWS') ? OS_WINDOWS : !strncasecmp(PHP_OS, 'win', 3));

/**
 * File_Util
 *
 * File and directory utility functions.
 *
 * @access  public
 * @static
 */
class File_Util
{
    /**
     * Returns a string path built from the array $pathParts. Where a join
     * occurs multiple separators are removed. Joins using the optional
     * separator, defaulting to the PHP DIRECTORY_SEPARATOR constant.
     *
     * @static
     * @access  public
     * @param   array   $parts Array containing the parts to be joined
     * @param   string  $separator The directory seperator
     */
    static function buildPath($parts, $separator = DIRECTORY_SEPARATOR)
    {
        $qs = '/^'. preg_quote($separator, '/') .'+$/';
        for ($i = 0, $c = count($parts); $i < $c; $i++) {
            if (!strlen($parts[$i]) || preg_match($qs, $parts[$i])) {
                unset($parts[$i]);
            } elseif (0 == $i) {
                $parts[$i] = rtrim($parts[$i], $separator);
            } elseif ($c - 1 == $i) {
                $parts[$i] = ltrim($parts[$i], $separator);
            } else {
                $parts[$i] = trim($parts[$i], $separator);
            }
        }
        return implode($separator, $parts);
    }

    /**
     * Returns a path without leading / or C:\. If this is not
     * present the path is returned as is.
     *
     * @static
     * @access  public
     * @param   string  $path The path to be processed
     * @return  string  The processed path or the path as is
     */
    static function skipRoot($path)
    {
        if (File_Util::isAbsolute($path)) {
            if (FILE_WIN32) {
                return substr($path, $path{3} == '\\' ? 4 : 3);
            }
            return ltrim($path, '/');
        }
        return $path;
    }

    /**
     * Returns the temp directory according to either the TMP, TMPDIR, or
     * TEMP env variables. If these are not set it will also check for the
     * existence of /tmp, %WINDIR%\temp
     *
     * @static
     * @access  public
     * @return  string  The system tmp directory
     */
    static function tmpDir()
    {
        if (FILE_WIN32) {
            if (isset($_ENV['TEMP'])) {
                return $_ENV['TEMP'];
            }
            if (isset($_ENV['TMP'])) {
                return $_ENV['TMP'];
            }
            if (isset($_ENV['windir'])) {
                return $_ENV['windir'] . '\\temp';
            }
            if (isset($_ENV['SystemRoot'])) {
                return $_ENV['SystemRoot'] . '\\temp';
            }
            if (isset($_SERVER['TEMP'])) {
                return $_SERVER['TEMP'];
            }
            if (isset($_SERVER['TMP'])) {
                return $_SERVER['TMP'];
            }
            if (isset($_SERVER['windir'])) {
                return $_SERVER['windir'] . '\\temp';
            }
            if (isset($_SERVER['SystemRoot'])) {
                return $_SERVER['SystemRoot'] . '\\temp';
            }
            return '\temp';
        }
        if (isset($_ENV['TMPDIR'])) {
            return $_ENV['TMPDIR'];
        }
        if (isset($_SERVER['TMPDIR'])) {
            return $_SERVER['TMPDIR'];
        }
        return '/tmp';
    }

    /**
     * Returns a temporary filename using tempnam() and File::tmpDir().
     *
     * @static
     * @access  public
     * @param   string  $dirname Optional directory name for the tmp file
     * @return  string  Filename and path of the tmp file
     */
    static function tmpFile($dirname = null)
    {
        if (!isset($dirname)) {
            $dirname = File_Util::tmpDir();
        }
        return tempnam($dirname, 'temp.');
    }

    /**
     * Returns boolean based on whether given path is absolute or not.
     *
     * @static
     * @access  public
     * @param   string  $path Given path
     * @return  boolean True if the path is absolute, false if it is not
     */
    static function isAbsolute($path)
    {
        if (preg_match('/(?:\/|\\\)\.\.(?=\/|$)/', $path)) {
            return false;
        }
        if (FILE_WIN32) {
            return (($path{0} == '/') ||  preg_match('/^[a-zA-Z]:(\\\|\/)/', $path));
        }
        return ($path{0} == '/') || ($path{0} == '~');
    }

    /**
     * Checks for a file's existence, taking the current include path
     * into consideration
     *
     * This method can be called statically
     * (e.g., File_Util::isIncludable('config.php'))
     *
     * @param string $file
     * @param string $sep the directory separator (optional)
     * @return string the includable path
     * @access public
     * @static
     */
    static function isIncludable($file, $sep = DIRECTORY_SEPARATOR)
    {
        foreach ((array) explode(PATH_SEPARATOR, ini_get('include_path')) as $path) {
            if (file_exists($path .= $sep . $file)) {
                return $path;
            }
        }
        if (file_exists($file)) {
            return $file;
        }
        return null;
    }

    /**
     * Get path relative to another path
     *
     * @static
     * @access  public
     * @return  string
     * @param   string  $path
     * @param   string  $root
     * @param   string  $separator
     */
    static function relativePath($path, $root, $separator = DIRECTORY_SEPARATOR)
    {
        $path = File_Util::realpath($path, $separator);
        $root = File_Util::realpath($root, $separator);
        $dirs = explode($separator, $path);
        $comp = explode($separator, $root);

        if (FILE_WIN32) {
            if (strcasecmp($dirs[0], $comp[0])) {
                return $path;
            }
            unset($dirs[0], $comp[0]);
        }

        foreach ($comp as $i => $part) {
            if (isset($dirs[$i]) && $part == $dirs[$i]) {
                unset($dirs[$i], $comp[$i]);
            } else {
                break;
            }
        }

        return str_repeat('..' . $separator, count($comp)) . implode($separator, $dirs);
    }

    /**
     * Get real path (works with non-existant paths)
     *
     * @static
     * @access  public
     * @return  string
     * @param   string  $path
     * @param   string  $separator
     */
    static function realPath($path, $separator = DIRECTORY_SEPARATOR)
    {
        if (!strlen($path)) {
            return $separator;
        }

        $drive = '';
        $path = preg_replace('/[\\\\\/]/', $separator, $path);
        if (FILE_WIN32) {
            if (preg_match('/([a-zA-Z]\:)(.*)/', $path, $matches)) {
                $drive = $matches[1];
                $path  = $matches[2];
            } else {
                $cwd   = getcwd();
                $drive = substr($cwd, 0, 2);
                if ($path{0} !== $separator{0}) {
                    $path  = substr($cwd, 3) . $separator . $path;
                }
            }
        } elseif ($path{0} !== $separator) {
            $path = getcwd() . $separator . $path;
        }

        $dirStack = array();
        foreach (explode($separator, $path) as $dir) {
            if (strlen($dir) && $dir !== '.') {
                if ($dir == '..') {
                    array_pop($dirStack);
                } else {
                    $dirStack[] = $dir;
                }
            }
        }

        return $drive . $separator . implode($separator, $dirStack);
    }

    /**
     * Check whether path is in root path
     *
     * @static
     * @access  public
     * @return  bool
     * @param   string  $path
     * @param   string  $root
     */
    static function pathInRoot($path, $root)
    {
        static $realPaths = array();

        if (!isset($realPaths[$root])) {
            $realPaths[$root] = File_Util::realPath($root);
        }

        return false !== strstr(File_Util::realPath($path), $realPaths[$root]);
    }

    /**
     * List Directory
     *
     * The final argument, $cb, is a callback that either evaluates to true or
     * false and performs a filter operation, or it can also modify the
     * directory/file names returned.  To achieve the latter effect use as
     * follows:
     *
     * <code>
     * <?php
     * function uc(&$filename) {
     *     $filename = strtoupper($filename);
     *     return true;
     * }
     * $entries = File_Util::listDir('.', FILE_LIST_ALL, FILE_SORT_NONE, 'uc');
     * foreach ($entries as $e) {
     *     echo $e->name, "\n";
     * }
     * ?>
     * </code>
     *
     * @static
     * @access  public
     * @return  array
     * @param   string  $path
     * @param   int     $list
     * @param   int     $sort
     * @param   mixed   $cb
     */
    static function listDir($path, $list = FILE_LIST_ALL, $sort = FILE_SORT_NONE, $cb = null)
    {
        if (!strlen($path) || !is_dir($path)) {
            return null;
        }

        $entries = array();
        for ($dir = dir($path); false !== $entry = $dir->read(); ) {
            if ($list & FILE_LIST_DOTS || $entry{0} !== '.') {
                $isRef = ($entry === '.' || $entry === '..');
                $isDir = $isRef || is_dir($path .'/'. $entry);
                if (    ((!$isDir && $list & FILE_LIST_FILES)   ||
                         ($isDir  && $list & FILE_LIST_DIRS))   &&
                        (!is_callable($cb) ||
                            call_user_func_array($cb, array(&$entry)))) {
                    $entries[] = (object) array(
                        'name'  => $entry,
                        'size'  => $isDir ? null : filesize($path .'/'. $entry),
                        'date'  => filemtime($path .'/'. $entry),
                    );
                }
            }
        }
        $dir->close();

        if ($sort) {
            $entries = File_Util::sortFiles($entries, $sort);
        }

        return $entries;
    }

    /**
     * Sort Files
     *
     * @static
     * @access  public
     * @return  array
     * @param   array   $files
     * @param   int     $sort
     */
    static function sortFiles($files, $sort)
    {
        if (!$files) {
            return array();
        }

        if (!$sort) {
            return $files;
        }

        if ($sort === 1) {
            return array_reverse($files);
        }

        if ($sort & FILE_SORT_RANDOM) {
            shuffle($files);
            return $files;
        }

        $names = array();
        $sizes = array();
        $dates = array();

        if ($sort & FILE_SORT_NAME) {
            $r = &$names;
        } elseif ($sort & FILE_SORT_DATE) {
            $r = &$dates;
        } elseif ($sort & FILE_SORT_SIZE) {
            $r = &$sizes;
        } else {
            asort($files, SORT_REGULAR);
            return $files;
        }

        $sortFlags = array(
            FILE_SORT_NAME => SORT_STRING,
            FILE_SORT_DATE => SORT_NUMERIC,
            FILE_SORT_SIZE => SORT_NUMERIC,
        );

        foreach ($files as $file) {
            $names[] = $file->name;
            $sizes[] = $file->size;
            $dates[] = $file->date;
        }

        if ($sort & FILE_SORT_REVERSE) {
            arsort($r, $sortFlags[$sort & ~1]);
        } else {
            asort($r, $sortFlags[$sort]);
        }

        $result = array();
        foreach ($r as $i => $f) {
            $result[] = $files[$i];
        }

        return $result;
    }

    /**
     * Switch File Extension
     *
     * @static
     * @access  public
     * @return  string|array
     * @param   string|array    $filename
     * @param   string          $to new file extension
     * @param   string          $from change only files with this extension
     * @param   bool            $reverse change only files not having $from extension
     */
    static function switchExt($filename, $to, $from = null, $reverse = false)
    {
        if (is_array($filename)) {
            foreach ($filename as $key => $file) {
                $filename[$key] = File_Util::switchExt($file, $to, $from);
            }
            return $filename;
        }

        if ($len = strlen($from)) {
            $ext = substr($filename, -$len - 1);
            $cfn = FILE_WIN32 ? 'strcasecmp' : 'strcmp';
            if (!$reverse == $cfn($ext, '.'. $from)) {
                return $filename;
            }
            return substr($filename, 0, -$len - 1) .'.'. $to;
        }

        if ($pos = strpos($filename, '.')) {
            return substr($filename, 0, $pos) .'.'. $to;
        }

        return $filename .'.'. $to;
    }

    /**
     * Returns the filesize using a prefix like "kilo", "mebi" or "giga"
     *
     * @author Christian Weiske <cweiske@cweiske.de>
     *
     * @param integer $size       The size to convert
     * @param integer $decimals   The number of decimals to use
     * @param boolean $long       Use long names (kilobyte) instead of
     *                            short ones (kB)
     * @param boolean $oldStyle   If the old style should be used
     * @param boolean $useBiBytes If the "BiBytes" names should be
     *                            used [applies only to !$bOldStyle]
     *
     * @return string The filesize in human readable format
     *
     * @static
     */
    static function prefixed(
        $size, $decimals = 1, $long = false, $oldStyle = true,
        $useBiBytes = true
    ) {
        $base  = ($oldStyle || $useBiBytes) ? 1024 : 1000;
        $names = array(
            '', 'kilo', 'mega', 'giga', 'tera',
             'peta', 'exa', 'zetta', 'yotta'
        );
        $max   = count($names) - 1;

        for ($a = 0; $size >= $base && $a < $max; $a++) {
            $size /= $base;
        }

        $name = ($oldStyle || !$useBiBytes)
            ? $names[$a]
            : $names[$a] . 'bi';
        if (!$long) {
            $name = $oldStyle || !$useBiBytes
                ? strtoupper(substr($name, 0, 1))
                : strtoupper(substr($name, 0, 1)) . 'i';
            $name .= 'B';
        } else {
            $name .= $size == 1 ? 'byte' : 'bytes';
        }

        return round($size, $decimals) . ' ' . $name;
    }

}
