package com.lunhan.xxx.common.util;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.dataformat.xml.PackageVersion;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.lunhan.xxx.common.serializer.*;
import com.lunhan.xxx.common.serializer.deserializer.*;

import java.io.IOException;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.*;

/**
 * json/XML处理类
 * @author linliu
 * @date   2018-12-28
 */
public final class SerializeUtil {
    private SerializeUtil() {
        throw new IllegalStateException("Utility class");
    }

    //region 字符串常量
    private static final String TITLE = "SerializeUtil";
    //endregion

    private static final ObjectMapper JSON_MAPPER = new ObjectMapper();
    private static final XmlMapper XML_MAPPER = new XmlMapper();

    static {
        //忽略字段大小写
        XML_MAPPER.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);
        //忽略字段数量不一致
        XML_MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        //默认json序列化设置
        SerializeUtil.initSerializationConfigure(JSON_MAPPER);
    }
    /**
     * 默认json序列化设置
     * @param JSON_MAPPER mapper实例
     */
    private static void initSerializationConfigure(ObjectMapper JSON_MAPPER) {
        //忽略字段大小写
        JSON_MAPPER.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);

        //此配置反序列化的时候如果多了属性, 不抛出异常。不设置这个json字符串只能少属性，不能多属性，否者会抛异常
        JSON_MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        //如果是空对象的时候,不抛异常
        JSON_MAPPER.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);

        //******************************* 处理日期类型序列化和反序列化 *******************************

        //取消时间的转化格式,默认是时间戳,可以取消,同时需要设置要表现的时间格式
        JSON_MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);

        SimpleModule serializerModule = new SimpleModule("CQDateTimeSerializer", PackageVersion.VERSION);

        serializerModule.addSerializer(Date.class, new CQDateSerializer());
        serializerModule.addDeserializer(Date.class, new CQDateDeSerializer());

        serializerModule.addSerializer(Calendar.class, new CQCalendarSerializer());
        serializerModule.addDeserializer(Calendar.class, new CQCalendarDeSerializer());

        serializerModule.addSerializer(LocalDate.class, new CQLocalDateSerializer());
        serializerModule.addDeserializer(LocalDate.class, new CQLocalDateDeSerializer());

        serializerModule.addSerializer(LocalDateTime.class, new CQLocalDateTimeSerializer());
        serializerModule.addDeserializer(LocalDateTime.class, new CQLocalDateTimeDeSerializer());

        serializerModule.addSerializer(Timestamp.class, new CQTimestampSerializer());
        serializerModule.addDeserializer(Timestamp.class, new CQTimestampDeSerializer());

        JSON_MAPPER.registerModule(serializerModule);
        //******************************* 处理日期类型序列化和反序列化 *******************************

        /*

        //序列化的时候序列对象的所有属性
        JSON_MAPPER.setSerializationInclusion(JsonInclude.Include.ALWAYS);

        */
    }

    /**
     * json字符串转 T 类型实体
     * @param json json字符串
     * @param clazz 实体类型
     * @param <T> 实体类型
     */
    public static <T> T toObject(String json, Class<T> clazz) {
        if(StringUtil.isNullOrEmpty(json)){
            return null;
        }
        try {
            if(Objects.equals(clazz, JsonObject.class)) {
                JsonParser jsonParser = new JsonParser();
                return (T)jsonParser.parse(json).getAsJsonObject();
            }
            return JSON_MAPPER.readValue(json, clazz);
        } catch (IOException e) {
            //TODO log
            throw new RuntimeException(e);
        }
    }

    /**
     * json字符串转 List→T 类型集合
     * @param json json字符串
     * @param clazz 实体类型
     * @param <T> 实体类型
     */
    public static <T> List<T> toListObject(String json, Class<T> clazz){
        if(StringUtil.isNullOrEmpty(json)){
            return new ArrayList<>();
        }
        try{
            //这种返回的是List<LinkedMap>
            //return JSON_MAPPER.readValue(json, new TypeReference<List<T>>() {});
            return SerializeUtil.toObject(json, List.class, clazz);
        } catch (Exception e) {
            //TODO log
            throw new RuntimeException(e);
        }
    }

    /**
     * json字符串转 T 类型实体
     * @param json json字符串
     * @param genericClass 实体类型
     * @param clazz 实体类型
     * @param <T> 实体类型
     */
    public static <T> T toObject(String json, Class<?> genericClass, Class<?> clazz) {
        if(StringUtil.isNullOrEmpty(json)){
            return null;
        }
        try {
            JavaType type = JSON_MAPPER.getTypeFactory().constructParametricType(genericClass, clazz);
            return JSON_MAPPER.readValue(json, type);
        } catch (IOException e) {
            //TODO log
            throw new RuntimeException(e);
        }
    }

    public static String toJson(Object obj) {
        if(obj==null){
            return null;
        }
        try {
            if(obj instanceof JsonObject || obj instanceof JsonArray) {
                return obj.toString();
            } else {
                return JSON_MAPPER.writeValueAsString(obj);
            }
        } catch (Exception e) {
            //TODO log
            throw new RuntimeException(e);
        }
    }
    public static String toJsonWithoutNull(Object obj) {
        if(obj==null){
            return null;
        }
        try {
            if (obj instanceof JsonObject || obj instanceof JsonArray) {
                return obj.toString();
            } else {
                ObjectMapper mapper = new ObjectMapper();
                //默认json序列化设置
                SerializeUtil.initSerializationConfigure(mapper);
                mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
                return mapper.writeValueAsString(obj);
            }
        } catch (Exception e) {
            //TODO log
            throw new RuntimeException(e);
        }
    }

    public static String toCSharpJson(Object obj) {
        if(obj==null){
            return null;
        }
        try {
            if (obj instanceof JsonObject || obj instanceof JsonArray) {
                return obj.toString();
            } else {
                ObjectMapper mapper = new ObjectMapper();
                //默认json序列化设置
                SerializeUtil.initSerializationConfigure(mapper);
                // deprecated  mapper.setPropertyNamingStrategy(PropertyNamingStrategy.CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES);
                mapper.setPropertyNamingStrategy(PropertyNamingStrategy.UPPER_CAMEL_CASE);
                return mapper.writeValueAsString(obj);
            }
        } catch (Exception e) {
            //TODO log
            throw new RuntimeException(e);
        }
    }

    public static String toJson(Object obj, String dateFormat) {
        if(obj==null){
            return null;
        }
        try {
            if (obj instanceof JsonObject || obj instanceof JsonArray) {
                return obj.toString();
            } else {
                ObjectMapper mapper = new ObjectMapper();
                //默认json序列化设置
                SerializeUtil.initSerializationConfigure(mapper);
                mapper.setDateFormat(new SimpleDateFormat(dateFormat));
                return mapper.writeValueAsString(obj);
            }
        } catch (Exception e) {
            //TODO log
            throw new RuntimeException(e);
        }
    }

    public static <T> T fromXml(String xml, Class<T> clazz) {
        if(StringUtil.isNullOrEmpty(xml)){
            return null;
        }
        try {
            return XML_MAPPER.readValue(xml, clazz);
        } catch (Exception e) {
            //TODO log
            throw new RuntimeException(e);
        }
    }

    public static <T> T fromXml(String xml, Class<?> genericClass, Class<?> clazz) {
        if(StringUtil.isNullOrEmpty(xml)){
            return null;
        }
        try {
            JavaType type = XML_MAPPER.getTypeFactory().constructParametricType(genericClass, clazz);
            return XML_MAPPER.readValue(xml, type);
        } catch (Exception e) {
            //TODO log
            throw new RuntimeException(e);
        }
    }

    public static String toXml(Object obj) {
        if(obj == null){
            return "";
        }
        try{
            return XML_MAPPER.writeValueAsString(obj);
        } catch (Exception e) {
            //TODO log
            throw new RuntimeException(e);
        }
    }

    public static JsonObject toJSONObject(Object obj) {
        if(null==obj) {
            return null;
        }
        try {
            String json = new Gson().toJson(obj);
            return new JsonParser().parse(json).getAsJsonObject();
        } catch (Exception e) {
            //TODO log
            throw new RuntimeException(e);
        }
    }
}