package com.engine.salary.remote.cbs8;

import com.alibaba.fastjson.JSON;
import com.engine.salary.exception.CBS8RunTimeException;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collector;
import java.util.stream.Collectors;

/**
 * 实体类相关
 * <p>Copyright: Copyright (c) 2022</p>
 * <p>Company: 泛微软件</p>
 *
 * @author qiantao
 * @version 1.0
 **/
public class SalaryEntityUtil {

    private static final DecimalFormat decimalFormat = new DecimalFormat("#,##0.00");

    /**
     * 数字正则表达式
     * 包含负数、正数、小数、0、0.00000等
     */
    public static final String NUMBER_REGEX = "(-?[1-9]\\d*\\.?\\d+)|(-?0\\.\\d*[0-9])|(\\d+)";

    /**
     * 千分位格式化
     *
     * @param originMap 原始map
     * @param targetMap 目标map
     */
    public static void thousandthConvert(Map<String, Object> originMap, Map<String, Object> targetMap) {

        if (MapUtils.isNotEmpty(originMap)) {
            originMap.forEach((k, v) -> {
                if (StringUtils.isNotBlank(String.valueOf(v))) {
                    targetMap.put(k, decimalFormat.format(Double.valueOf(String.valueOf(v))));
                }
            });
        }
    }

    /**
     * 千分位格式化
     *
     * @param originString 原始字符串
     * @return 格式化后的字符串
     */
    public static String thousandthConvert(String originString) {
        if (StringUtils.isNotBlank(originString)) {
            return decimalFormat.format(Double.valueOf(originString));
        }
        return "0.00";
    }

    /**
     * 判断对象或对象数组中每一个对象是否为空: 对象为null，字符序列长度为0，集合类、Map为empty
     *
     * @param obj
     * @return
     */
    public static boolean isNullOrEmpty(Object obj) {
        if (obj == null) {
            return true;
        }
        if (obj instanceof CharSequence) {
            return ((CharSequence) obj).length() == 0;
        }
        if (obj instanceof Collection) {
            return ((Collection) obj).isEmpty();
        }
        if (obj instanceof Map) {
            return ((Map) obj).isEmpty();
        }
        if (obj instanceof Object[]) {
            Object[] object = (Object[]) obj;
            if (object.length == 0) {
                return true;
            }
            boolean empty = true;
            for (int i = 0; i < object.length; i++) {
                if (!isNullOrEmpty(object[i])) {
                    empty = false;
                    break;
                }
            }
            return empty;
        }

        return false;
    }

    public static boolean isNotNullOrEmpty(Object obj) {
        return !isNullOrEmpty(obj);
    }

    public static <R, T, A> A properties(Collection<T> objs, Function<T, R> function, Collector<R, ?, A> collectors) {
        return objs.stream().map(function).collect(collectors);
    }

    public static <R, T> Set<R> properties(Collection<T> objs, Function<T, R> function) {
        if (CollectionUtils.isEmpty(objs)) {
            return Sets.newHashSet();
        }
        return properties(objs, function, Collectors.toSet());
    }

    public static <R, T> Map<R, T> convert2Map(Collection<T> objs, Function<T, R> function) {
        if (CollectionUtils.isEmpty(objs)) {
            return Maps.newHashMap();
        }
        return objs.stream().collect(Collectors.toMap(function, Function.identity(), (a, b) -> a));
    }

    public static <T, K, V> Map<K, V> convert2Map(Collection<T> objs, Function<T, K> keyMapper, Function<T, V> valueMapper) {
        if (CollectionUtils.isEmpty(objs)) {
            return Maps.newHashMap();
        }
        return objs.stream()
                .filter(e -> valueMapper.apply(e) != null && keyMapper.apply(e) != null)
                .collect(Collectors.toMap(keyMapper, valueMapper, (a, b) -> a));
    }

    public static <R, T> Map<R, List<T>> group2Map(Collection<T> objs, Function<T, R> function) {
        if (CollectionUtils.isEmpty(objs)) {
            return Maps.newHashMap();
        }
        return objs.stream().collect(Collectors.groupingBy(function));
    }

    public static <T, K, V> Map<K, Set<V>> group2Map(Collection<T> objs, Function<T, K> keyMapper, Function<T, V> valueMapper) {
        if (CollectionUtils.isEmpty(objs)) {
            return Maps.newHashMap();
        }
        return objs.stream()
                .filter(e -> keyMapper.apply(e) != null && valueMapper.apply(e) != null)
                .collect(Collectors.groupingBy(keyMapper,
                        Collectors.collectingAndThen(Collectors.toList(), e -> e.stream().map(valueMapper).collect(Collectors.toSet()))));
    }

    public static <T, K, V> Map<K, List<V>> group2ListMap(Collection<T> objs, Function<T, K> keyMapper, Function<T, V> valueMapper) {
        if (CollectionUtils.isEmpty(objs)) {
            return Maps.newHashMap();
        }
        return objs.stream()
                .filter(e -> keyMapper.apply(e) != null && valueMapper.apply(e) != null)
                .collect(Collectors.groupingBy(keyMapper,
                        Collectors.collectingAndThen(Collectors.toList(), e -> e.stream().map(valueMapper).collect(Collectors.toList()))));
    }

    public static <R, T, K, V> Map<R, Map<K, V>> list2Map(Collection<T> objs, Function<T, R> function1, Function<T, K> function2, Function<T, V> function3) {
        if (CollectionUtils.isEmpty(objs)) {
            return Maps.newHashMap();
        }
        Map<R, List<T>> collect = objs.stream().collect(Collectors.groupingBy(function1));
        Map<R, Map<K, V>> map = new HashMap<>();
        for (Map.Entry<R, List<T>> entry: collect.entrySet()) {
            Map<K, V> values = map.getOrDefault(entry.getKey(), new HashMap<>());
            entry.getValue().forEach(e -> values.put(function2.apply(e), function3.apply(e)));
            map.put(entry.getKey(), values);
        }
        return map;
    }

    public static <R, T, K> Map<R, Map<K, T>> list2Map(Collection<T> objs, Function<T, R> function1, Function<T, K> function2) {
        if (CollectionUtils.isEmpty(objs)) {
            return Maps.newHashMap();
        }
        Map<R, List<T>> collect = objs.stream().collect(Collectors.groupingBy(function1));
        Map<R, Map<K, T>> map = new HashMap<>();
        for (Map.Entry<R, List<T>> entry: collect.entrySet()) {
            Map<K, T> values = map.getOrDefault(entry.getKey(), new HashMap<>());
            entry.getValue().forEach(e -> values.put(function2.apply(e), e));
            map.put(entry.getKey(), values);
        }
        return map;
    }



    /**
     * LinkedHashMap有序去重
     *
     * @param keyExtractor
     * @param <T>
     * @return
     */
    public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
        LinkedHashMap<Object, Boolean> map = new LinkedHashMap<>();
        return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

    /**
     * ConcurrentHashMap无序去重
     *
     * @param keyExtractor
     * @param <T>
     * @return
     */
    public static <T> Predicate<T> distinctByKeyMap(Function<? super T, Object> keyExtractor) {
        ConcurrentHashMap<Object, Boolean> map = new ConcurrentHashMap<>();
        return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

    public static <T> BigDecimal reduce(Collection<T> objs, Function<T, BigDecimal> function) {
        if (CollectionUtils.isEmpty(objs)) {
            return BigDecimal.ZERO;
        }
        return objs.stream()
                .filter(e -> function.apply(e) != null)
                .map(function)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }

    public static BigDecimal empty2Zero(String value) {
        if (StringUtils.isEmpty(value)) {
            return BigDecimal.ZERO;
        }
        try {
            return new BigDecimal(value);
        } catch (Exception e) {
            return BigDecimal.ZERO;
        }
    }



    /**
     * 两个集合是否有交集
     *
     * @param list1
     * @param list2
     * @param <T>
     * @return
     */
    public static <T> boolean judgeIntersection(List<T> list1, List<T> list2) {
        boolean flag = false;
        List<T> origin = new ArrayList<>();
        origin.addAll(list1);
        origin.retainAll(list2);
        if (origin.size() > 0) {
            flag = true;
        }
        return flag;
    }

    /**
     * String转Long
     *
     * @param obj
     * @return
     */
    public static Long string2Long(String obj) {
        if (NumberUtils.isCreatable(obj)) {
            return Long.valueOf(obj);
        }
        return null;
    }

    /**
     * String转Integer
     *
     * @param obj
     * @return
     */
    public static Integer string2Integer(String obj) {
        if (NumberUtils.isCreatable(obj)) {
            return Integer.valueOf(obj);
        }
        return null;
    }

    /**
     * String转BigDecimal
     *
     * @param obj
     * @return
     */
    public static BigDecimal string2BigDecimal(String obj) {
        if (NumberUtils.isCreatable(obj)) {
            return new BigDecimal(obj);
        }
        return null;
    }

    /**
     * String转BigDecimal
     *
     * @param obj
     * @return
     */
    public static BigDecimal string2BigDecimalDefault0(String obj) {
        if (NumberUtils.isCreatable(obj)) {
            return new BigDecimal(obj);
        }
        return BigDecimal.ZERO;
    }

    /**
     * 判断字符串是否等于0
     *
     * @param obj
     * @return
     */
    public static boolean StringEqZERO(String obj) {
        if (NumberUtils.isCreatable(obj)) {
            return BigDecimal.ZERO.compareTo(new BigDecimal(obj)) == 0;
        }
        return false;
    }


    public static Double string2DoubleDefault0(String obj) {
        if (NumberUtils.isCreatable(obj)) {
            return new Double(obj);
        }
        return new Double("0.0");
    }

    /**
     * 两个集合交集，（forEasy）
     *
     * @param arr1
     * @param arr2
     * @return
     */
    public static <T> Collection<T> intersectionForList(Collection<T> arr1, Collection<T> arr2) {

        Collection<T> resultList = new ArrayList<>();

        if (CollectionUtils.isEmpty(arr1) || CollectionUtils.isEmpty(arr1)) {
            return resultList;
        }
        arr1.forEach(a1 -> {
            if (arr2.contains(a1)) {
                resultList.add(a1);
            }
        });
        return resultList;
    }

    public static String toJSONString(Object obj) {
        if (obj != null) {
            return JSON.toJSONString(obj);
        }
        return "";
    }


    public static String null2String(Object obj) {
        if (Objects.isNull(obj)) {
            return "";
        }
        return obj.toString();
    }

    public static String null2String(Object obj, String def) {
        if (Objects.isNull(obj)) {
            return def;
        }
        return obj.toString();
    }

    public static Integer getIntValue(Object obj, Integer def) {
        if (Objects.isNull(obj)) {
            return def;
        }
        try {
            return StringUtils.isEmpty(String.valueOf(obj)) ? def : Integer.valueOf(String.valueOf(obj));
        } catch (NumberFormatException e) {
            return def;
        }
    }

    public static BigDecimal getBigDecimal(Object value, int scale) {
        String valueStr = null2String(value);
        if (StringUtils.isEmpty(valueStr)) {
            return BigDecimal.ZERO;
        }
        try {
            return new BigDecimal(valueStr).setScale(scale, RoundingMode.HALF_UP);
        } catch (NumberFormatException e) {
            return null;
        }
    }

    public static BigDecimal getBigDecimal(Object value, int scale, BigDecimal defValue) {
        try {
            return new BigDecimal(null2String(value)).setScale(scale, RoundingMode.HALF_UP);
        } catch (NumberFormatException e) {
            return defValue;
        }
    }


    public static <T> T findFirst(Collection<T> objs) {
        if (CollectionUtils.isEmpty(objs)) {
            throw new CBS8RunTimeException("the collection can not be empty");
        }
        return objs.stream().findFirst().orElse(null);
    }

}