package com.walker.web.agent.impl;

import com.walker.web.agent.Capabilities;
import com.walker.web.agent.UserAgentParser;

import static java.util.Arrays.parallelSort;
import static java.util.stream.Collectors.toList;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Comparator;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class UserAgentParserImpl implements UserAgentParser {

    // Common substrings to filter irrelevant rules and speed up processing
    static final String[] COMMON = {"-", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "profile", "player",
            "compatible", "android", "google", "tab", "transformer", "lenovo", "micro", "edge", "safari", "opera",
            "chrome", "firefox", "msie", "chromium", "cpu os ", "cpu iphone os ", "windows nt ", "mac os x ", "linux",
            "bsd", "windows phone", "iphone", "pad", "blackberry", "nokia", "alcatel", "ucbrowser", "mobile", "ie",
            "mercury", "samsung", "browser", "wow64", "silk", "lunascape", "crios", "epiphany", "konqueror", "version",
            "rv:", "build", "bot", "like gecko", "applewebkit", "trident", "mozilla", "windows nt 4", "windows nt 5.0",
            "windows nt 5.1", "windows nt 5.2", "windows nt 6.0", "windows nt 6.1", "windows nt 6.2", "windows nt 6.3",
            "windows nt 10.0", "android?4.0", "android?4.1", "android?4.2", "android?4.3", "android?4.4", "android?2.3",
            "android?5"};

    // Common prefixes to filter irrelevant rules and speed up processing
    static final String[] FILTER_PREFIXES = {"mozilla/5.0", "mozilla/4"};

    // All useragent rule ordered by size and alphabetically
    private final Rule[] myRules;

    // Filters for filtering irrelevant rules and speed up processing
    private final Filter[] myFilters;

    // The default Capabilities
    private final Capabilities myDefaultCapabilities;

    // The domain of literals for this parser
    private final LiteralDomain myDomain;

    /**
     * Creates a new parser based on a collection of rules.
     * @param rules The rules, ordered by priority
     * @param domain The domain of literals
     * @param defaultCapabilities The default capabilities
     */
    UserAgentParserImpl(final Rule[] rules, final LiteralDomain domain, final Capabilities defaultCapabilities) {
        myDomain = domain;
        myRules = getOrderedRules(rules);
        myFilters = buildFilters();
        myDefaultCapabilities = defaultCapabilities;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Capabilities parse(final String userAgent) {
        if (userAgent == null || userAgent.length() == 0) {
            return myDefaultCapabilities;
        }

        final SearchableString searchString = myDomain.getSearchableString(userAgent.toLowerCase());

        final BitSet includes = getIncludeRules(searchString, myFilters);

        for (int i = includes.nextSetBit(0); i >= 0; i = includes.nextSetBit(i + 1)) {
            final Rule rule = myRules[i];
            if (rule.matches(searchString)) {
                return rule.getCapabilities();
            }
        }

        return myDefaultCapabilities;
    }

    BitSet getIncludeRules(final SearchableString searchString, final Filter[] filters) {

        final BitSet excludes = new BitSet(myRules.length);
        for (final Filter filter : filters) {
            filter.applyExcludes(searchString, excludes);
        }

        // Convert flip the excludes to determine the includes
        final BitSet includes = excludes;
        includes.flip(0, myRules.length);
        return includes;
    }

    // Sort by size and alphabet, so the first match can be returned immediately
    static Rule[] getOrderedRules(final Rule[] rules) {

        final Comparator<Rule> c = Comparator.comparing(Rule::getSize).reversed().thenComparing(Rule::getPattern);

        final Rule[] result = Arrays.copyOf(rules, rules.length);
        parallelSort(result, c);
        return result;
    }

    Filter[] buildFilters() {

        final List<Filter> result = new ArrayList<>();

        // Build filters for specific prefix constraints
        for (final String pattern : FILTER_PREFIXES) {
            result.add(createPrefixFilter(pattern));
        }

        // Build filters for specific contains constraints
        final List<Filter> commonFilters =
                Stream.of(COMMON).parallel().map(this::createContainsFilter).collect(toList());
        result.addAll(commonFilters);

        return result.toArray(new Filter[0]);
    }

    Filter createContainsFilter(final String pattern) {
        final Literal literal = myDomain.createLiteral(pattern);

        final Predicate<SearchableString> pred = c -> c.getIndices(literal).length > 0;

        final Predicate<Rule> matches = rule -> rule.requires(pattern);

        return new Filter(pred, matches);
    }

    Filter createPrefixFilter(final String pattern) {
        final Literal literal = myDomain.createLiteral(pattern);

        final Predicate<SearchableString> pred = s -> s.startsWith(literal);

        final Predicate<Rule> matches = rule -> {
            final Literal prefix = rule.getPrefix();
            return prefix != null && prefix.toString().startsWith(pattern);
        };

        return new Filter(pred, matches);
    }

    /**
     * Filter expression to can exclude a number of rules if a useragent doesn't meet it's predicate.
     */
    class Filter {

        private final Predicate<SearchableString> myUserAgentPredicate;
        private final BitSet myMask;

        /**
         * Creates a the filter.
         * @param userAgentPredicate The predicate for matching user agents.
         * @param patternPredicate The corresponding predicate for matching rule
         */
        Filter(final Predicate<SearchableString> userAgentPredicate, final Predicate<Rule> patternPredicate) {
            myUserAgentPredicate = userAgentPredicate;
            myMask = new BitSet(myRules.length);
            for (int i = 0; i < myRules.length; i++) {
                if (patternPredicate.test(myRules[i])) {
                    myMask.set(i);
                }
            }
        }

        void applyExcludes(final SearchableString userAgent, final BitSet resultExcludes) {
            if (!myUserAgentPredicate.test(userAgent)) {
                resultExcludes.or(myMask);
            }
        }
    }
}