/streams-confluence-plugin/src/main/java/com/atlassian/streams/confluence/ConfluenceSearchQueryBuilder.java

package com.atlassian.streams.confluence;

import com.atlassian.confluence.search.service.ContentTypeEnum;
import com.atlassian.confluence.search.v2.SearchQuery;
import com.atlassian.confluence.search.v2.query.*;
import static com.atlassian.streams.util.Preconditions.*;
import static org.apache.commons.collections.CollectionUtils.*;
import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.NotNullPredicate;
import static org.apache.commons.lang.StringUtils.*;

import java.util.*;


public class ConfluenceSearchQueryBuilder
{
    // names of the text fields used by Confluence internally, will break if any is renamed by Confluence
    private static final String[] TEXT_FIELDS =
            {"title", "labelText", "contentBody", "filename", "username", "fullName", "email", "from", "recipients"};
    private final Set<String> createdByUsers = new LinkedHashSet<String>();
    private final Set<String> lastModifiedByUsers = new LinkedHashSet<String>();
    private final Set<String> spaceKeys = new LinkedHashSet<String>();
    private final Set<String> searchTerms = new LinkedHashSet<String>();
    private final Set<ContentTypeEnum> contentTypes = new LinkedHashSet<ContentTypeEnum>();

    public ConfluenceSearchQueryBuilder createdOrLastModifiedBy(Collection<String> userNames)
    {
        return createdBy(userNames).lastModifiedBy(userNames);
    }

    public ConfluenceSearchQueryBuilder createdOrLastModifiedBy(String... userNames)
    {
        return createdOrLastModifiedBy(nullSafeCollection(userNames));
    }

    @SuppressWarnings("unchecked")
    public ConfluenceSearchQueryBuilder createdBy(Collection<String> userNames)
    {
        createdByUsers.addAll(collect(nullSafeCollection(userNames), StringTrimmer.INSTANCE));
        return this;
    }

    public ConfluenceSearchQueryBuilder createdBy(String... userNames)
    {
        return createdBy(nullSafeCollection(userNames));
    }

    @SuppressWarnings("unchecked")
    public ConfluenceSearchQueryBuilder lastModifiedBy(Collection<String> userNames)
    {
        lastModifiedByUsers.addAll(collect(nullSafeCollection(userNames), StringTrimmer.INSTANCE));
        return this;
    }

    public ConfluenceSearchQueryBuilder lastModifiedBy(String... userNames)
    {
        return lastModifiedBy(nullSafeCollection(userNames));
    }

    @SuppressWarnings("unchecked")
    public ConfluenceSearchQueryBuilder inSpace(Collection<String> spaceKeys)
    {
        this.spaceKeys.addAll(collect(nullSafeCollection(spaceKeys), StringTrimmer.INSTANCE));
        return this;
    }

    public ConfluenceSearchQueryBuilder inSpace(String... spaceKeys)
    {
        return inSpace(nullSafeCollection(spaceKeys));
    }

    @SuppressWarnings("unchecked")
    public ConfluenceSearchQueryBuilder searchFor(Collection<String> searchTerms)
    {
        this.searchTerms.addAll(collect(nullSafeCollection(searchTerms), StringTrimmer.INSTANCE));
        return this;
    }

    public ConfluenceSearchQueryBuilder searchFor(String... searchTerms)
    {
        return searchFor(nullSafeCollection(searchTerms));
    }

    public ConfluenceSearchQueryBuilder contentType(Collection<ContentTypeEnum> types)
    {
        this.contentTypes.addAll(nullSafeCollection(types));
        return this;
    }

    public ConfluenceSearchQueryBuilder contentType(ContentTypeEnum... types)
    {
        return contentType(nullSafeCollection(types));
    }

    @SuppressWarnings("unchecked")
    public SearchQuery build()
    {
        BooleanQueryBuilder finalQuery = new BooleanQueryBuilder();
        filter(createdByUsers, NotNullPredicate.INSTANCE);
        filter(lastModifiedByUsers, NotNullPredicate.INSTANCE);
        if (isNotEmpty(createdByUsers) || isNotEmpty(lastModifiedByUsers))
        {
            BooleanQueryBuilder usersQuery = new BooleanQueryBuilder();
            if (isNotEmpty(createdByUsers))
            {
                usersQuery.or(collect(createdByUsers, UserNameToCreatorQueryTransformer.INSTANCE,
                        new HashSet<SearchQuery>(createdByUsers.size())));
            }
            if (isNotEmpty(lastModifiedByUsers))
            {
                usersQuery.or(collect(lastModifiedByUsers, UserNameToLastModifierQueryTransformer.INSTANCE,
                        new HashSet<SearchQuery>(lastModifiedByUsers.size())));
            }
            finalQuery.and(usersQuery);
        }
        filter(spaceKeys, NotNullPredicate.INSTANCE);
        if (isNotEmpty(spaceKeys))
        {
            finalQuery.and(new InSpaceQuery(new HashSet<String>(spaceKeys)));
        }
        filter(searchTerms, NotNullPredicate.INSTANCE);
        if (isNotEmpty(searchTerms))
        {
            finalQuery.and(buildMultiTextFieldQuery(searchTerms));
        }
        filter(contentTypes, NotNullPredicate.INSTANCE);
        if (isNotEmpty(contentTypes))
        {
            finalQuery.and(new ContentTypeQuery(contentTypes));
        }
        return finalQuery.build();
    }

    private static SearchQuery buildMultiTextFieldQuery(Set<String> keywords)
    {
        StringBuilder sb = new StringBuilder();
        for (String keyword : keywords)
        {
            if (sb.length() > 0)
                sb.append(' ');
            sb.append(keyword);
        }
        return new MultiTextFieldQuery(sb.toString(), TEXT_FIELDS);
    }

    private static <T> Collection<T> nullSafeCollection(T[] source)
    {
        if (source == null)
        {
            return Collections.emptyList();
        }
        return Arrays.asList(source);
    }

    private static <T> Collection<T> nullSafeCollection(Collection<T> source)
    {
        if (source == null)
        {
            return Collections.emptyList();
        }
        return source;
    }

    static class StringTrimmer implements Transformer
    {
        public static StringTrimmer INSTANCE = new StringTrimmer();

        private StringTrimmer()
        {
            super();
        }

        public Object transform(Object input)
        {
            return trimToNull((String)input);
        }
    }

    static class UserNameToCreatorQueryTransformer implements Transformer
    {
        public static UserNameToCreatorQueryTransformer INSTANCE =
                new UserNameToCreatorQueryTransformer();

        private UserNameToCreatorQueryTransformer()
        {
            super();
        }

        public Object transform(Object input)
        {
            String userName = (String) input;
            return isBlank(userName) ? null : new CreatorQuery(userName);
        }
    }

    static class UserNameToLastModifierQueryTransformer implements Transformer
    {
        public static UserNameToLastModifierQueryTransformer INSTANCE =
                new UserNameToLastModifierQueryTransformer();

        private UserNameToLastModifierQueryTransformer()
        {
            super();
        }

        public Object transform(Object input)
        {
            String userName = (String) input;
            return isBlank(userName) ? null : new LastModifierQuery(userName);
        }
    }

    static class BooleanQueryBuilder
    {
        private Boolean isAndQuery;
        private final Set<SearchQuery> queries;

        private BooleanQueryBuilder()
        {
            queries = new HashSet<SearchQuery>();
        }

        BooleanQueryBuilder and(Collection<SearchQuery> queries)
        {
            if (isAndQuery != null && !isAndQuery)
            {
                throw new IllegalStateException(
                        "AND operation not permitted as a previous OR operation has been called.");
            }
            isAndQuery = true;
            this.queries.addAll(checkNotNull(queries, "Sub queries"));
            return this;
        }

        BooleanQueryBuilder and(SearchQuery... queries)
        {
            return and(Arrays.asList(checkNotNull(queries, "Sub queries")));
        }

        BooleanQueryBuilder and(BooleanQueryBuilder queryBuilder)
        {
            return and(queryBuilder.build());
        }

        BooleanQueryBuilder or(Collection<SearchQuery> queries)
        {
            if (isAndQuery != null && isAndQuery)
            {
                throw new IllegalStateException(
                        "OR operation not permitted as a previous AND operation has been called.");
            }
            isAndQuery = false;
            this.queries.addAll(checkNotNull(queries, "Sub queries"));
            return this;
        }

        BooleanQueryBuilder or(SearchQuery... queries)
        {
            return or(Arrays.asList(checkNotNull(queries, "Sub queries")));
        }

        BooleanQueryBuilder or(BooleanQueryBuilder queryBuilder)
        {
            return or(queryBuilder.build());
        }

        SearchQuery build()
        {
            if (queries.isEmpty())
            {
                throw new IllegalStateException("New subqueries added.");
            }
            SearchQuery result =
                    isAndQuery ? BooleanQuery.composeAndQuery(queries) : BooleanQuery.composeOrQuery(queries);
            isAndQuery = null;
            queries.clear();
            return result;
        }

    }

}