/**
 * Copyright 2010-2013 The Kuali Foundation
 *
 * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
 *
 * 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.
 */
package org.kuali.common.util;

import java.io.File;
import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.kuali.common.util.nullify.NullUtils;

import com.google.common.collect.ImmutableList;

public class CollectionUtils {

        public static Collection<String> getBlanks(Collection<String> collection) {
                Collection<String> blanks = new ArrayList<String>();
                for (String element : collection) {
                        if (StringUtils.isBlank(element)) {
                                blanks.add(element);
                        }
                }
                return blanks;
        }

        /**
         * Returns a new unmodifiable list containing the elements from <code>list</code>
         * 
         * @deprecated See ListUtils.newArrayList() instead
         */
        @Deprecated
        public static <T> List<T> unmodifiableCopy(List<T> list) {
                return Collections.unmodifiableList(new ArrayList<T>(list));
        }

        /**
         * Get an unmodifiable list from the single element. Return emptyList() if element is null.
         * 
         * @deprecated Use CollectionUtils.singletonList() instead
         */
        @Deprecated
        public static <T> List<T> unmodifiableList(T element) {
                List<T> list = toEmptyList(element);
                return Collections.unmodifiableList(list);
        }

        /**
         * Get an unmodifiable list from elements
         * 
         * @deprecated Use ImmutableList.copyOf(elements) instead
         */
        @Deprecated
        public static <T> List<T> unmodifiableList(T... elements) {
                return Collections.unmodifiableList(Arrays.asList(elements));
        }

        /**
         * If the CSV is whitespace, the empty string, <code>null</code>, <code>"null"</code>, or <code>"none"</code>, return an empty list.
         */
        public static List<String> getNoneSensitiveListFromCSV(String csv) {
                if (StringUtils.isBlank(csv) || NullUtils.isNullOrNone(csv)) {
                        return Collections.<String> emptyList();
                } else {
                        return CollectionUtils.getTrimmedListFromCSV(csv);
                }
        }

        /**
         * Remove any Strings from the list that do not match the filter and then sort the ones that remain
         * 
         * @return The list of strings that were filtered out.
         * @deprecated
         */
        @Deprecated
        public static List<String> filterAndSort(List<String> strings, StringFilter filter) {
                List<String> excluded = filter(strings, filter);
                Collections.sort(strings);
                return excluded;
        }

        /**
         * Remove any Strings from the list that do not match the filter and then sort the ones that remain
         * 
         * @return The list of strings that were filtered out.
         */
        public static List<String> filterAndSortStrings(List<String> strings, org.kuali.common.util.filter.StringFilter filter) {
                List<String> excluded = filterStrings(strings, filter);
                Collections.sort(strings);
                return excluded;
        }

        /**
         * Remove any Strings from the collection that do not match the filter
         */
        public static List<String> filterStrings(Collection<String> strings, org.kuali.common.util.filter.StringFilter filter) {
                List<String> excluded = new ArrayList<String>();
                Iterator<String> itr = strings.iterator();
                while (itr.hasNext()) {
                        String string = itr.next();
                        if (!filter.include(string)) {
                                excluded.add(string);
                                itr.remove();
                        }
                }
                return excluded;
        }

        /**
         * Remove any Strings from the collection that do not match the filter
         * 
         * @deprecated
         */
        @Deprecated
        public static List<String> filter(Collection<String> strings, StringFilter filter) {
                List<String> excluded = new ArrayList<String>();
                Iterator<String> itr = strings.iterator();
                while (itr.hasNext()) {
                        String string = itr.next();
                        if (!filter.include(string)) {
                                excluded.add(string);
                                itr.remove();
                        }
                }
                return excluded;
        }

        /**
         * Null safe method for converting an array of objects into a list. Never returns null.
         */
        public static List<Object> asList(Object... objects) {
                List<Object> list = new ArrayList<Object>();
                if (objects == null) {
                        return list;
                }
                for (Object element : objects) {
                        if (element != null) {
                                list.add(element);
                        }
                }
                return list;
        }

        /**
         * Null safe method for converting an untyped array of classes into a list. Never returns null.
         */
        public static List<Class<?>> asList(Class<?>... classes) {
                List<Class<?>> list = new ArrayList<Class<?>>();
                if (classes == null) {
                        return list;
                }
                for (Class<?> element : classes) {
                        if (element != null) {
                                list.add(element);
                        }
                }
                return list;
        }

        /**
         * Return an array of int's that represents as even of a split as possible
         * 
         * For example: passing in 100,7 returns 15, 15, 14, 14, 14, 14, 14
         * 
         * @param numerator
         * @param denominator
         * @return
         */
        public static int[] getDivideEvenly(int number, int howManyWays) {
                Assert.isTrue(howManyWays > 0, "howManyWays must be a positive integer");
                int quotient = number / howManyWays;
                int remainder = number % howManyWays;

                int[] lengths = new int[howManyWays];
                for (int i = 0; i < howManyWays; i++) {
                        int length = i < remainder ? quotient + 1 : quotient;
                        lengths[i] = length;
                }
                return lengths;
        }

        /**
         * Split <code>elements</code> evenly into separate lists divided up <code>howManyWays</code>
         */
        public static final <T> List<List<T>> splitEvenly(List<T> elements, int howManyWays) {
                // Can't split 2 things 3 ways
                if (howManyWays > elements.size()) {
                        howManyWays = elements.size();
                }
                int[] lengths = getDivideEvenly(elements.size(), howManyWays);
                int offset = 0;
                List<List<T>> listOfLists = new ArrayList<List<T>>();
                for (int i = 0; i < lengths.length; i++) {
                        int length = lengths[i];
                        List<T> sublist = new ArrayList<T>();
                        for (int j = offset; j < offset + length; j++) {
                                sublist.add(elements.get(j));
                        }
                        listOfLists.add(sublist);
                        offset += length;
                }
                return listOfLists;
        }

        /**
         * Prefix the strings passed in with their position in the list (left padded with zero's). The padding is the number of digits in the size of the list. A list with 100 elements
         * will return strings prefixed with 000, 001, etc.
         */
        public static final List<String> getSequencedStrings(List<String> strings, int initialSequenceNumber) {
                List<String> sequencedStrings = new ArrayList<String>();
                int size = strings.size();
                int length = new Integer(size).toString().length();
                String prefix = StringUtils.repeat("0", length);
                for (String string : strings) {
                        String sequence = StringUtils.right(prefix + (initialSequenceNumber++), length);
                        String sequencedString = sequence + "-" + string;
                        sequencedStrings.add(sequencedString);
                }
                return sequencedStrings;
        }

        /**
         * Prefix the strings passed in with their position in the list (left padded with zero's). The padding is the number of digits in the size of the list. A list with 100 elements
         * will return strings prefixed with 000, 001, etc.
         */
        public static final List<String> getSequencedStrings(List<String> strings) {
                return getSequencedStrings(strings, 0);
        }

        /**
         * Return a new <code>List</code> containing the unique set of strings from <code>strings</code>
         */
        public static final List<String> getUniqueStrings(List<String> strings) {
                LinkedHashSet<String> unique = new LinkedHashSet<String>(strings);
                return new ArrayList<String>(unique);
        }

        public static final List<File> getUniqueFiles(List<File> files) {
                LinkedHashSet<File> unique = new LinkedHashSet<File>(files);
                return new ArrayList<File>(unique);
        }

        public static final List<String> getLines(String s) {
                if (s == null) {
                        return Collections.<String> emptyList();
                }
                try {
                        return IOUtils.readLines(new StringReader(s));
                } catch (IOException e) {
                        throw new IllegalStateException(e);
                }
        }

        /**
         * Return a new list containing the unique set of strings contained in both lists
         */
        public static final List<String> combineStringsUniquely(List<String> list1, List<String> list2) {
                List<String> newList = getUniqueStrings(list1);
                for (String element : list2) {
                        if (!newList.contains(element)) {
                                newList.add(element);
                        }
                }
                return newList;
        }

        protected static final <T> T getNewInstance(Class<T> c) {
                try {
                        return c.newInstance();
                } catch (IllegalAccessException e) {
                        throw new IllegalArgumentException(e);
                } catch (InstantiationException e) {
                        throw new IllegalArgumentException(e);
                }
        }

        /**
         * Create a new list containing new instances of <code>c</code>
         */
        public static final <T> List<T> getNewList(Class<T> c, int size) {
                List<T> list = new ArrayList<T>();
                for (int i = 0; i < size; i++) {
                        T element = getNewInstance(c);
                        list.add(element);
                }
                return list;
        }

        /**
         * Return a list containing only the elements where the corresponding index in the <code>includes</code> list is <code>true</code>. <code>includes</code> and <code>list</code>
         * must be the same size.
         */
        public static final <T> List<T> getList(List<Boolean> includes, List<T> list) {
                Assert.isTrue(includes.size() == list.size());
                List<T> included = new ArrayList<T>();
                for (int i = 0; i < includes.size(); i++) {
                        if (includes.get(i)) {
                                included.add(list.get(i));
                        }
                }
                return included;
        }

        /**
         * Combine the list of lists into a single list
         */
        public static final <T> List<T> combineLists(List<List<T>> listOfLists) {
                List<T> combined = new ArrayList<T>();
                for (List<T> list : listOfLists) {
                        combined.addAll(list);
                }
                return combined;
        }

        /**
         * Combine the list of maps into a single map
         */
        public static final <K, V> Map<K, V> combineMaps(List<Map<K, V>> listOfMaps) {
                Map<K, V> combined = new HashMap<K, V>();
                for (Map<K, V> map : listOfMaps) {
                        combined.putAll(map);
                }
                return combined;
        }

        /**
         * Return a combined list where <code>required</code> is always the first element in the list
         */
        public static final <T> List<T> combine(T element, List<T> list) {
                Assert.notNull(element, "element is required");
                if (list == null) {
                        return Collections.singletonList(element);
                } else {
                        List<T> combined = new ArrayList<T>();
                        // Always insert required as the first element in the list
                        combined.add(element);
                        // Add the other elements
                        for (T optional : list) {
                                combined.add(optional);
                        }
                        return combined;
                }
        }

        /**
         * If <code>map==null</code> return emptyMap(), otherwise return <code>map</code>
         */
        public static final <K, V> Map<K, V> toEmptyMap(Map<K, V> map) {
                if (map == null) {
                        return Collections.emptyMap();
                } else {
                        return map;
                }
        }

        /**
         * If <code>map==null</code> return <code>new HashMap<K,V>()</code>, otherwise return <code>map</code>
         */
        public static final <K, V> Map<K, V> toModifiableEmptyMap(Map<K, V> map) {
                if (map == null) {
                        return new HashMap<K, V>();
                } else {
                        return map;
                }
        }

        /**
         * If <code>key==null</code> OR <code>value==null</code> return <code>new HashMap<K,V>()</code> otherwise return
         * <code>new HashMap<K, V>(Collections.singletonMap(key, value))</code>
         */
        public static final <K, V> Map<K, V> toModifiableEmptyMap(K key, V value) {
                if (key == null || value == null) {
                        return new HashMap<K, V>();
                } else {
                        return new HashMap<K, V>(Collections.singletonMap(key, value));
                }
        }

        /**
         * If <code>key==null</code> OR <code>value==null</code> return an empty map otherwise return a singleton map.
         */
        public static final <K, V> Map<K, V> toEmptyMap(K key, V value) {
                if (key == null || value == null) {
                        return Collections.emptyMap();
                } else {
                        return Collections.singletonMap(key, value);
                }
        }

        /**
         * If <code>o==null</code> return <code>Collections.&lt;T> emptyList()</code> otherwise return <code>Collections.singletonList(o)</code>
         */
        public static final <T> List<T> toEmptyList(T o) {
                if (o == null) {
                        return Collections.<T> emptyList();
                } else {
                        return Collections.singletonList(o);
                }
        }

        /**
         * Returns an immutable list containing only the specified object. The returned list is serializable.
         * 
         * @throws IllegalArgumentException
         *             if object is null
         */
        public static final <T> List<T> singletonList(T o) {
                if (o != null) {
                        return Collections.singletonList(o);
                } else {
                        throw new IllegalArgumentException("nulls not allowed");
                }
        }

        /**
         * Add keys and values to map. Keys and values must be the same size (or both null). Map cannot be null.
         */
        public static final <K, V> void combine(Map<K, V> map, List<K> keys, List<V> values) {
                keys = toEmptyList(keys);
                values = toEmptyList(values);
                Assert.isTrue(keys.size() == values.size(), "sizes must match");
                Assert.notNull(map, "map is null");
                for (int i = 0; i < keys.size(); i++) {
                        K key = keys.get(i);
                        V value = values.get(i);
                        map.put(key, value);
                }
        }

        /**
         * If <code>list==null</code> return an empty list otherwise return <code>list</code>
         */
        public static final <T> List<T> toEmptyList(List<T> list) {
                if (list == null) {
                        return Collections.emptyList();
                } else {
                        return list;
                }
        }

        public static final <T> List<T> toNullIfEmpty(List<T> list) {
                if (isEmpty(list)) {
                        return null;
                } else {
                        return list;
                }
        }

        public static final <T> Collection<T> toNullIfEmpty(Collection<T> c) {
                if (isEmpty(c)) {
                        return null;
                } else {
                        return c;
                }
        }

        public static final <T> List<T> getPreFilledList(int size, T value) {
                if (value == null || size < 1) {
                        return Collections.<T> emptyList();
                } else {
                        List<T> list = new ArrayList<T>(size);
                        for (int i = 0; i < size; i++) {
                                list.add(value);
                        }
                        return list;
                }
        }

        public static final String getSpaceSeparatedCSV(List<String> strings) {
                return getStringWithSeparator(strings, ", ");
        }

        public static final String getStringWithSeparator(List<?> list, String separator) {
                list = toEmptyList(list);
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < toEmptyList(list).size(); i++) {
                        if (i != 0) {
                                sb.append(separator);
                        }
                        Object element = list.get(i);
                        if (element != null) {
                                sb.append(element.toString());
                        } else {
                                sb.append(NullUtils.NULL);
                        }
                }
                return sb.toString();
        }

        public static final String toCSV(List<Integer> integers) {
                Assert.noNulls(integers);
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < integers.size(); i++) {
                        if (i != 0) {
                                sb.append(",");
                        }
                        sb.append(integers.get(i));
                }
                return sb.toString();
        }

        public static final String asCSV(List<String> strings) {
                return getCSV(strings);
        }

        public static final String getCSV(List<String> strings) {
                return getStringWithSeparator(strings, ",");
        }

        public static final String getSpaceSeparatedString(List<?> list) {
                return getStringWithSeparator(list, " ");
        }

        public static final Object[] toObjectArray(List<Object> objects) {
                return objects.toArray(new Object[objects.size()]);
        }

        public static final String[] toStringArray(List<String> strings) {
                return strings.toArray(new String[strings.size()]);
        }

        public static final boolean isEmpty(Collection<?> c) {
                return c == null || c.size() == 0;
        }

        public static final boolean isEmpty(Map<?, ?> m) {
                return m == null || m.size() == 0;
        }

        public static final List<String> sortedMerge(List<String> list, String csv) {
                Set<String> set = new TreeSet<String>();
                set.addAll(toEmptyList(list));
                set.addAll(getTrimmedListFromCSV(csv));
                return new ArrayList<String>(set);
        }

        public static final List<String> getTrimmedListFromCSV(String csv) {
                if (StringUtils.isBlank(csv)) {
                        return Collections.<String> emptyList();
                }
                String[] tokens = Str.splitAndTrimCSV(csv);
                List<String> list = new ArrayList<String>();
                list.addAll(Arrays.asList(tokens));
                return list;
        }

        public static final <T> List<T> nullSafeCombine(List<T> list1, List<T> list2) {
                List<T> combined = new ArrayList<T>();
                if (!isEmpty(list1)) {
                        combined.addAll(list1);
                }
                if (!isEmpty(list2)) {
                        combined.addAll(list2);
                }
                return combined;
        }

        public static final List<String> combineStrings(List<String> list1, List<String> list2, List<String> list3) {
                List<String> combined = new ArrayList<String>();
                nullSafeAdd(combined, list1);
                nullSafeAdd(combined, list2);
                nullSafeAdd(combined, list3);
                return combined;
        }

        /**
         * Return a new list containing all of the strings from both lists with string added in between the strings from both lists
         */
        public static final List<String> combineStrings(List<String> list1, String string, List<String> list2) {
                return combineStrings(list1, toEmptyList(string), list2);
        }

        /**
         * Return a new list containing all of the strings from both lists
         */
        public static final List<String> combineStrings(List<String> list1, List<String> list2) {
                return combineStrings(list1, (String) null, list2);
        }

        /**
         * Return a new list containing all of the strings from both lists
         */
        public static final List<String> combineStrings(List<String>... lists) {
                List<String> combined = new ArrayList<String>();
                for (List<String> list : lists) {
                        combined.addAll(ImmutableList.copyOf(list));
                }
                return combined;
        }

        /**
         * Return a new list containing all of the elements from the lists passed in
         */
        public static final <T> List<T> combine(List<T> list1, List<T> list2) {
                return combine(list1, list2, null);
        }

        public static final <T> List<T> combine(List<T> list1, List<T> list2, List<T> list3) {
                List<T> combined = new ArrayList<T>();
                combined.addAll(toEmptyList(list1));
                combined.addAll(toEmptyList(list2));
                combined.addAll(toEmptyList(list3));
                return combined;
        }

        public static final <T> void nullSafeAdd(List<T> list1, List<T> list2) {
                if (list2 != null) {
                        list1.addAll(list2);
                }
        }

        /**
         * Return <code>true</code> if <code>s</code> contains any of the strings from <code>strings</code>
         */
        public static final boolean containsAny(String s, List<String> strings) {
                for (String string : strings) {
                        if (StringUtils.contains(s, string)) {
                                return true;
                        }
                }
                return false;
        }
}