<?php

/**
 * Hoa
 *
 *
 * @license
 *
 * New BSD License
 *
 * Copyright © 2007-2017, Hoa community. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Hoa nor the names of its contributors may be
 *       used to endorse or promote products derived from this software without
 *       specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

namespace Psy\Readline\Hoa;

/**
 * Class \Hoa\File\Finder.
 *
 * This class allows to find files easily by using filters and flags.
 */
class FileFinder implements \IteratorAggregate
{
    /**
     * SplFileInfo classname.
     */
    protected $_splFileInfo = \SplFileInfo::class;

    /**
     * Paths where to look for.
     */
    protected $_paths = [];

    /**
     * Max depth in recursion.
     */
    protected $_maxDepth = -1;

    /**
     * Filters.
     */
    protected $_filters = [];

    /**
     * Flags.
     */
    protected $_flags = -1;

    /**
     * Types of files to handle.
     */
    protected $_types = [];

    /**
     * What comes first: parent or child?
     */
    protected $_first = -1;

    /**
     * Sorts.
     */
    protected $_sorts = [];

    /**
     * Initialize.
     */
    public function __construct()
    {
        $this->_flags = IteratorFileSystem::KEY_AS_PATHNAME
                        | IteratorFileSystem::CURRENT_AS_FILEINFO
                        | IteratorFileSystem::SKIP_DOTS;
        $this->_first = \RecursiveIteratorIterator::SELF_FIRST;

        return;
    }

    /**
     * Select a directory to scan.
     */
    public function in($paths): self
    {
        if (!\is_array($paths)) {
            $paths = [$paths];
        }

        foreach ($paths as $path) {
            if (1 === \preg_match('/[\*\?\[\]]/', $path)) {
                $iterator = new \CallbackFilterIterator(
                    new \GlobIterator(\rtrim($path, \DIRECTORY_SEPARATOR)),
                    function ($current) {
                        return $current->isDir();
                    }
                );

                foreach ($iterator as $fileInfo) {
                    $this->_paths[] = $fileInfo->getPathname();
                }
            } else {
                $this->_paths[] = $path;
            }
        }

        return $this;
    }

    /**
     * Set max depth for recursion.
     */
    public function maxDepth(int $depth): self
    {
        $this->_maxDepth = $depth;

        return $this;
    }

    /**
     * Include files in the result.
     */
    public function files(): self
    {
        $this->_types[] = 'file';

        return $this;
    }

    /**
     * Include directories in the result.
     */
    public function directories(): self
    {
        $this->_types[] = 'dir';

        return $this;
    }

    /**
     * Include links in the result.
     */
    public function links(): self
    {
        $this->_types[] = 'link';

        return $this;
    }

    /**
     * Follow symbolink links.
     */
    public function followSymlinks(bool $flag = true): self
    {
        if (true === $flag) {
            $this->_flags ^= IteratorFileSystem::FOLLOW_SYMLINKS;
        } else {
            $this->_flags |= IteratorFileSystem::FOLLOW_SYMLINKS;
        }

        return $this;
    }

    /**
     * Include files that match a regex.
     * Example:
     *     $this->name('#\.php$#');.
     */
    public function name(string $regex): self
    {
        $this->_filters[] = function (\SplFileInfo $current) use ($regex) {
            return 0 !== \preg_match($regex, $current->getBasename());
        };

        return $this;
    }

    /**
     * Exclude directories that match a regex.
     * Example:
     *      $this->notIn('#^\.(git|hg)$#');.
     */
    public function notIn(string $regex): self
    {
        $this->_filters[] = function (\SplFileInfo $current) use ($regex) {
            foreach (\explode(\DIRECTORY_SEPARATOR, $current->getPathname()) as $part) {
                if (0 !== \preg_match($regex, $part)) {
                    return false;
                }
            }

            return true;
        };

        return $this;
    }

    /**
     * Include files that respect a certain size.
     * The size is a string of the form:
     *     operator number unit
     * where
     *     • operator could be: <, <=, >, >= or =;
     *     • number is a positive integer;
     *     • unit could be: b (default), Kb, Mb, Gb, Tb, Pb, Eb, Zb, Yb.
     * Example:
     *     $this->size('>= 12Kb');.
     */
    public function size(string $size): self
    {
        if (0 === \preg_match('#^(<|<=|>|>=|=)\s*(\d+)\s*((?:[KMGTPEZY])b)?$#', $size, $matches)) {
            return $this;
        }

        $number = (float) ($matches[2]);
        $unit = $matches[3] ?? 'b';
        $operator = $matches[1];

        switch ($unit) {
            case 'b':
                break;

            // kilo
            case 'Kb':
                $number <<= 10;

                break;

            // mega.
            case 'Mb':
                $number <<= 20;

                break;

            // giga.
            case 'Gb':
                $number <<= 30;

                break;

            // tera.
            case 'Tb':
                $number *= 1099511627776;

                break;

            // peta.
            case 'Pb':
                $number *= 1024 ** 5;

                break;

            // exa.
            case 'Eb':
                $number *= 1024 ** 6;

                break;

            // zetta.
            case 'Zb':
                $number *= 1024 ** 7;

                break;

            // yota.
            case 'Yb':
                $number *= 1024 ** 8;

                break;
        }

        $filter = null;

        switch ($operator) {
            case '<':
                $filter = function (\SplFileInfo $current) use ($number) {
                    return $current->getSize() < $number;
                };

                break;

            case '<=':
                $filter = function (\SplFileInfo $current) use ($number) {
                    return $current->getSize() <= $number;
                };

                break;

            case '>':
                $filter = function (\SplFileInfo $current) use ($number) {
                    return $current->getSize() > $number;
                };

                break;

            case '>=':
                $filter = function (\SplFileInfo $current) use ($number) {
                    return $current->getSize() >= $number;
                };

                break;

            case '=':
                $filter = function (\SplFileInfo $current) use ($number) {
                    return $current->getSize() === $number;
                };

                break;
        }

        $this->_filters[] = $filter;

        return $this;
    }

    /**
     * Whether we should include dots or not (respectively . and ..).
     */
    public function dots(bool $flag = true): self
    {
        if (true === $flag) {
            $this->_flags ^= IteratorFileSystem::SKIP_DOTS;
        } else {
            $this->_flags |= IteratorFileSystem::SKIP_DOTS;
        }

        return $this;
    }

    /**
     * Include files that are owned by a certain owner.
     */
    public function owner(int $owner): self
    {
        $this->_filters[] = function (\SplFileInfo $current) use ($owner) {
            return $current->getOwner() === $owner;
        };

        return $this;
    }

    /**
     * Format date.
     * Date can have the following syntax:
     *     date
     *     since date
     *     until date
     * If the date does not have the “ago” keyword, it will be added.
     * Example: “42 hours” is equivalent to “since 42 hours” which is equivalent
     * to “since 42 hours ago”.
     */
    protected function formatDate(string $date, &$operator): int
    {
        $operator = -1;

        if (0 === \preg_match('#\bago\b#', $date)) {
            $date .= ' ago';
        }

        if (0 !== \preg_match('#^(since|until)\b(.+)$#', $date, $matches)) {
            $time = \strtotime($matches[2]);

            if ('until' === $matches[1]) {
                $operator = 1;
            }
        } else {
            $time = \strtotime($date);
        }

        return $time;
    }

    /**
     * Include files that have been changed from a certain date.
     * Example:
     *     $this->changed('since 13 days');.
     */
    public function changed(string $date): self
    {
        $time = $this->formatDate($date, $operator);

        if (-1 === $operator) {
            $this->_filters[] = function (\SplFileInfo $current) use ($time) {
                return $current->getCTime() >= $time;
            };
        } else {
            $this->_filters[] = function (\SplFileInfo $current) use ($time) {
                return $current->getCTime() < $time;
            };
        }

        return $this;
    }

    /**
     * Include files that have been modified from a certain date.
     * Example:
     *     $this->modified('since 13 days');.
     */
    public function modified(string $date): self
    {
        $time = $this->formatDate($date, $operator);

        if (-1 === $operator) {
            $this->_filters[] = function (\SplFileInfo $current) use ($time) {
                return $current->getMTime() >= $time;
            };
        } else {
            $this->_filters[] = function (\SplFileInfo $current) use ($time) {
                return $current->getMTime() < $time;
            };
        }

        return $this;
    }

    /**
     * Add your own filter.
     * The callback will receive 3 arguments: $current, $key and $iterator. It
     * must return a boolean: true to include the file, false to exclude it.
     * Example:
     *     // Include files that are readable
     *     $this->filter(function ($current) {
     *         return $current->isReadable();
     *     });.
     */
    public function filter($callback): self
    {
        $this->_filters[] = $callback;

        return $this;
    }

    /**
     * Sort result by name.
     * If \Collator exists (from ext/intl), the $locale argument will be used
     * for its constructor. Else, strcmp() will be used.
     * Example:
     *     $this->sortByName('fr_FR');.
     */
    public function sortByName(string $locale = 'root'): self
    {
        if (true === \class_exists('Collator', false)) {
            $collator = new \Collator($locale);

            $this->_sorts[] = function (\SplFileInfo $a, \SplFileInfo $b) use ($collator) {
                return $collator->compare($a->getPathname(), $b->getPathname());
            };
        } else {
            $this->_sorts[] = function (\SplFileInfo $a, \SplFileInfo $b) {
                return \strcmp($a->getPathname(), $b->getPathname());
            };
        }

        return $this;
    }

    /**
     * Sort result by size.
     * Example:
     *     $this->sortBySize();.
     */
    public function sortBySize(): self
    {
        $this->_sorts[] = function (\SplFileInfo $a, \SplFileInfo $b) {
            return $a->getSize() < $b->getSize();
        };

        return $this;
    }

    /**
     * Add your own sort.
     * The callback will receive 2 arguments: $a and $b. Please see the uasort()
     * function.
     * Example:
     *     // Sort files by their modified time.
     *     $this->sort(function ($a, $b) {
     *         return $a->getMTime() < $b->getMTime();
     *     });.
     */
    public function sort($callable): self
    {
        $this->_sorts[] = $callable;

        return $this;
    }

    /**
     * Child comes first when iterating.
     */
    public function childFirst(): self
    {
        $this->_first = \RecursiveIteratorIterator::CHILD_FIRST;

        return $this;
    }

    /**
     * Get the iterator.
     */
    public function getIterator()
    {
        $_iterator = new \AppendIterator();
        $types = $this->getTypes();

        if (!empty($types)) {
            $this->_filters[] = function (\SplFileInfo $current) use ($types) {
                return \in_array($current->getType(), $types);
            };
        }

        $maxDepth = $this->getMaxDepth();
        $splFileInfo = $this->getSplFileInfo();

        foreach ($this->getPaths() as $path) {
            if (1 === $maxDepth) {
                $iterator = new \IteratorIterator(
                    new IteratorRecursiveDirectory(
                        $path,
                        $this->getFlags(),
                        $splFileInfo
                    ),
                    $this->getFirst()
                );
            } else {
                $iterator = new \RecursiveIteratorIterator(
                    new IteratorRecursiveDirectory(
                        $path,
                        $this->getFlags(),
                        $splFileInfo
                    ),
                    $this->getFirst()
                );

                if (1 < $maxDepth) {
                    $iterator->setMaxDepth($maxDepth - 1);
                }
            }

            $_iterator->append($iterator);
        }

        foreach ($this->getFilters() as $filter) {
            $_iterator = new \CallbackFilterIterator(
                $_iterator,
                $filter
            );
        }

        $sorts = $this->getSorts();

        if (empty($sorts)) {
            return $_iterator;
        }

        $array = \iterator_to_array($_iterator);

        foreach ($sorts as $sort) {
            \uasort($array, $sort);
        }

        return new \ArrayIterator($array);
    }

    /**
     * Set SplFileInfo classname.
     */
    public function setSplFileInfo(string $splFileInfo): string
    {
        $old = $this->_splFileInfo;
        $this->_splFileInfo = $splFileInfo;

        return $old;
    }

    /**
     * Get SplFileInfo classname.
     */
    public function getSplFileInfo(): string
    {
        return $this->_splFileInfo;
    }

    /**
     * Get all paths.
     */
    protected function getPaths(): array
    {
        return $this->_paths;
    }

    /**
     * Get max depth.
     */
    public function getMaxDepth(): int
    {
        return $this->_maxDepth;
    }

    /**
     * Get types.
     */
    public function getTypes(): array
    {
        return $this->_types;
    }

    /**
     * Get filters.
     */
    protected function getFilters(): array
    {
        return $this->_filters;
    }

    /**
     * Get sorts.
     */
    protected function getSorts(): array
    {
        return $this->_sorts;
    }

    /**
     * Get flags.
     */
    public function getFlags(): int
    {
        return $this->_flags;
    }

    /**
     * Get first.
     */
    public function getFirst(): int
    {
        return $this->_first;
    }
}