package com.hikvision.building.cloud.neptune.community.biz.Utils;

import java.io.IOException;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JSONUtil {

    private static Logger logger = LoggerFactory.getLogger(JSONUtil.class);
    private static ObjectMapper objectMapper = new ObjectMapper();

    static {
        // 排除值为空属性
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        // 转换成对象时，没有属性的处理，忽略掉
        objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

        // 进行缩进输出
        // configure(SerializationFeature.INDENT_OUTPUT,true);
        // 进行日期格式化
        // if (dateFormatPattern != null) {
        // DateFormat dateFormat = new SimpleDateFormat(dateFormatPattern);
        // objectMapper.setDateFormat(dateFormat);
        // }
    }

    /**
     * 将 POJO 对象转为 JSON 字符串
     */
    public static <T> String toJson(T pojo) {
        try {
            return objectMapper.writeValueAsString(pojo);
        } catch (Exception e) {
            logger.error("toJson Failed.",e);
            throw new RuntimeException("转换json格式异常");
        }
    }

    /**
     * 将 JSON 字符串转为 POJO 对象
     */
    public static <T> T fromJson(String json,Class<T> type) {
        try {
            return objectMapper.readValue(json,type);
        } catch (Exception e) {
            logger.error("fromJson Failed.",e);
            throw new RuntimeException("json格式错误" + json);
        }
    }

    /**
     * JSON串转换为Java泛型对象，可以是各种类型，此方法最为强大。用法看测试用例。
     * 
     * @param <T>
     * @param jsonString
     *            JSON字符串
     * @param tr
     *            TypeReference,例如: new TypeReference< List<FamousUser> >(){}
     * @return List对象列表
     */
    public static <T> T toCollection(String jsonStr,TypeReference<T> typeReference) {
        try {
            return objectMapper.readValue(jsonStr,typeReference);
        } catch (Exception e) {
            logger.error("toCollection Failed.",e);
            throw new RuntimeException("json格式错误" + jsonStr);
        }
    }

    public static Map<?,?> json2map(String jsonStr) {
        if (jsonStr == null) {
            throw new RuntimeException("jsonStr is null");
        }
        try {
            return objectMapper.readValue(jsonStr,Map.class);
        } catch (Exception e) {
            logger.error("json2map Failed.",e);
            throw new RuntimeException("json格式错误" + jsonStr);
        }
    }

    public static <T> T map2pojo(Map<?,?> map,Class<T> clazz) {
        return objectMapper.convertValue(map,clazz);
    }

    public static String object2Json(Object obj) {
        if (obj == null) {
            logger.error("obj is null.");
            throw new RuntimeException("入参错误");
        }
        try {
            return objectMapper.writeValueAsString(obj);
        } catch (IOException e) {
            logger.error("object2Json Failed.",e);
            throw new RuntimeException("转换json格式异常");
        }
    }
}