package com.cool.store.utils;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;

public class MapUtil {
    public static <T> void setMapValue(Map<String, Object> hashMap, String name, T value) {
        if (value == null) {
            return;
        }
        hashMap.put(name, value);
    }

    public static <T> void setMapObjectValue(Map<String, Object> hashMap, T obj) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        if (obj == null) {
            return;
        }
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            String name = field.getName();
            String uName = name.substring(0, 1).toUpperCase() + name.substring(1);

            Method m = obj.getClass().getMethod("get" + uName);
            Object value = m.invoke(obj);
            if (value == null) {
                continue;
            }
            // 基础类型
            if (isBaseType(value)) {
                setMapValue(hashMap, name, value);
            } else if (value instanceof List) {
                if (((List) value).size() > 0) {
                    setMapObjectValue(hashMap, ((List) value).get(0));
                }
            } else {
                setMapObjectValue(hashMap, value);
            }
        }

    }

    public static boolean isBaseType(Object object) {
        Class className = object.getClass();
        return className.equals(Integer.class) ||
                className.equals(Byte.class) ||
                className.equals(Long.class) ||
                className.equals(Double.class) ||
                className.equals(Float.class) ||
                className.equals(Character.class) ||
                className.equals(Short.class) ||
                className.equals(Boolean.class) ||
                className.equals(String.class);
    }

    /**
     * 实体类对象转URL参
     * @param t 实体类对象
     * @param callSuper 是否转换父类成员
     * @param <T> 实体类泛型
     * @return a=1&b=2
     */
    public static <T> String entityToUrlParam(T t, boolean callSuper){
        // URL 参数存储器
        StringBuffer urlParam = new StringBuffer();
        //扩展转换父类成员功能
        entitySuperclassToUrlParam(t, t.getClass(),callSuper,urlParam);
        if(urlParam.length()>0){
            //去除最后一个&字符
            urlParam.deleteCharAt(urlParam.length() - 1);
        }
        return urlParam.toString();
    }

    public static <T> String entityToUrlParam(T t) {
        if (t == null) {
            return null;
        }
        return entityToUrlParam(t, true);
    }

    /**
     * 实体类对象转URL参
     * @param t 实体类对象
     * @param clazz 实体类类型
     * @param callSuper 是否转换父类成员
     * @param urlParam URL 参数存储器
     * @param <T> 实体类泛型
     * @return a=1&b=2
     */
    @Deprecated
    public static <T> void entitySuperclassToUrlParam(T t,Class clazz,boolean callSuper,StringBuffer urlParam){
        //如果实体类对象为Object类型，则不处理
        if(!clazz.equals(Object.class)) {
            //获取实体类对象下的所有成员，并保存到 URL 参数存储器中
            Arrays.stream(clazz.getDeclaredFields()).forEach(field -> {
                //设置可以操作私有成员
                field.setAccessible(true);
                try {
                    //获取成员值
                    Object value = field.get(t);
                    //成员值为 Null 时，则不处理
                    if (Objects.nonNull(value)) {
                        urlParam.append(field.getName()).append("=").append(value).append("&");
                    }
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            });
            //是否转换父类成员
            if(callSuper){
                //获取父类类型
                clazz = clazz.getSuperclass();
                //递归调用，获取父类的处理结果
                entitySuperclassToUrlParam(t,clazz,callSuper,urlParam);
            }
        }
    }
}
