package com.walker.web.agent.impl;

import com.walker.web.agent.Capabilities;

public class Rule {

    // The properties of the matching pattern
    private final Literal myPrefix;
    private final Literal[] mySuffixes;
    private final Literal myPostfix;

    // The size of the pattern
    private final int mySize;

    // The browser properties
    private final Capabilities myCapabilities;

    /**
     * Creates a new rule.
     * @param prefix The prefix of the matching pattern, potentially <code>null</code>
     * @param suffixes The required substrings separated by wildcards, potentially <code>null</code> to indicate no
     *            wildcards
     * @param postfix The postfix of the matching pattern, potentially <code>null</code>
     * @param pattern The original string representation of the matching pattern
     * @param capabilities The browser properties for this rule
     */
    Rule(final Literal prefix, final Literal[] suffixes, final Literal postfix, final String pattern,
         final Capabilities capabilities) {
        myPrefix = prefix;
        mySuffixes = suffixes;
        myPostfix = postfix;
        myCapabilities = capabilities;
        mySize = pattern.length();
    }

    /**
     * Return the prefix.
     * @return the prefix, possibly <code>null</code>
     */
    Literal getPrefix() {
        return myPrefix;
    }

    /**
     * The required substrings separated by wildcards, potentially <code>null</code> to indicate no wildcards
     * @return The required substrings.
     */
    Literal[] getSuffixes() {
        return mySuffixes;
    }

    /**
     * Return the postfix.
     * @return the postfix, possibly <code>null</code>
     */
    Literal getPostfix() {
        return myPostfix;
    }

    /**
     * Tests whether this rule needs a specific string in the useragent to match.
     * @return <code>true</code> if this rule can't match without the specific substring, false otherwise.
     */
    boolean requires(final String value) {
        if (requires(myPrefix, value) || requires(myPostfix, value)) {
            return true;
        }

        if (mySuffixes == null) {
            return false;
        }
        for (final Literal suffix : mySuffixes) {
            if (requires(suffix, value)) {
                return true;
            }
        }
        return false;
    }

    private static boolean requires(final Literal literal, final String value) {
        return literal != null && literal.requires(value);
    }

    Capabilities getCapabilities() {
        return myCapabilities;
    }

    int getSize() {
        return mySize;
    }

    final boolean matches(final SearchableString value) {

        // Inclusive
        final int start;
        if (myPrefix == null) {
            start = 0;
        } else if (value.startsWith(myPrefix)) {
            start = myPrefix.getLength();
        } else {
            return false;
        }

        // Inclusive
        final int end;
        if (myPostfix == null) {
            end = value.getSize() - 1;
        } else if (value.endsWith(myPostfix)) {
            end = value.getSize() - 1 - myPostfix.getLength();
        } else {
            return false;
        }

        return checkWildCards(value, mySuffixes, start, end);
    }

    // Static for inline (2x)
    static boolean checkWildCards(final SearchableString value, final Literal[] suffixes, final int start,
                                  final int end) {

        if (suffixes == null) {
            // No wildcards
            return start == end + 1;
        }

        // One wildcard
        if (suffixes.length == 0) {
            return start <= end + 1;
        }

        int from = start;
        for (final Literal suffix : suffixes) {

            final int match = checkWildCard(value, suffix, from);
            if (match == -1) {
                return false;
            }

            from = suffix.getLength() + match;
            if (from > end + 1) {
                return false;
            }
        }

        return true;
    }

    // Return found index or -1
    private static int checkWildCard(final SearchableString value, final Literal suffix, final int start) {
        for (final int index : value.getIndices(suffix)) {
            if (index >= start) {
                return index;
            }
        }
        return -1;
    }

    /**
     * Returns the reconstructed original pattern.
     * @return the reconstructed original pattern
     */
    String getPattern() {
        final StringBuilder result = new StringBuilder();

        if (myPrefix != null) {
            result.append(myPrefix);
        }
        if (mySuffixes != null) {
            result.append("*");
            for (final Literal sub : mySuffixes) {
                result.append(sub);
                result.append("*");
            }
        }
        if (myPostfix != null) {
            result.append(myPostfix);
        }
        return result.toString();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String toString() {
        return getPattern() + " : " + myCapabilities;
    }
}