package cn.cecep.talroad.util.effective;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class StringTools {

    // 判断整数
    public static boolean isIntNum(String str) {
        if (null == str || "".equals(str)) {
            return false;
        }
        Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
        return pattern.matcher(str).matches();
    }

    public static void main(String[] args) {
        String s = sciCal(-16.9117, 1);

        System.out.println(s);
        System.out.println(new BigDecimal(-16.9117).setScale(1,BigDecimal.ROUND_HALF_EVEN));
    }

    /**
     * @param data 需要科学计算的数据
     * @param digit 保留的小数位
     * @return
     * 功能：四舍六入五成双计算法
     */
    public static String sciCal(Object data, int digit){
        String result = null;
        if (Objects.nonNull(data)){
            //判断负数 不能计算问题
            String parent="";
            String valueData = data.toString();
            if(valueData.contains("-")){
                parent="-";
                valueData=valueData.replace("-","");
            }
            try {
                double value=Double.valueOf(valueData);
                double ratio = Math.pow(10, digit);
                double _num = value * ratio;
                double mod = _num % 1;
                double integer = Math.floor(_num);
                double returnNum;
                if(mod > 0.5){
                    returnNum=(integer + 1) / ratio;
                }else if(mod < 0.5){
                    returnNum=integer / ratio;
                }else{
                    returnNum=(integer % 2 == 0 ? integer : integer + 1) / ratio;
                }
                BigDecimal bg = new BigDecimal(returnNum);
                result = bg.setScale((int)digit, BigDecimal.ROUND_HALF_UP).toString();
            } catch (RuntimeException e) {
                throw e;
            }
            return parent+result;
        }
        return result;
    }

    /**
     * 获取随机主键
     * @return
     */
    public static String getUUid(){
        UUID uuid=UUID.randomUUID();
        String str = uuid.toString();
        if(str.indexOf("-")>-1){
            str=str.replace("-","");
        }
        return str;
    }

    /**
     * 时间处理小时
     * @param time
     * @return
     */
    public static  String getHourTime(String time){
        if (StringUtils.isNotBlank(time)){
            time = time.replace("%20", " ");
        }
        return time;
    }

    /**
     * 度分秒转经纬度Java he
     * @param lng 116°16′22. 116度16分22秒 转 116.27277777777778
     * @return
     */
    public static String tranformPos(String lng){
        String longAndLa="";
        if (StringUtils.isBlank(lng)){
            lng=longAndLa;
        }
        if (lng.contains("度")&&lng.contains("分")){
            //116度16分22秒
            if (lng.contains("度")||lng.contains("分")||lng.contains("秒")){
                lng=lng.replace("度","°");
                lng=lng.replace("分","′");
                lng=lng.replace("秒",".");
            }
            String[] lntArr = lng
                    .trim()
                    .replace("°", ";")
                    .replace("′", ";")
                    .replace("'", ";")
                    .replace("\"", "")
                    .split(";");
            Double result = 0D;
            for (int i = lntArr.length; i >0 ; i--) {
                double v = Double.parseDouble(lntArr[i-1]);
                if(i==1){
                    result=v+result;
                }else{
                    result=(result+v)/60;
                }
            }
            longAndLa=result.toString();
        }else if (lng.contains("°")&&lng.contains("′")||lng.contains("‘")||lng.contains("’")){
            String[] lntArr = lng
                    .trim()
                    .replace("°", ";")
                    .replace("′", ";")
                    .replace("‘", ";")
                    .replace("'", ";")
                    .replace("’", ";")
                    .replace("“", "")
                    .replace("″", "")
                    .replace("”", "")
                    .replace("N", "")
                    .replace("E", "")
                    .replace("\"", "")
                    .split(";");
            Double result = 0D;
            for (int i = lntArr.length; i >0 ; i--) {
                double v = Double.parseDouble(lntArr[i-1]);
                if(i==1){
                    result=v+result;
                }else{
                    result=(result+v)/60;
                }
            }
            longAndLa=result.toString();
        }else {
            int lngCount = countStr(lng, ".");
            if (lng.contains("~")){
                if (lng.contains("113")||lng.contains("113")){
                    lng = getLngBuffer(lng, 3);
                }
                if (lng.contains("29")||lng.contains("30")){
                    lng = getLngBuffer(lng, 2);
                }
            }
            if(lngCount==2){
                lng =getLngLast(lng,".");
            }
            longAndLa=lng;
        }
        return longAndLa;
    }

    /**
     * 用与经纬度
     * String aa="113040~114012";
     * String bb="29048~30017";
     * @param lng
     * @param count  3或者2
     * @return
     */
    private static String getLngBuffer(String lng,Integer count){
        String[] split = lng.split("~");
        String lo=split[0];
        StringBuffer sb = new StringBuffer(lo);
        sb.insert(count,".");
        System.out.println(sb);
        return sb.toString();
    }

    /**
     * 判断字符串中某个字符存在的个数 1,2,3  转 1,23
     * @param ,   1,2,3
     * @param ,  转 1,23
     * @return
     */
    private  static  String getLngLast(String lng,String str){
        int i = lng.lastIndexOf(str);
        String start = lng.substring(0, i);
        String end = lng.substring(i + 1, lng.length());
        return start + end;
    }

    /**
     * 判断字符串中某个字符存在的个数
     * @param str1  完整字符串
     * @param str2  要统计匹配个数的字符
     * @return
     */
    public static int countStr(String str1, String str2) {
        int count=0;
        if (str1.indexOf(str2) == -1) {
            return 0;
        }
        while(str1.indexOf(str2)!=-1){
            count++;
            str1=str1.substring(str1.indexOf(str2)+str2.length());
        }
        return count;
    }

    /**
     * 去重对象空格  去除两边所有空格
     * @param obj
     */
    public static void objectToTrim(Object obj)  {
        Map<String,String> map = new HashMap<>();
        try {
            Field[] declaredFields = obj.getClass().getDeclaredFields();
            for (Field field:declaredFields){
                String type = field.getType().getCanonicalName();
                if (StringUtils.equals("java.lang.String", type)){
                    field.setAccessible(true);
                    Object object = field.get(obj);
                    if (object != null) {
                        //去重所有空格
                        map.put(field.getName(),replaceAllTrim(object.toString().trim()));
                    }
                }
            }
            for (Field field:declaredFields){
                if (map.get(field.getName())!=null){
                    String s = map.get(field.getName());
                    field.setAccessible(true);
                    field.set(obj,s);
                }
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 去除两边所有空格
     * @param str
     * @return
     */
    public static String replaceAllTrim(String str) {
        String s = "";
        if (StringUtils.isNotBlank(str)){

            //去重空格
            StringBuffer stringBuffer = new StringBuffer();
            for(int i=0;i<str.length();i++) {
                char c = str.charAt(i);
                if (Character.isSpaceChar(c)||c==' '){} else stringBuffer.append(c);
            }
            str = stringBuffer.toString();

            String trim = str.trim();
            String replaceStr = str.replaceAll(" ", "");
            Pattern p = Pattern.compile("\\s*|\t|\r|\n");
            /*\n 回车(\u000a)
            \t 水平制表符(\u0009)
            \s 空格(\u0008)
            \r 换行(\u000d)*/
            Matcher m = p.matcher(str);
            s = m.replaceAll("");
            if (replaceStr.length()!=s.length()){
                if (replaceStr.length()<s.length()){
                    s=replaceStr;
                }
            }
            if (trim.length()==s.length()){
                s=trim;
            }else {
                if (!s.equals("")){
                    String starts = s.substring(0, 1);
                    String end = s.substring(s.length()-1, s.length());
                    s=trim.substring(trim.indexOf(starts),trim.lastIndexOf(end)+1);
                }
            }
        }
        return s;
    }

    /**
     * 将list对象转list<map>
     * @param list
     * @return
     */
    public static List<Map<String, Object>> objectToListMap(List<?> list){

        List<Map<String, Object>> map=new ArrayList<>();
        if (!CollectionUtils.isEmpty(list)){
            map = list.stream().map(it -> {
                Map<String, Object> apiMap = new HashMap<>();
                Field[] declaredFields = it.getClass().getDeclaredFields();
                for (Field declaredField : declaredFields) {
                    String name = declaredField.getName();
                    try {
                        Field f = it.getClass().getDeclaredField(name);
                        f.setAccessible(true);
                        apiMap.put(name,f.get(it));
                    } catch (IllegalAccessException | NoSuchFieldException e) {
                        e.printStackTrace();
                    }
                }
                return apiMap;
            }).collect(Collectors.toList());
        }
        return map;
    }

    /**
     * 获取图片组入数据
     * @return
     */
    public static void getPathGroup(Object obj, String field,String path){
         if (StringUtils.isNotBlank(path)) {
             if (path.contains("group")) {
                 path = path.substring(path.indexOf("group"), path.length());
                 //设置值
                 try {
                     Class c = obj.getClass();
                     Field f = c.getDeclaredField(field);
                     f.setAccessible(true);
                     f.set(obj, path);
                 } catch (Exception e) {
                     System.out.println(e.getMessage());
                 }
             }
         }
    }

    /**
     * 求Map<K,V>中Value(值)的最小值
     *
     * @param map
     * @return
     */
    public static Object getMinValue(Map<Integer, Integer> map) {
        if (map == null)
            return null;
        Collection<Integer> c = map.values();
        Object[] obj = c.toArray();
        Arrays.sort(obj);
        return obj[0];
    }

    /**
     * 求Map<K,V>中Value(值)的最大值
     *
     * @param map
     * @return
     */
    public static Object getMaxValue(Map<Integer, Integer> map) {
        if (map == null)
            return null;
        int length =map.size();
        Collection<Integer> c = map.values();
        Object[] obj = c.toArray();
        Arrays.sort(obj);
        return obj[length-1];
    }

    /**
     *
     * @param value 需要科学计算的数据
     * @param digit 保留的小数位
     * @return 四舍六入计算法
     */
    private String setGiveSixIntoFour(Object value,int digit){
        String count="0";
        if (Objects.nonNull(value)){
            try {
                BigDecimal decimal = new BigDecimal(value.toString());
                if (decimal.compareTo(BigDecimal.ZERO)==0){
                }else {
                    BigDecimal i = decimal.setScale(2, RoundingMode.HALF_EVEN);
                    count=i.toString();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        return count;
    }

}
