# Copyright (C) 2015-2018 Regents of the University of California
#
# 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.

# 5.14.2018: copied into Toil from https://github.com/BD2KGenomics/bd2k-python-lib

from __future__ import absolute_import
import re

# Same as Python's fnmatch with the following differences:
# - '/' doesn't match '*'
# - added '**' to match anything
# - added some unit tests

"""Filename matching with shell patterns.

fnmatch(FILENAME, PATTERN) matches according to the local convention.
fnmatchcase(FILENAME, PATTERN) always takes case in account.

The functions operate by translating the pattern into a regular
expression.  They cache the compiled regular expressions for speed.

The function translate(PATTERN) returns a regular expression
corresponding to PATTERN.  (It does not compile it.)
"""

__all__ = ["filter", "fnmatch", "fnmatchcase", "translate"]
_cache = {}
_MAXCACHE = 100

def _purge( ):
    """Clear the pattern cache"""
    _cache.clear( )


def fnmatch( name, pat ):
    """Test whether FILENAME matches PATTERN.

    Patterns are Unix shell style:

    *       matches everything
    ?       matches any single character
    [seq]   matches any character in seq
    [!seq]  matches any char not in seq

    An initial period in FILENAME is not special.
    Both FILENAME and PATTERN are first case-normalized
    if the operating system requires it.
    If you don't want this, use fnmatchcase(FILENAME, PATTERN).

    >>> fnmatch('bar', '*' )
    True
    >>> fnmatch('foo/bar', '*' )
    False
    >>> fnmatch('foo/bar', '**' )
    True
    >>> fnmatch('foo/bar', '*/*' )
    True
    >>> fnmatch('foo/bar', '**/*' )
    True
    >>> fnmatch('/bar', '**/*' )
    True
    >>> fnmatch('/', '**' )
    True
    >>> fnmatch('/', '*' )
    False
    """

    import os

    name = os.path.normcase( name )
    pat = os.path.normcase( pat )
    return fnmatchcase( name, pat )


def filter( names, pat ):
    """Return the subset of the list NAMES that match PAT"""
    import os, posixpath

    result = [ ]
    pat = os.path.normcase( pat )
    if not pat in _cache:
        res = translate( pat )
        if len( _cache ) >= _MAXCACHE:
            _cache.clear( )
        _cache[ pat ] = re.compile( res )
    match = _cache[ pat ].match
    if os.path is posixpath:
        # normcase on posix is NOP. Optimize it away from the loop.
        for name in names:
            if match( name ):
                result.append( name )
    else:
        for name in names:
            if match( os.path.normcase( name ) ):
                result.append( name )
    return result


def fnmatchcase( name, pat ):
    """Test whether FILENAME matches PATTERN, including case.

    This is a version of fnmatch() which doesn't case-normalize
    its arguments.
    """

    if not pat in _cache:
        res = translate( pat )
        if len( _cache ) >= _MAXCACHE:
            _cache.clear( )
        _cache[ pat ] = re.compile( res )
    return _cache[ pat ].match( name ) is not None


def translate( pat ):
    """Translate a shell PATTERN to a regular expression.

    There is no way to quote meta-characters.
    """

    i, n = 0, len( pat )
    res = ''
    while i < n:
        c = pat[ i ]
        i += 1
        if c == '*':
            if i < len(pat) and pat[i] == '*':
                i += 1
                res += '.*'
            else:
                res += '[^/]*'
        elif c == '?':
            res += '.'
        elif c == '[':
            j = i
            if j < n and pat[ j ] == '!':
                j += 1
            if j < n and pat[ j ] == ']':
                j += 1
            while j < n and pat[ j ] != ']':
                j += 1
            if j >= n:
                res += '\\['
            else:
                stuff = pat[ i:j ].replace( '\\', '\\\\' )
                i = j + 1
                if stuff[ 0 ] == '!':
                    stuff = '^' + stuff[ 1: ]
                elif stuff[ 0 ] == '^':
                    stuff = '\\' + stuff
                res = '%s[%s]' % (res, stuff)
        else:
            res = res + re.escape( c )
    return res + '\Z(?ms)'
