package com.common.core.utils;


import com.common.annotation.DesensitiveInfo;
import com.common.core.domain.DesensitiveType;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.ReflectionUtils;

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.time.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Map;

/**
 * @description: 脱敏工具类
 * @author: holden
 * @time: 2022-01-20 09:10
 */
public class DesensitiveUtils {

    private DesensitiveUtils() {
    }

    /**
     * 扫描方法注解，脱敏
     *
     * @param obj
     */
    public static void format(Object obj) {
        DesensitiveUtils.formatMethod(obj);
    }

    /**
     *  判断对象类型，进行分类处理
     *
     * @param obj   需要反射对象
     */
    private static void formatMethod(Object obj) {
        if (obj == null || isPrimitive(obj.getClass())) {
            return;
        }
        if (obj.getClass().isArray()) {
            for (Object object : (Object[]) obj) {
                formatMethod(object);
            }
        } else if (Collection.class.isAssignableFrom(obj.getClass())) {
            for (Object o : ((Collection) obj)) {
                formatMethod(o);
            }
        } else if (Map.class.isAssignableFrom(obj.getClass())) {
            for (Object o : ((Map) obj).values()) {
                formatMethod(o);
            }
        } else {
            objFormat(obj);
        }
    }

    /**
     * 只有对象才格式化数据
     *
     * @param obj
     */
    private static void objFormat(Object obj) {
        for (Field field : obj.getClass().getDeclaredFields()) {
            if (isPrimitive(field.getType())||field.getType().isArray()) {
                fieldSetSensitiveValue(obj, field);
            }else{
                //对象类型进行下一级处理
                ReflectionUtils.makeAccessible(field);
                Object fieldValue = ReflectionUtils.getField(field, obj);
                if (fieldValue != null) {
                    formatMethod(fieldValue);
                }
            }
        }
    }

    /**
     * 进行脱敏处理的方法
     * @param obj
     * @param field
     */
    private static void fieldSetSensitiveValue(Object obj, Field field)  {
        DesensitiveInfo annotation = field.getAnnotation(DesensitiveInfo.class);
        if (annotation!=null){
            ReflectionUtils.makeAccessible(field);
            Object fieldValue = ReflectionUtils.getField(field, obj);
            String padStr = annotation.padStr();
            DesensitiveType type = annotation.value();
            Integer padSize = type.getPadSize();
            if (fieldValue!=null && !"".equals(fieldValue.toString())){
                if(DesensitiveType.EMAIL.name().equals(type.name())){
                    if(String.class.isAssignableFrom(field.getType())) {
                        ReflectionUtils.setField(field, obj, generatePad(padSize, padStr) + "@company.com");
                    }
                    if(field.getType().isArray()){
                        ArrayList<String> list=new ArrayList();
                        for (String s : (String[])fieldValue) {
                            // 对空字符原样处理
                            if(s==null || s.isEmpty()){
                                list.add(s);
                            }else {
                                list.add(generatePad(padSize, padStr) + "@company.com");
                            }
                        }
                        ReflectionUtils.setField(field, obj, list.toArray(new String[0]));
                    }
                }else {
                    if(String.class.isAssignableFrom(field.getType())) {
                        ReflectionUtils.setField(field, obj, generatePad(padSize, padStr));
                    }
                    if(field.getType().isArray()){
                        ArrayList<String> list=new ArrayList();
                        for (String s : (String[])fieldValue) {
                            // 对空字符原样处理
                            if(s==null || s.isEmpty()){
                                list.add(s);
                            }else {
                                list.add(generatePad(padSize, padStr));
                            }
                        }
                        ReflectionUtils.setField(field, obj, list.toArray(new String[0]));
                    }
                }
            }
//            else{
//                if(DesensitiveType.EMAIL.name().equals(type.name())){
//                    if(String.class.isAssignableFrom(field.getType())) {
//                        ReflectionUtils.setField(field, obj, generatePad(padSize, padStr) + "@company.com");
//                    }
//                    if(field.getType().isArray()){
//                        ArrayList<String> list=new ArrayList();
//                        list.add(generatePad(padSize, padStr) + "@company.com");
//                        ReflectionUtils.setField(field, obj, list.toArray(new String[0]));
//                    }
//                }else {
//                    if(String.class.isAssignableFrom(field.getType())) {
//                        ReflectionUtils.setField(field, obj, generatePad(padSize, padStr));
//                    }
//                    if(field.getType().isArray()){
//                        ArrayList<String> list=new ArrayList();
//                        list.add(generatePad(padSize, padStr));
//                        ReflectionUtils.setField(field, obj, list.toArray(new String[0]));
//                    }
//                }
//            }
        }
    }

    public static String getFieldDesensitive(Object t, Field field){
        DesensitiveInfo annotation = field.getAnnotation(DesensitiveInfo.class);
        if (annotation!=null){
            DesensitiveType type = annotation.value();
            String padStr = annotation.padStr();
            Integer padSize = type.getPadSize();
            return generatePad(padSize, padStr);
        }
        return null;
    }


    public static String getFieldDesensitive(DesensitiveType field){
        String padStr = "*";
        Integer padSize = field.getPadSize();
        if(DesensitiveType.EMAIL.name().equals(field.name())) {
            return generatePad(padSize, padStr)+"@company.com";
        }else{
            return generatePad(padSize, padStr);
        }
    }

    public static String getFieldDesensitive(Object t, DesensitiveType field){
        if(null == t || "".equals(t.toString())){
            return "";
        }
        String padStr = "*";
        Integer padSize = field.getPadSize();
        if(DesensitiveType.EMAIL.name().equals(field.name())) {
            return generatePad(padSize, padStr)+"@company.com";
        }else{
            return generatePad(padSize, padStr);
        }
    }

    public static String generatePad(Integer padSize,String pad){
        String padstr = "";
        for(int i = 0; i < padSize; i++){
            padstr += pad;
        }
        return padstr;
    }

    /**
     * 基本数据类型和String类型判断
     *
     * @param clz
     * @return
     */
    public static boolean isPrimitive(Class<?> clz) {
        try {
            if (String.class.isAssignableFrom(clz) || Date.class.isAssignableFrom(clz)|| BigDecimal.class.isAssignableFrom(clz) || LocalDateTime.class.isAssignableFrom(clz)
                    || LocalDate.class.isAssignableFrom(clz)  || LocalTime.class.isAssignableFrom(clz)  || Year.class.isAssignableFrom(clz)
                    || YearMonth.class.isAssignableFrom(clz)  || Month.class.isAssignableFrom(clz) || clz.isPrimitive()) {
                return true;
            } else {
                return ((Class) clz.getField("TYPE").get(null)).isPrimitive();
            }
        } catch (Exception e) {
            return false;
        }
    }

}