//------------------------------------------------------------------------------
// <copyright file="Wildcard.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>                                                                
//------------------------------------------------------------------------------

/*
 * Wildcard
 * 
 * wildcard wrappers for Regex
 *
 * (1) Wildcard does straight string wildcarding with no path separator awareness
 * (2) WildcardUrl recognizes that forward / slashes are special and can't match * or ?
 * (3) WildcardDos recognizes that backward \ and : are special and can't match * or ?
 * 
 * Copyright (c) 1999, Microsoft Corporation
 */
namespace System.Web.Util {
    using System.Runtime.Serialization.Formatters;
    using System.Text.RegularExpressions;

    /*
     * Wildcard
     *
     * Wildcard patterns have three metacharacters:
     *
     * A ? is equivalent to .
     * A * is equivalent to .*
     * A , is equivalent to |
     *
     * Note that by each alternative is surrounded by \A...\z to anchor
     * at the edges of the string.
     */
    internal class Wildcard {
#if NOT_USED
        internal /*public*/ Wildcard(String pattern) : this (pattern, false) {
        }
#endif

        internal /*public*/ Wildcard(String pattern, bool caseInsensitive) {
            _pattern = pattern;
            _caseInsensitive = caseInsensitive;
        }

        internal String _pattern;
        internal bool _caseInsensitive;
        internal Regex _regex;

        protected static Regex metaRegex = new Regex("[\\+\\{\\\\\\[\\|\\(\\)\\.\\^\\$]");
        protected static Regex questRegex = new Regex("\\?");
        protected static Regex starRegex = new Regex("\\*");
        protected static Regex commaRegex = new Regex(",");
        protected static Regex slashRegex = new Regex("(?=/)");
        protected static Regex backslashRegex = new Regex("(?=[\\\\:])");

        /*
         * IsMatch returns true if the input is an exact match for the
         * wildcard pattern.
         */
        internal /*public*/ bool IsMatch(String input) {
            EnsureRegex();

            bool result =  _regex.IsMatch(input);

            return result;
        }
#if DONT_COMPILE
        internal /*public*/ String Pattern {
            get {
                return _pattern;
            }
        }
#endif
        /*
         * Builds the matching regex when needed
         */
        protected void EnsureRegex() {
            // threadsafe without protection because of gc

            if (_regex != null)
                return;

            _regex = RegexFromWildcard(_pattern, _caseInsensitive);
        }

        /*
         * Basic wildcard -> Regex conversion, no slashes
         */
        protected virtual Regex RegexFromWildcard(String pattern, bool caseInsensitive) {
            RegexOptions options = RegexOptions.None;

            // match right-to-left (for speed) if the pattern starts with a *

            if (pattern.Length > 0 && pattern[0] == '*')
                options = RegexOptions.RightToLeft | RegexOptions.Singleline;
            else
                options = RegexOptions.Singleline;

            // case insensitivity

            if (caseInsensitive)
                options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;

            // Remove regex metacharacters

            pattern = metaRegex.Replace(pattern, "\\$0");

            // Replace wildcard metacharacters with regex codes

            pattern = questRegex.Replace(pattern, ".");
            pattern = starRegex.Replace(pattern, ".*");
            pattern = commaRegex.Replace(pattern, "\\z|\\A");

            // anchor the pattern at beginning and end, and return the regex

            return new Regex("\\A" + pattern + "\\z", options);
        }
    }

    abstract internal class WildcardPath : Wildcard {
#if NOT_USED        
        internal /*public*/ WildcardPath(String pattern) : base(pattern) {
        }

        private Regex[][] _dirs;
#endif

        internal /*public*/ WildcardPath(String pattern, bool caseInsensitive) : base(pattern, caseInsensitive) {
        }

        private Regex _suffix;

        /*
         * IsSuffix returns true if a suffix of the input is an exact
         * match for the wildcard pattern.
         */
        internal /*public*/ bool IsSuffix(String input) {
            EnsureSuffix();
            return _suffix.IsMatch(input);
        }

#if NOT_USED        
        /*
         * AllowPrefix returns true if the input is an exact match for
         * a prefix-directory of the wildcard pattern (i.e., if it
         * is possible to match the wildcard pattern by adding
         * more subdirectories or a filename at the end of the path).
         */
        internal /*public*/ bool AllowPrefix(String prefix) {
            String[] dirs = SplitDirs(prefix);

            EnsureDirs();

            for (int i = 0; i < _dirs.Length; i++) {
                // pattern is shorter than prefix: reject
                if (_dirs[i].Length < dirs.Length)
                    goto NextAlt;

                for (int j = 0; j < dirs.Length; j++) {
                    // the jth directory doesn't match; path is not a prefix
                    if (!_dirs[i][j].IsMatch(dirs[j]))
                        goto NextAlt;
                }

                // one alternative passed: we pass.

                return true;

                NextAlt: 
                ;
            }

            return false;
        }

        /*
         * Builds the matching regex array when needed
         */
        protected void EnsureDirs() {
            // threadsafe without protection because of gc

            if (_dirs != null)
                return;

            _dirs = DirsFromWildcard(_pattern);
        }
#endif

        /*
         * Builds the matching regex when needed
         */
        protected void EnsureSuffix() {
            // threadsafe without protection because of gc

            if (_suffix != null)
                return;

            _suffix = SuffixFromWildcard(_pattern, _caseInsensitive);
        }


        /*
         * Specialize for forward-slash and backward-slash cases
         */
        protected abstract Regex SuffixFromWildcard(String pattern, bool caseInsensitive);
        protected abstract Regex[][] DirsFromWildcard(String pattern);
        protected abstract String[] SplitDirs(String input);
    }

    /*
     * WildcardUrl
     *
     * The twist is that * and ? cannot match forward slashes,
     * and we can do an exact suffix match that starts after
     * any /, and we can also do a prefix prune.
     */
    internal class WildcardUrl : WildcardPath {
#if NOT_USED
        internal /*public*/ WildcardUrl(String pattern) : base(pattern) {
        }
#endif
        internal /*public*/ WildcardUrl(String pattern, bool caseInsensitive) : base(pattern, caseInsensitive) {
        }

        protected override String[] SplitDirs(String input) {
            return slashRegex.Split(input);
        }

        protected override Regex RegexFromWildcard(String pattern, bool caseInsensitive) {
            RegexOptions options;

            // match right-to-left (for speed) if the pattern starts with a *

            if (pattern.Length > 0 && pattern[0] == '*')
                options = RegexOptions.RightToLeft;
            else
                options = RegexOptions.None;

            // case insensitivity

            if (caseInsensitive)
                options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;

            // Remove regex metacharacters

            pattern = metaRegex.Replace(pattern, "\\$0");

            // Replace wildcard metacharacters with regex codes

            pattern = questRegex.Replace(pattern, "[^/]");
            pattern = starRegex.Replace(pattern, "[^/]*");
            pattern = commaRegex.Replace(pattern, "\\z|\\A");

            // anchor the pattern at beginning and end, and return the regex

            return new Regex("\\A" + pattern + "\\z", options);
        }

        protected override Regex SuffixFromWildcard(String pattern, bool caseInsensitive) {
            RegexOptions options;

            // match right-to-left (for speed)

            options = RegexOptions.RightToLeft;

            // case insensitivity

            if (caseInsensitive)
                options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;

            // Remove regex metacharacters

            pattern = metaRegex.Replace(pattern, "\\$0");

            // Replace wildcard metacharacters with regex codes

            pattern = questRegex.Replace(pattern, "[^/]");
            pattern = starRegex.Replace(pattern, "[^/]*");
            pattern = commaRegex.Replace(pattern, "\\z|(?:\\A|(?<=/))");

            // anchor the pattern at beginning and end, and return the regex

            return new Regex("(?:\\A|(?<=/))" + pattern + "\\z", options);
        }

        protected override Regex[][] DirsFromWildcard(String pattern) {
            String[] alts = commaRegex.Split(pattern);
            Regex[][] dirs = new Regex[alts.Length][];

            for (int i = 0; i < alts.Length; i++) {
                String[] dirpats = slashRegex.Split(alts[i]);

                Regex[] dirregex = new Regex[dirpats.Length];

                if (alts.Length == 1 && dirpats.Length == 1) {
                    // common case: no commas, no slashes: dir regex is same as top regex.

                    EnsureRegex();
                    dirregex[0] = _regex;
                }
                else {
                    for (int j = 0; j < dirpats.Length; j++) {
                        dirregex[j] = RegexFromWildcard(dirpats[j], _caseInsensitive);
                    }
                }

                dirs[i] = dirregex;
            }

            return dirs;
        }
    }
}