package com.yanzuoguang.util.helper;

import java.util.*;

/**
 * 字符串帮主类
 *
 * @author 颜佐光
 */
public class ArrayHelper {
    /**
     * 合并为数组列表
     *
     * @param from  参数列表
     * @param froms 参数列表
     * @param <T>   泛型类型
     * @return 非空字符串数组
     */
    @SafeVarargs
    public static <T> List<T> megerNotEmpty(T from, Collection<T>... froms) {
        List<T> tos = new ArrayList<>();
        if (from != null && !StringHelper.isEmpty(from)) {
            tos.add(from);
        }
        if (froms == null) {
            return tos;
        }
        for (Collection<T> list : froms) {
            if (list == null) {
                continue;
            }
            for (T item : list) {
                if (!StringHelper.isEmpty(item)) {
                    tos.add(item);
                }
            }
        }
        return tos;
    }

    /**
     * 获取第一个对象
     *
     * @param froms
     * @param <T>
     * @return
     */
    public static <T> T getFirst(List<T> froms) {
        return froms.size() > 0 ? froms.get(0) : null;
    }

    /**
     * 获取第一个对象
     *
     * @param froms
     * @param <T>
     * @return
     */
    public static <T> T getFirst(Collection<T> froms) {
        if (froms == null) {
            return null;
        }
        for (T from : froms) {
            return from;
        }
        return null;
    }

    /**
     * 判断对象是否是数组或者List
     *
     * @param val
     * @return
     */
    public static boolean isArrayOrList(Object val) {
        return val != null && (val instanceof List || val.getClass().isArray());
    }
    /**
     * 判断对象是否是数组或者List
     *
     * @param val
     * @return
     */
    public static boolean isArrayOrCollection(Object val) {
        return val != null && (val instanceof Collection || val.getClass().isArray());
    }


    /**
     * 判断对象是否是数组或者List
     *
     * @param val
     * @return
     */
    public static int getSize(List val) {
        return val != null ? val.size() : 0;
    }

    /**
     * 判断对象是否是数组或者List
     *
     * @param val
     * @return
     */
    public static boolean isEmpty(List val) {
        return val == null || val.isEmpty();
    }

    /**
     * 获取对象为对象列表
     *
     * @param val 需要获取的对象，可以为List或者Array或者其他对象.
     * @return
     */
    public static List getList(Object val) {
        boolean isArray = isArrayOrList(val);
        List list;
        // 判断处理
        if (val instanceof List) {
            list = (List) val;
        } else if (isArray) {
            Object[] arr = (Object[]) val;
            list = Arrays.asList(arr);
        } else {
            list = new ArrayList();
            list.add(val);
        }
        return list;
    }
    /**
     * 获取对象为对象列表
     *
     * @param val 需要获取的对象，可以为List或者Array或者其他对象.
     * @return
     */
    public static Collection getCollection(Object val) {
        boolean isArray = isArrayOrCollection(val);
        Collection list;
        // 判断处理
        if (val instanceof Collection) {
            list = (Collection) val;
        } else if (isArray) {
            Object[] arr = (Object[]) val;
            list = Arrays.asList(arr);
        } else {
            list = new ArrayList();
            list.add(val);
        }
        return list;
    }

    /**
     * 将数组添加到列表中
     *
     * @param from
     * @param <T>
     */
    public static final <T> List<T> mergeList(T[]... from) {
        List<T> list = new ArrayList<>();
        addList(list, from);
        return list;
    }

    /**
     * 将数组添加到列表中
     *
     * @param from
     * @param <T>
     */
    public static final <T> List<T> mergeList(List<T>... from) {
        List<T> list = new ArrayList<>();
        addList(list, from);
        return list;
    }

    /**
     * 将数组添加到列表中
     *
     * @param list
     * @param from
     * @param <T>
     */
    public static final <T> void addList(List<T> list, T[]... from) {
        for (T[] item : from) {
            for (T sub : item) {
                list.add(sub);
            }
        }
    }


    /**
     * 将数组添加到列表中
     *
     * @param list
     * @param from
     * @param <T>
     */
    public static final <T> void addList(List<T> list, List<T>... from) {
        for (List<T> item : from) {
            for (T sub : item) {
                list.add(sub);
            }
        }
    }

}