package utils;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 *
 * @author Administrator
 */
public class JSONUtil {

    /**
     * 字段过滤模式
     */
    public static final int INCLUDE = 0;
    public static final int REMOVE = 1;
    private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    /**
     *
     * @param <T>
     * @param o
     * @param maxLength 如果是String型，字符串的最大截取长度
     * @param createSub 如果是集合，那么集合中的子对象是否也生成json字串
     * @param Map<String, List<String&rt;&rt; filterMap :对指定的类进行字段的过滤
     * @param pattern 字段过滤模式：0(NOT)-只考虑已经列出的字段，1(REMOVE)-去除已经列出的字段
     * @return
     */
    public static <T> String toJSON(T o, int maxLength, boolean createSub, Map<String, String> filterMap, int pattern) {
        if (o == null) {
            return "null";
        }
        return toJSONx(o, o.getClass(), maxLength, createSub, filterMap, pattern, null);
    }

    public static <T> String toJSON(T o) {
        return JSONUtil.toJSON(o, 0, false, null, 0);
    }

    public static <T> String toJSON(T o, int maxLength) {
        return JSONUtil.toJSON(o, maxLength, false, null, 0);
    }

    /**
     *
     * @param <T>
     * @param o 要转为json的对象
     * @param clazz o的类型，关键时刻，用于强制转换o的类型T为V
     * @param maxLength
     * @param createSub
     * @param filterMap
     * @param pattern
     * @param olist 存储已经处理过的对象，在list中的索引越高，层级越深
     * @return
     */
    private static <T> String toJSONx(T o, Class clazz, int maxLength, boolean createSub, Map<String, String> filterMap, int pattern, List<Object> olist) {
        String s = "";
        String c = "";
        try {
            if (o != null) {
                /**
                 * 不知道是何种类型的，利用反射得到元素，但是防止循环引用，此处做一次检查，
                 * 有个缺陷，如果元素对相同对象引用两次，则只会自动转为不考虑下级对象模式，防止死循环
                 */
                olist = olist == null ? (new ArrayList<Object>()) : olist;
                for (Object vo : olist) {
                    if (vo == o) {
                        createSub = false;
                        S.p("-----(toJSONx)已爬取过,再爬取一次, 但不再考虑下级");
                        break;
                    } else {
                        olist.add(o);
                    }
                }

                c = o.getClass().getName();

                //检查各种类型情况
                if (String.class.getName().equals(c)) {
                    return S.addDoubleQuot(maxLength > 0 ? S.left(o + "", maxLength) : (o + ""));
                } else if (o instanceof Number
                        || Boolean.class.getName().equals(c)
                        || boolean.class.getName().equals(c)) {
                    return o + "";
                } else if (o instanceof Date) {
                    return S.addDoubleQuot(sdf.format((Date) o));
                } else if (o instanceof Collection) {
                    s += "[";
                    int k = 0;
                    for (Object oo : (Collection) o) {
                        if (createSub) {
                            if (k++ > 0) {
                                s += ", ";
                            }
                            s += toJSONx(oo, oo.getClass(), maxLength, createSub, filterMap, pattern, olist);
                        } else {
                            s += getJsonString(oo, maxLength);
                        }
                    }
                    s += "]";

                } else if (Map.class.getName().equals(c) || HashMap.class.getName().equals(c)) {
                    s += "{";
                    int k = 0;
                    Map map = (HashMap