/**
 * wzy扩展
 *
 * @param input
 * @param value
 * @param config
 * @param processor
 * @param featureValues
 * @param features
 */
private static void reflectObject(String input, Object value, ParserConfig config, ParseProcess processor,
		int featureValues, Feature... features) {
	if (input == null) {
		return;
	}
	for (Feature featrue : features) {
		featureValues = Feature.config(featureValues, featrue, true);
	}

	DefaultJSONParser parser = new DefaultJSONParser(input, config, featureValues);

	if (processor instanceof ExtraTypeProvider) {
		parser.getExtraTypeProviders().add((ExtraTypeProvider) processor);
	}

	if (processor instanceof ExtraProcessor) {
		parser.getExtraProcessors().add((ExtraProcessor) processor);
	}
	parser.parseObject(value);
	parser.handleResovleTask(value);
	parser.close();
}
 

public static void main(String[] args) {
	TestFastJson entity=new TestFastJson();
	JSONObject json=new JSONObject();
	JSONArray list=new JSONArray();
	list.add(1);
	json.put("1", 1);
	json.put("list",list);
	entity.setJson(json);
	String jsonStr=JSON.toJSONString(entity);
	System.out.println(jsonStr);
	entity=JSONObject.parseObject(jsonStr,TestFastJson.class);
	System.out.println(entity);
	//反序列化
	DefaultJSONParser jp=new DefaultJSONParser(jsonStr);
	JSONObject json2=jp.parseObject();
	System.out.println("id："+json2.getIntValue("id"));
	//类型反序列化
	Type type=new TypeReference<TestFastJson>() {
	}.getType();
	TestFastJson entity2=JSON.parseObject(jsonStr, type);
	System.out.println(entity2.getId());
}
 

@SuppressWarnings("rawtypes")
@Override
public void parseField(DefaultJSONParser parser, Object object, Type objectType, Map<String, Object> fieldValues) {
    JSONLexer lexer = parser.lexer;
    final int token = lexer.token();
    if (token == JSONToken.NULL
            || (token == JSONToken.LITERAL_STRING && lexer.stringVal().length() == 0)) {
        setValue(object, null);
        return;
    }

    ArrayList list = new ArrayList();

    ParseContext context = parser.getContext();

    parser.setContext(context, object, fieldInfo.name);
    parseArray(parser, objectType, list);
    parser.setContext(context);

    if (object == null) {
        fieldValues.put(fieldInfo.name, list);
    } else {
        setValue(object, list);
    }
}
 

private void _createInstance(Context context, MethodVisitor mw) {
    JavaBeanInfo beanInfo = context.beanInfo;
    Constructor<?> defaultConstructor = beanInfo.defaultConstructor;
    if (Modifier.isPublic(defaultConstructor.getModifiers())) {
        mw.visitTypeInsn(NEW, type(context.getInstClass()));
        mw.visitInsn(DUP);

        mw.visitMethodInsn(INVOKESPECIAL, type(defaultConstructor.getDeclaringClass()), "<init>", "()V");

        mw.visitVarInsn(ASTORE, context.var("instance"));
    } else {
        mw.visitVarInsn(ALOAD, 0);
        mw.visitVarInsn(ALOAD, 1);
        mw.visitVarInsn(ALOAD, 0);
        mw.visitFieldInsn(GETFIELD, type(JavaBeanDeserializer.class), "clazz", "Ljava/lang/Class;");
        mw.visitMethodInsn(INVOKESPECIAL, type(JavaBeanDeserializer.class), "createInstance",
                           "(L" + DefaultJSONParser + ";Ljava/lang/reflect/Type;)Ljava/lang/Object;");
        mw.visitTypeInsn(CHECKCAST, type(context.getInstClass())); // cast
        mw.visitVarInsn(ASTORE, context.var("instance"));
    }
}
 

private void _getCollectionFieldItemDeser(Context context, MethodVisitor mw, FieldInfo fieldInfo,
                                          Class<?> itemType) {
    Label notNull_ = new Label();
    mw.visitVarInsn(ALOAD, 0);
    mw.visitFieldInsn(GETFIELD, context.className, fieldInfo.name + "_asm_list_item_deser__",
                      desc(ObjectDeserializer.class));
    mw.visitJumpInsn(IFNONNULL, notNull_);

    mw.visitVarInsn(ALOAD, 0);

    mw.visitVarInsn(ALOAD, 1);
    mw.visitMethodInsn(INVOKEVIRTUAL, DefaultJSONParser, "getConfig", "()" + desc(ParserConfig.class));
    mw.visitLdcInsn(com.alibaba.fastjson.asm.Type.getType(desc(itemType)));
    mw.visitMethodInsn(INVOKEVIRTUAL, type(ParserConfig.class), "getDeserializer",
                       "(Ljava/lang/reflect/Type;)" + desc(ObjectDeserializer.class));

    mw.visitFieldInsn(PUTFIELD, context.className, fieldInfo.name + "_asm_list_item_deser__",
                      desc(ObjectDeserializer.class));

    mw.visitLabel(notNull_);
    mw.visitVarInsn(ALOAD, 0);
    mw.visitFieldInsn(GETFIELD, context.className, fieldInfo.name + "_asm_list_item_deser__",
                      desc(ObjectDeserializer.class));
}
 

private void _getFieldDeser(Context context, MethodVisitor mw, FieldInfo fieldInfo) {
    Label notNull_ = new Label();
    mw.visitVarInsn(ALOAD, 0);
    mw.visitFieldInsn(GETFIELD, context.className, fieldInfo.name + "_asm_deser__", desc(ObjectDeserializer.class));
    mw.visitJumpInsn(IFNONNULL, notNull_);

    mw.visitVarInsn(ALOAD, 0);

    mw.visitVarInsn(ALOAD, 1);
    mw.visitMethodInsn(INVOKEVIRTUAL, DefaultJSONParser, "getConfig", "()" + desc(ParserConfig.class));
    mw.visitLdcInsn(com.alibaba.fastjson.asm.Type.getType(desc(fieldInfo.fieldClass)));
    mw.visitMethodInsn(INVOKEVIRTUAL, type(ParserConfig.class), "getDeserializer",
                       "(Ljava/lang/reflect/Type;)" + desc(ObjectDeserializer.class));

    mw.visitFieldInsn(PUTFIELD, context.className, fieldInfo.name + "_asm_deser__", desc(ObjectDeserializer.class));

    mw.visitLabel(notNull_);

    mw.visitVarInsn(ALOAD, 0);
    mw.visitFieldInsn(GETFIELD, context.className, fieldInfo.name + "_asm_deser__", desc(ObjectDeserializer.class));
}
 

private void _createInstance(ClassWriter cw, Context context) {
    Constructor<?> defaultConstructor = context.beanInfo.defaultConstructor;
    if (!Modifier.isPublic(defaultConstructor.getModifiers())) {
        return;
    }
    
    MethodVisitor mw = new MethodWriter(cw, ACC_PUBLIC, "createInstance",
                                        "(L" + DefaultJSONParser + ";Ljava/lang/reflect/Type;)Ljava/lang/Object;",
                                        null, null);

    mw.visitTypeInsn(NEW, type(context.getInstClass()));
    mw.visitInsn(DUP);
    mw.visitMethodInsn(INVOKESPECIAL, type(context.getInstClass()), "<init>", "()V");

    mw.visitInsn(ARETURN);
    mw.visitMaxs(3, 3);
    mw.visitEnd();
}
 

@SuppressWarnings("unchecked")
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
    Object value = DateCodec.instance.deserialze(parser, type, fieldName);

    if (value instanceof Calendar) {
        return (T) value;
    }

    Date date = (Date) value;
    if (date == null) {
        return null;
    }

    JSONLexer lexer = parser.lexer;
    Calendar calendar = Calendar.getInstance(lexer.getTimeZone(), lexer.getLocale());
    calendar.setTime(date);

    if (type == XMLGregorianCalendar.class) {
        return (T) createXMLGregorianCalendar((GregorianCalendar) calendar);
    }

    return (T) calendar;
}
 

public void extract(JSONPath path, DefaultJSONParser parser, Context context) {
    if (context.eval) {
        Object object = parser.parse();
        if (object instanceof List) {
            int[] indexes = new int[this.indexes.length];
            System.arraycopy(this.indexes, 0, indexes, 0, indexes.length);
            boolean noneNegative = indexes[0] >= 0;

            List list = (List) object;
            if (noneNegative) {
                for (int i = list.size() - 1; i >= 0; i--) {
                    if (Arrays.binarySearch(indexes, i) < 0) {
                        list.remove(i);
                    }
                }
                context.object = list;
                return;
            }
        }
    }
    throw new UnsupportedOperationException();
}
 

@SuppressWarnings("unchecked")
public static <T> T deserialze(DefaultJSONParser parser) {
    final JSONLexer lexer = parser.lexer;
    if (lexer.token() == JSONToken.LITERAL_INT) {
        BigDecimal decimalValue = lexer.decimalValue();
        lexer.nextToken(JSONToken.COMMA);
        return (T) decimalValue;
    }

    if (lexer.token() == JSONToken.LITERAL_FLOAT) {
        BigDecimal val = lexer.decimalValue();
        lexer.nextToken(JSONToken.COMMA);
        return (T) val;
    }

    Object value = parser.parse();
    return value == null //
        ? null //
        : (T) TypeUtils.castToBigDecimal(value);
}
 

@SuppressWarnings({ "unchecked", "rawtypes" })
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
    if (parser.lexer.token() == JSONToken.NULL) {
        parser.lexer.nextToken(JSONToken.COMMA);
        return null;
    }
    
    if (type == JSONArray.class) {
        JSONArray array = new JSONArray();
        parser.parseArray(array);
        return (T) array;
    }

    Collection list = TypeUtils.createCollection(type);

    Type itemType = TypeUtils.getCollectionItemType(type);
    parser.parseArray(itemType, list, fieldName);

    return (T) list;
}
 

@SuppressWarnings({ "unchecked", "rawtypes" })
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
    ParameterizedType paramType = (ParameterizedType) type;
    Type itemType = paramType.getActualTypeArguments()[0];

    Object itemObject = parser.parseObject(itemType);

    Type rawType = paramType.getRawType();
    if (rawType == AtomicReference.class) {
        return (T) new AtomicReference(itemObject);
    }

    if (rawType == WeakReference.class) {
        return (T) new WeakReference(itemObject);
    }

    if (rawType == SoftReference.class) {
        return (T) new SoftReference(itemObject);
    }

    throw new UnsupportedOperationException(rawType.toString());
}
 

@SuppressWarnings("unchecked")
public static <T> T parseObject(String input, Type clazz, int featureValues, Feature... features) {
    if (input == null) {
        return null;
    }

    for (Feature feature : features) {
        featureValues = Feature.config(featureValues, feature, true);
    }

    DefaultJSONParser parser = new DefaultJSONParser(input, ParserConfig.getGlobalInstance(), featureValues);
    T value = (T) parser.parseObject(clazz);

    parser.handleResovleTask(value);

    parser.close();

    return (T) value;
}
 

@SuppressWarnings("unchecked")
public static <T> T parseObject(char[] input, int length, Type clazz, Feature... features) {
    if (input == null || input.length == 0) {
        return null;
    }

    int featureValues = DEFAULT_PARSER_FEATURE;
    for (Feature feature : features) {
        featureValues = Feature.config(featureValues, feature, true);
    }

    DefaultJSONParser parser = new DefaultJSONParser(input, length, ParserConfig.getGlobalInstance(), featureValues);
    T value = (T) parser.parseObject(clazz);

    parser.handleResovleTask(value);

    parser.close();

    return (T) value;
}
 

public static JSONArray parseArray(String text) {
    if (text == null) {
        return null;
    }

    DefaultJSONParser parser = new DefaultJSONParser(text, ParserConfig.getGlobalInstance());

    JSONArray array;

    JSONLexer lexer = parser.lexer;
    if (lexer.token() == JSONToken.NULL) {
        lexer.nextToken();
        array = null;
    } else if (lexer.token() == JSONToken.EOF) {
        array = null;
    } else {
        array = new JSONArray();
        parser.parseArray(array);

        parser.handleResovleTask(array);
    }

    parser.close();

    return array;
}
 

public static List<Object> parseArray(String text, Type[] types) {
    if (text == null) {
        return null;
    }

    List<Object> list;

    DefaultJSONParser parser = new DefaultJSONParser(text, ParserConfig.getGlobalInstance());
    Object[] objectArray = parser.parseArray(types);
    if (objectArray == null) {
        list = null;
    } else {
        list = Arrays.asList(objectArray);
    }

    parser.handleResovleTask(list);

    parser.close();

    return list;
}
 

@SuppressWarnings({ "unchecked"})
    public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {

    	if (parser.getLexer().token() == JSONToken.NULL) {
            parser.getLexer().nextToken(JSONToken.COMMA);
            return null;
        }
        String input = parser.getInput();
//        final String inputValue = input.replaceAll("\\{.+list:\\[(.++)\\]\\}", "$1");
//        ReflectionUtil.setField(ReflectionUtil.findField(parser.getClass(), "input"), parser,inputValue );
        Page<T> list = null;
        if (null==parser.getInput()||"null".equals(input)) {
			return null;
		}
        JSONObject jo = parser.parseObject();
        JSONArray ja = jo.getJSONArray("list");
        if (ja!=null) {
            List<T> vList = (List<T>) ja;
			list = new Page<>();
			list.addAll(vList);
	        list.setTotal(jo.getIntValue("total"));
		}

        return (T) list;
    }
 

@Override
public <T> T deserialze(DefaultJSONParser defaultJSONParser, Type type, Object o) {
    JSONObject object = JSONObject.parseObject(defaultJSONParser.getInput());
    if (null != o && o.equals("releaseDate")) {
        return (T) DateUtil.parse(object.get(o));
    }
    return (T) object.get(o);
}
 

@Override
public <T> T deserialze(final DefaultJSONParser parser, final Type type, final Object fieldName) {
    JSONLexer lexer = parser.getLexer();
    switch (lexer.token()) {
        case JSONToken.NULL:
            lexer.nextToken();
            return null;
        case JSONToken.LBRACE:
            return (T) parse(parser, lexer);
        default:
            return null;
    }
}
 

/**
 * @since 1.2.51
 * @param json
 * @param path
 * @return
 */
public static Object extract(String json, String path, ParserConfig config, int features, Feature... optionFeatures) {
    features |= Feature.OrderedField.mask;
    DefaultJSONParser parser = new DefaultJSONParser(json, config, features);
    JSONPath jsonPath = compile(path);
    Object result = jsonPath.extract(parser);
    parser.lexer.close();
    return result;
}
 

/**
 * 解析应答
 *
 * @param parser 解析器
 * @param lexer  文法
 * @return 应答
 */
protected ResponsePayload parse(final DefaultJSONParser parser, final JSONLexer lexer) {
    ResponsePayload payload = new ResponsePayload();
    String key;
    int token;
    try {
        String typeName = null;
        for (; ; ) {
            // lexer.scanSymbol
            key = lexer.scanSymbol(parser.getSymbolTable());
            if (key == null) {
                token = lexer.token();
                if (token == JSONToken.RBRACE) {
                    lexer.nextToken(JSONToken.COMMA);
                    break;
                } else if (token == JSONToken.COMMA) {
                    if (lexer.isEnabled(Feature.AllowArbitraryCommas)) {
                        continue;
                    }
                }
            }
            lexer.nextTokenWithColon(JSONToken.LITERAL_STRING);
            if (RES_CLASS.equals(key)) {
                typeName = parseString(lexer, RES_CLASS, false);
            } else if (RESPONSE.equals(key)) {
                payload.setResponse(parseResponse(parser, lexer, typeName));
            } else if (EXCEPTION.equals(key)) {
                payload.setException((Throwable) parseObject(parser, lexer, getThrowableType(typeName)));
            }
            if (lexer.token() == JSONToken.RBRACE) {
                lexer.nextToken(JSONToken.COMMA);
                break;
            }
        }
        return payload;
    } catch (ClassNotFoundException e) {
        throw new SerializerException(e.getMessage());
    }
}
 

/**
 * 解析应答
 *
 * @param parser   解析器
 * @param lexer    文法
 * @param typeName 名称
 * @return 应答对象
 */
protected Object parseResponse(final DefaultJSONParser parser, final JSONLexer lexer, final String typeName) {
    if (typeName == null || typeName.isEmpty()) {
        return null;
    }
    try {
        return parseObject(parser, lexer, getType(typeName));
    } catch (ClassNotFoundException e) {
        //泛化调用情况下，类可能不存在
        //TODO 需要判断是泛化调用
        return parser.parse();
    }
}
 

/**
 * 读取MAP
 *
 * @param parser 解析器
 * @param lexer  文法
 * @param field  字段
 */
protected Map<String, Object> parseMap(final DefaultJSONParser parser, final JSONLexer lexer, final String field) {
    Map<String, Object> result = null;
    switch (lexer.token()) {
        case JSONToken.LBRACE:
            result = parser.parseObject();
            break;
        case JSONToken.NULL:
            lexer.nextToken();
            break;
        default:
            throw new SerializerException("syntax error: invalid " + field);
    }
    return result;
}
 

/**
 * 解析对象数组
 *
 * @param parser 解析器
 * @param lexer  语法
 * @param types  类型
 * @param field  字段
 */
protected Object[] parseObjects(final DefaultJSONParser parser, final JSONLexer lexer, final Type[] types, final String field) {
    Object[] result = null;
    //空数组
    if (lexer.token() == JSONToken.NULL) {
        if (types.length == 0) {
            lexer.nextToken();
        } else {
            throw new SerializerException("syntax error: invalid " + field);
        }
    } else {
        //解析参数
        JSONReader reader = new JSONReader(parser);
        reader.startArray();
        int i = 0;
        result = new Object[types.length];
        while (reader.hasNext()) {
            if (i >= result.length) {
                throw new SerializerException("syntax error: invalid " + field);
            }
            result[i] = reader.readObject(types[i]);
            i++;
        }
        reader.endArray();
    }
    return result;
}
 

@SuppressWarnings("unchecked")
@Override
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
    JSONLexer lexer = parser.getLexer();
    String stringVal = lexer.stringVal();
    
    return (T) EnumUtil.valueOf((Class<T>) type , stringVal);
}
 

@Override
public ObjectId deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
    //这里parser.getInput()获取到的是整个json字符串
    //parser.getLexer().stringVal()获取到的是指定字段的字符串值
    String hexString = parser.getLexer().stringVal();
    return new ObjectId(hexString);
}
 

public void extract(JSONPath path, DefaultJSONParser parser, Context context) {
    JSONLexerBase lexer = (JSONLexerBase) parser.lexer;
    if (lexer.seekArrayToItem(index)
            && context.eval)
    {
        context.object = parser.parse();
    }
}
 

public ResolveFieldDeserializer(DefaultJSONParser parser, List list, int index){
    super(null, null);
    this.parser = parser;
    this.index = index;
    this.list = list;
    
    key = null;
    map = null;
    
    collection = null;
}
 

public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
    PropertyProcessable processable;
    try {
        processable = this.type.newInstance();
    } catch (Exception e) {
        throw new JSONException("craete instance error");
    }

    Object object =parser.parse(processable, fieldName);

    return (T) object;
}
 

@SuppressWarnings("unchecked")
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
    if (type instanceof GenericArrayType) {
        Type componentType = ((GenericArrayType) type).getGenericComponentType();
        if (componentType instanceof TypeVariable) {
            TypeVariable<?> componentVar = (TypeVariable<?>) componentType;
            componentType = componentVar.getBounds()[0];
        }

        List<Object> list = new ArrayList<Object>();
        parser.parseArray(componentType, list);
        Class<?> componentClass;
        if (componentType instanceof Class) {
            componentClass = (Class<?>) componentType;
            Object[] array = (Object[]) Array.newInstance(componentClass, list.size());
            list.toArray(array);
            return (T) array;
        } else {
            return (T) list.toArray();
        }

    }
    
    if (type instanceof Class
            && type != Object.class
            && type != Serializable.class
            && type != Cloneable.class
            && type != Closeable.class
            && type != Comparable.class) {
        return (T) parser.parseObject(type);    
    }

    return (T) parser.parse(fieldName);
}