/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.alipay.test.acts.util;

import au.com.bytecode.opencsv.CSVWriter;
import com.alipay.test.acts.log.ActsLogUtil;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.azeckoski.reflectutils.ClassFields;
import org.azeckoski.reflectutils.ReflectUtils;
import org.azeckoski.reflectutils.ClassData;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.lang.reflect.Field;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import com.alipay.test.acts.db.enums.CSVColEnum;
import com.alipay.test.acts.log.ActsLogUtil;
import com.alipay.test.acts.object.manager.ObjectTypeManager;
import com.google.common.collect.ImmutableList;
import com.google.common.reflect.Invokable;
import com.google.common.reflect.Parameter;
import com.google.common.reflect.TypeToken;

/**
 * external method for acts ide
 *
 * @author mahongliang
 * @version $Id: CSVApisUtil.java, v 0.1 2015年11月20日 下午12:48:57  Exp $
 */
public class CSVApisUtil {
    private static final Log LOG = LogFactory.getLog(CSVApisUtil.class);

    /**
     * External method. Parse Class
     *
     * @param clsName  class
     * @param classLoade  clsLoad
     * @param genRootPath csv root path
     * @throws ClassNotFoundException
     */
    public static Set<String> paraClassToCscFile(String clsName, ClassLoader classLoade,
                                                 String genRootPath) throws ClassNotFoundException {
        Set<String> sbfWarnError = new HashSet<String>();
        Class<?> specifyClass = classLoade.loadClass(clsName);
        if (specifyClass.isInterface()) {
            processInterface(specifyClass, genRootPath, sbfWarnError);
        } else {
            doProcess(specifyClass, null, new HashSet<String>(),
                mkCsvFolderForCls(specifyClass, null, genRootPath), sbfWarnError);
        }

        return sbfWarnError;
    }

    /**
     * External method. Parse the input and return parameters of the specified method
     *
     * @param clsName  class
     * @param classLoade  clsLoad
     * @param genRootPath csv root path
     * @throws ClassNotFoundException
     */
    public static Set<String> paraClassSpeciMethodToCscFile(String clsName, ClassLoader classLoade,
                                                            String genRootPath, String methodName,
                                                            boolean isResultOnly)
                                                                                 throws ClassNotFoundException {
        Set<String> sbfWarnError = new HashSet<String>();
        Class<?> specifyClass = classLoade.loadClass(clsName);
        processInterfaceMethod(specifyClass, genRootPath, sbfWarnError, methodName, isResultOnly);

        return sbfWarnError;

    }

    /**
     * create a CSV file based on the class
     *
     * @param clsMain
     * @param genRootPath
     * @return created csv file
     */
    public static String mkCsvFolderForCls(Class<?> clsMain, Type clsType, String genRootPath) {
        if (isWrapClass(clsMain)) {
            LOG.warn("do nothing when simple type");
            return null;
        }
        if (clsMain.isArray() && isWrapClass(clsMain.getComponentType())) {
            LOG.warn("do nothing  when the element'class in array is simple type");
            return null;
        }

        Class<?> clsAdd = clsMain.isArray() ? clsMain.getComponentType() : clsMain;

        String csvRootPath;
        String csvFolder;
        File objModel = FileUtil.getTestResourceFileByRootPath(genRootPath);
        if (!objModel.exists()) {
            objModel.mkdir();
        }
        if (clsType == null) {
            csvFolder = genRootPath + clsAdd.getSimpleName();
            csvRootPath = csvFolder + "/" + clsAdd.getSimpleName() + ".csv";
        } else {
            if (clsType instanceof ParameterizedType) {
                Class<?> clsSub = getParameRawCls(clsType);
                Type typeInner = HandMutiParameType(clsType, 0);
                Class<?> typeSub = getClass(typeInner, 0);
                //csv name with a generic name
                csvFolder = genRootPath + clsAdd.getSimpleName() + "_" + clsSub.getSimpleName()
                            + "_" + typeSub.getSimpleName();
                csvRootPath = csvFolder + "/" + clsAdd.getSimpleName() + "_"
                              + clsSub.getSimpleName() + "_" + typeSub.getSimpleName() + ".csv";
            } else {
                Class<?> clsSub = getClass(clsType, 0);
                //csv name with a generic name
                csvFolder = genRootPath + clsAdd.getSimpleName() + "_" + clsSub.getSimpleName();
                csvRootPath = csvFolder + "/" + clsAdd.getSimpleName() + "_"
                              + clsSub.getSimpleName() + ".csv";
            }

        }
        File file = FileUtil.getTestResourceFileByRootPath(csvFolder);
        if (!file.exists()) {
            file.mkdir();
        }
        return csvRootPath;
    }

    /**
     * get .csv file path based on the class
     *
     * @param objClass
     * @param csvPath
     * @return
     */
    private static String getCsvFileName(Class<?> objClass, String csvPath) {

        if (isWrapClass(objClass)) {
            LOG.warn("do nothing when simple type");
            return null;
        }
        String[] paths = csvPath.split("/");
        ArrayUtils.reverse(paths);

        String className = objClass.getSimpleName() + ".csv";

        if (!StringUtils.equals(className, paths[0])) {
            csvPath = StringUtils.replace(csvPath, paths[0], className);
        }

        return csvPath;
    }

    public static String getGenericCsvFileName(Class<?> sueperClass, Class<?> subClass,
                                               String csvPath) {

        if (isWrapClass(sueperClass)) {
            LOG.warn("do nothing when simple type");
            return null;
        }

        if (null == subClass) {
            return getCsvFileName(sueperClass, csvPath);
        }
        String[] paths = csvPath.split("/");
        ArrayUtils.reverse(paths);

        String className = sueperClass.getSimpleName() + "_" + subClass.getSimpleName() + ".csv";

        if (!StringUtils.equals(className, paths[0])) {
            csvPath = StringUtils.replace(csvPath, paths[0], className);
        }

        return csvPath;
    }

    /**
     *
     * @param
     * @param
     */
    private static void processInterface(Class<?> specifyClass, String genRootPath,
                                         Set<String> sbfWarnError) {
        ReflectUtils refUtil = ReflectUtils.getInstance();
        ClassFields<?> clsFiled = refUtil.analyzeClass(specifyClass);
        ClassData<?> getPro = clsFiled.getClassData();
        List<Method> listMetchod = getPro.getMethods();
        for (Method method : listMetchod) {
            Invokable invoke = Invokable.from(method);
            ImmutableList<Parameter> mParameters = invoke.getParameters();
            //input parameters
            for (Parameter parameter : mParameters) {

                try {
                    Class<?> paraCls = parameter.getType().getRawType();
                    TypeToken<?> preToken = parameter.getType();
                    TypeToken<?> genericTypeToken = preToken.resolveType(preToken.getType());
                    String csvFile = null;
                    if (!(genericTypeToken.getType() instanceof ParameterizedType)) {
                        doProcess(paraCls, null, new HashSet<String>(),
                            mkCsvFolderForCls(paraCls, null, genRootPath), sbfWarnError);
                    } else {
                        if (Map.class.isAssignableFrom(paraCls)) {
                            //MAP
                            csvFile = mkCsvFolderForCls(paraCls,
                                HandMutiParameType(genericTypeToken.getType(), 1), genRootPath);
                        } else {
                            csvFile = mkCsvFolderForCls(paraCls,
                                HandMutiParameType(genericTypeToken.getType(), 0), genRootPath);
                        }
                        ContainerUtils.handContainer(paraCls,
                            HandMutiParameType(genericTypeToken.getType(), 0),
                            HandMutiParameType(genericTypeToken.getType(), 1), csvFile,
                            new HashSet<String>(), sbfWarnError, true);
                    }

                } catch (Throwable e) {
                    //catch ex, then parsing other parameters
                    String genModelMsg = "translate class [" + parameter.getClass().getName()
                                         + "] to CSV failed:" + e.getMessage()
                                         + ", recommended to generate templates using class!"
                                         + "\n";
                    sbfWarnError.add(genModelMsg);
                }
            }
            try {
                //return parameters
                retClsToMkCsv(genRootPath, method, sbfWarnError);
            } catch (Throwable e) {
                //catch ex, then parsing other parameters
                String genModelMsg = "translate class" + method.getGenericReturnType().toString()
                                     + "] to CSV failed:" + e.getMessage()
                                     + ", recommended to generate templates using class!" + "\n";
                sbfWarnError.add(genModelMsg);
            }
        }
    }

    /**
     * generate the input and return parameters of the specified method in the interface
     *
     * @param specifyClass
     * @param genRootPath
     * @param sbfWarnError
     * @param methodName
     * @param isResultOnly
     */
    private static void processInterfaceMethod(Class<?> specifyClass, String genRootPath,
                                               Set<String> sbfWarnError, String methodName,
                                               boolean isResultOnly) {
        ReflectUtils refUtil = ReflectUtils.getInstance();
        ClassFields<?> clsFiled = refUtil.analyzeClass(specifyClass);
        ClassData<?> getPro = clsFiled.getClassData();
        List<Method> listMetchod = getPro.getMethods();
        for (Method method : listMetchod) {
            if (StringUtils.equals(method.getName(), methodName)) {
                Invokable invoke = Invokable.from(method);
                ImmutableList<Parameter> mParameters = invoke.getParameters();
                //input parameter
                if (!isResultOnly) {
                    for (Parameter parameter : mParameters) {

                        try {
                            Class<?> paraCls = parameter.getType().getRawType();
                            TypeToken<?> preToken = parameter.getType();
                            TypeToken<?> genericTypeToken = preToken
                                .resolveType(preToken.getType());
                            String csvFile = null;
                            if (!(genericTypeToken.getType() instanceof ParameterizedType)) {
                                doProcess(paraCls, null, new HashSet<String>(),
                                    mkCsvFolderForCls(paraCls, null, genRootPath), sbfWarnError);
                            } else {
                                if (Map.class.isAssignableFrom(paraCls)) {
                                    //MAP
                                    csvFile = mkCsvFolderForCls(paraCls,
                                        HandMutiParameType(genericTypeToken.getType(), 1),
                                        genRootPath);
                                } else {
                                    csvFile = mkCsvFolderForCls(paraCls,
                                        HandMutiParameType(genericTypeToken.getType(), 0),
                                        genRootPath);
                                }
                                ContainerUtils.handContainer(paraCls,
                                    HandMutiParameType(genericTypeToken.getType(), 0),
                                    HandMutiParameType(genericTypeToken.getType(), 1), csvFile,
                                    new HashSet<String>(), sbfWarnError, true);
                            }

                        } catch (Throwable e) {
                            //catch ex, then parsing other parameters
                            String genModelMsg = "class ["
                                                 + parameter.getClass().getName()
                                                 + "] to CSV failed:"
                                                 + e.getMessage()
                                                 + ", recommended to generate templates using class!"
                                                 + "\n";
                            sbfWarnError.add(genModelMsg);
                        }
                    }
                }
                try {
                    //return parameter
                    retClsToMkCsv(genRootPath, method, sbfWarnError);
                } catch (Throwable e) {
                    //catch ex, then parsing other parameters
                    String genModelMsg = "class [" + method.getGenericReturnType().toString()
                                         + "] to CSV failed:" + e.getMessage()
                                         + ", recommended to generate templates using class!"
                                         + "\n";
                    sbfWarnError.add(genModelMsg);
                }
            }

        }
    }

    /**
     * parse return parameter
     *
     * @param genRootPath
     * @param method
     */
    private static void retClsToMkCsv(String genRootPath, Method method, Set<String> sbfWarnError) {
        TypeToken<?> preToken = TypeToken.of(method.getGenericReturnType());
        TypeToken<?> genericTypeToken = preToken.resolveType(method.getGenericReturnType());
        Class<?> rawClss = genericTypeToken.getRawType();

        if (!(method.getGenericReturnType() instanceof ParameterizedType)) {
            doProcess(genericTypeToken.getRawType(), null, new HashSet<String>(),
                mkCsvFolderForCls(rawClss, null, genRootPath), sbfWarnError);
        } else {
            if (Map.class.isAssignableFrom(rawClss)) {
                //MAP
                String csvFile = mkCsvFolderForCls(rawClss,
                    HandMutiParameType(genericTypeToken.getType(), 1), genRootPath);
                ContainerUtils.handContainer(rawClss,
                    HandMutiParameType(genericTypeToken.getType(), 0),
                    HandMutiParameType(genericTypeToken.getType(), 1), csvFile,
                    new HashSet<String>(), sbfWarnError, true);
            } else {
                //other
                String csvFile = mkCsvFolderForCls(rawClss,
                    HandMutiParameType(genericTypeToken.getType(), 0), genRootPath);
                ContainerUtils.handContainer(rawClss,
                    HandMutiParameType(genericTypeToken.getType(), 0), null, csvFile,
                    new HashSet<String>(), sbfWarnError, true);
            }
        }
    }

    private static final ObjectTypeManager objectTypeManager             = new ObjectTypeManager();

    /** multiple elements:"1;2;3" */
    private static final String            LIST_CONTENT_TEMPLATE         = "1";
    /** multiple elements:"[email protected];2" */
    private static final String            COMPLEX_LIST_CONTENT_TEMPLATE = "[email protected]";
    private static final String            COMPLEX_TYPE_CONTENT_TEMPLATE = "[email protected]";
    private static final String            FILE_WORDS                    = "FILE";

    /**
     *
     * @param
     * @param
     */
    public static void doProcess(Class<?> classTopara, Class<?> subCls, Set<String> setCalue,
                                 String csvRoot, Set<String> sbfWarn) {
        if (StringUtils.isBlank(csvRoot)) {
            ActsLogUtil.warn(LOG, "The path is empty and the CSV file cannot be generated.");
            return;
        }
        if (null == classTopara) {
            ActsLogUtil.warn(LOG, "The class name is empty and cannot generate a CSV file");
            return;
        }

        if (classTopara.isArray()) {
            classTopara = classTopara.getComponentType();
        }

        if (isWrapClass(classTopara) || setCalue.contains(classTopara.getName())) {
            return;
        }

        File file = FileUtil.getTestResourceFileByRootPath(csvRoot);
        if (file.exists()) {
            ActsLogUtil.warn(LOG, "file [" + csvRoot + "] already exists,skip directly");
            return;
        }

        Map<String, Field> getPro = findTargetClsFields(classTopara);

        //prevent loops
        avoidDeedLoop(setCalue, classTopara, subCls);

        List<String[]> outputValues = new ArrayList<String[]>();
        //assemble the first line of the CSV file:the header line
        List<String> header = new ArrayList<String>();
        header.add(CSVColEnum.CLASS.getCode());
        header.add(CSVColEnum.PROPERTY.getCode());
        header.add(CSVColEnum.TYPE.getCode());
        header.add(CSVColEnum.RULE.getCode());
        header.add(CSVColEnum.FLAG.getCode());
        header.add("value");
        outputValues.add(header.toArray(new String[header.size()]));

        int i = 1;

        for (Entry<String, Field> proValue : getPro.entrySet()) {
            if (null == proValue.getValue()) {
                continue;
            }

            List<String> value = new ArrayList<String>();
            if (1 == i) {
                //If it is the first generated, the content needs to contain the class name.
                value.add(classTopara.getName());
            } else {
                value.add("");
            }
            //attribute's name
            value.add(proValue.getKey());
            //attribute's type name
            value.add(proValue.getValue().getType().getName());

            //data rule
            value.add("");

            //class type of this attribute
            Class<?> filedCls = proValue.getValue().getType();
            Boolean isHandle = false;
            if (setCalue.contains(filedCls.getName())) {
                //prevent infinite loops
                value.add("N");
                value.add("null");
                isHandle = true;
            } else if (isWrapClass(filedCls)) {

                addSimpleValue(proValue.getKey(), filedCls, value);
                isHandle = true;
            }

            if (null != proValue.getValue()) {
                if (!isHandle && Map.class.isAssignableFrom(filedCls)) {

                    try {
                        value.add("M");
                        Class<?> rawClass = getParameRawCls(proValue.getValue().getGenericType());

                        Type mapKeycls = HandMutiParameType(proValue.getValue().getGenericType(), 0);
                        Type mapValueCls = HandMutiParameType(proValue.getValue().getGenericType(),
                            1);

                        String mapPath;
                        if (mapValueCls instanceof ParameterizedType) {
                            mapPath = getGenericCsvFileName(rawClass,
                                (Class) ((ParameterizedType) mapValueCls).getRawType(), csvRoot);
                        } else {
                            mapPath = getGenericCsvFileName(rawClass, getClass(mapValueCls, 0),
                                csvRoot);
                        }

                        ContainerUtils.handContainer(rawClass, mapKeycls, mapValueCls, mapPath,
                            setCalue, sbfWarn, false);
                        value.add(cutCsvName(mapPath) + "@1");
                    } catch (Throwable e) {
                        //default value when failed
                        value.set(4, "N");
                        value.add("null");
                        LOG.warn("", e);
                    }
                } else if (!isHandle) {

                    Class<?> norMalCls = getClass(proValue.getValue().getGenericType(), 0);
                    //Array
                    if (filedCls.isArray()) {
                        norMalCls = filedCls.getComponentType();
                    }

                    value.add("Y");
                    if (objectTypeManager.isCollectionType(filedCls)) {
                        if (objectTypeManager.isSimpleType(norMalCls)) {
                            value.add(LIST_CONTENT_TEMPLATE);
                        } else if (Map.class.isAssignableFrom(norMalCls)) {
                            //List<Map<>>
                            TypeToken<?> preToken = TypeToken.of(proValue.getValue()
                                .getGenericType());
                            TypeToken<?> genericTypeToken = preToken.resolveType(proValue
                                .getValue().getGenericType());

                            Type mapType = HandMutiParameType(genericTypeToken.getType(), 0);
                            Class<?> rawClass = CSVApisUtil.getParameRawCls(mapType);

                            Type mapKeycls = CSVApisUtil.HandMutiParameType(mapType, 0);
                            Type mapValueCls = CSVApisUtil.HandMutiParameType(mapType, 1);

                            String mapPath;
                            if (mapValueCls instanceof ParameterizedType) {
                                mapPath = getGenericCsvFileName(rawClass,
                                    (Class) ((ParameterizedType) mapValueCls).getRawType(), csvRoot);
                            } else {
                                mapPath = getGenericCsvFileName(rawClass, getClass(mapValueCls, 0),
                                    csvRoot);
                            }

                            ContainerUtils.handContainer(rawClass, mapKeycls, mapValueCls, mapPath,
                                setCalue, sbfWarn, false);
                            value.add(cutCsvName(mapPath) + "@1");

                        } else {

                            //Set<Object> is not supported
                            if (Set.class.isAssignableFrom(filedCls)) {
                                value.set(4, "N");
                                value.add("null");
                            } else {
                                //List<Object>:element is a complex object

                                //prevent nested list elements
                                if (setCalue.contains(norMalCls.getName())) {
                                    value.set(4, "N");
                                    value.add("null");
                                } else {
                                    value.add(COMPLEX_LIST_CONTENT_TEMPLATE.replace(FILE_WORDS,
                                        norMalCls.getSimpleName() + ".csv"));
                                }

                                try {
                                    doProcess(norMalCls, null, setCalue,
                                        getCsvFileName(norMalCls, csvRoot), sbfWarn);
                                } catch (Throwable e) {
                                    //default value when failed
                                    value.set(4, "N");
                                    value.set(5, "null");
                                    LOG.warn("process complex classes in list failed", e);
                                }
                            }
                        }
                    } else if (proValue.getValue().getGenericType() instanceof ParameterizedType) {
                        value.add(COMPLEX_LIST_CONTENT_TEMPLATE.replace(FILE_WORDS,
                            filedCls.getSimpleName() + "_" + norMalCls.getSimpleName() + ".csv"));
                        try {
                            doProcess(filedCls, norMalCls, setCalue,
                                getGenericCsvFileName(filedCls, norMalCls, csvRoot), sbfWarn);
                        } catch (Throwable e) {
                            //default value when failed
                            value.set(4, "N");
                            value.set(5, "null");
                            LOG.warn("process generic classes failed", e);
                        }
                    } else if (filedCls.isInterface()
                               || Modifier.isAbstract(filedCls.getModifiers())) {
                        //stop generating templates when interface or abstraction
                        value.set(4, "N");
                        value.add("null");
                    } else {
                        value.add(COMPLEX_TYPE_CONTENT_TEMPLATE.replace(FILE_WORDS,
                            filedCls.getSimpleName() + ".csv"));
                    }
                    if (!isWrapClass(norMalCls) && !setCalue.contains(norMalCls.getName())
                        && !Map.class.isAssignableFrom(norMalCls)) {
                        //deal with internal complex classes
                        try {
                            doProcess(norMalCls, null, setCalue,
                                getCsvFileName(norMalCls, csvRoot), sbfWarn);
                        } catch (Throwable e) {
                            //default value when failed
                            value.set(4, "N");
                            value.set(5, "null");
                            LOG.warn("process internal complex classes failed", e);
                        }
                    }
                }
            }
            outputValues.add(value.toArray(new String[value.size()]));
            i++;
        }

        //no field of complicated objects
        if (getPro.size() == 0) {
            sbfWarn.add(cutCsvName(csvRoot));
            List<String> value = new ArrayList<String>();
            value.add(classTopara.getName());
            value.add("");
            value.add("");
            value.add("");
            value.add("");
            value.add("");
            outputValues.add(value.toArray(new String[value.size()]));
        }
        writeToCsv(file, outputValues);
        setCalue.remove(classTopara.getName());
    }

    public static String cutCsvName(final String csvRoot) {
        return StringUtils.substringAfterLast(csvRoot, "/");
    }

    public static Map<String, Field> findTargetClsFields(Class<?> cls) {
        if (isWrapClass(cls)) {
            return null;
        }
        ReflectUtils refUtil = ReflectUtils.getInstance();
        ClassFields<?> clsFiled = refUtil.analyzeClass(cls);
        List<Field> getPro = clsFiled.getClassData().getFields();
        Map<String, Field> reClsProp = new HashMap<String, Field>();
        for (Field proValue : getPro) {
            if (Modifier.isFinal(proValue.getModifiers())
                || Modifier.isStatic(proValue.getModifiers())) {
                continue;
            }
            String propName = proValue.getName();
            reClsProp.put(propName, proValue);
        }

        return reClsProp;
    }

    public static void writeToCsv(File file, List<String[]> outputValues) {

        OutputStream outputStream = null;
        try {
            outputStream = new FileOutputStream(file);
        } catch (Exception e) {
            ActsLogUtil.warn(LOG, "file [" + file.getName() + "] not fund." + e);
            throw new RuntimeException(e);
        }
        //write the generated content to a CSV file
        try {
            OutputStreamWriter osw = null;
            osw = new OutputStreamWriter(outputStream);
            CSVWriter csvWriter = new CSVWriter(osw);
            csvWriter.writeAll(outputValues);
            csvWriter.close();
            ActsLogUtil.warn(LOG, file.getName() + "generated successfully");
        } catch (Exception e) {
            ActsLogUtil.warn(LOG, "write to CSV file failed:" + file.getName() + e);
            throw new RuntimeException(e);
        }
    }

    public static void addSimpleValue(String fieldName, Class<?> fieldType, List<String> value) {
        if (StringUtils.equals(java.util.Date.class.getName(), fieldType.getName())) {
            value.add("D");
            value.add("today");
        } else if (StringUtils.equals(java.util.Currency.class.getName(), fieldType.getName())) {

            value.add("Y");
            value.add("CNY");

        } else if (StringUtils.equals(fieldName, "currencyValue")) {
            //default value
            value.add("Y");
            value.add("156");

        } else if (StringUtils.equals(fieldType.getName(), "int")
                   || StringUtils.equals(fieldType.getName(), "java.lang.Integer")
                   || StringUtils.equals(fieldType.getName(), "long")
                   || StringUtils.equals(fieldType.getName(), "java.lang.Long")
                   || StringUtils.equals(fieldType.getName(), "short")) {
            value.add("Y");
            value.add("0");
        } else if (StringUtils.equals(fieldType.getName(), "float")
                   || StringUtils.equals(fieldType.getName(), "double")) {
            value.add("Y");
            value.add("0.0");
        } else if (StringUtils.equals(fieldType.getName(), "boolean")) {
            value.add("Y");
            value.add("false");
        } else if (StringUtils.equals(fieldType.getName(), "char")) {
            value.add("Y");
            value.add("A");
        } else if (StringUtils.equals(fieldType.getName(), "java.math.BigDecimal")) {
            value.add("Y");
            value.add("0.001");
        } else if (StringUtils.equals(fieldType.getName(), "java.lang.Object")) {
            value.set(2, "java.lang.Object");
            value.add("N");
            value.add("");
        } else if (StringUtils.equals(fieldType.getName(), "java.lang.Void")) {
            value.set(2, "java.lang.Void");
            value.add("N");
            value.add("null");
        } else {
            value.add("Y");
            value.add("null");
        }
    }

    /**
     * get the type of generic
     * @param type
     * @param i
     * @return
     */
    public static Class<?> getClass(Type type, int i) {
        if (type instanceof ParameterizedType) {

            return getGenericClass((ParameterizedType) type, i);
        } else if (type instanceof GenericArrayType) {
            return (Class) ((GenericArrayType) type).getGenericComponentType();
        } else if (type instanceof TypeVariable) {
            return getClass(((TypeVariable) type).getBounds()[0], 0);
        } else if (type instanceof WildcardType) {
            WildcardType wuleType = (WildcardType) type;
            if (null != wuleType.getUpperBounds()[0]) {
                return getClass(wuleType.getUpperBounds()[0], 0);
            } else {
                return getClass(wuleType.getLowerBounds()[0], 0);
            }
        } else if (type instanceof Class) {
            return (Class<?>) type;
        } else {
            return (Class<?>) type;
        }
    }

    /**
     *
     * @param type
     * @param i
     * @return
     */
    public static Type HandMutiParameType(Type type, int i) {
        if (type instanceof ParameterizedType) {
            try {
                ParameterizedType outType = (ParameterizedType) type;
                return outType.getActualTypeArguments()[i];
            } catch (Exception e) {
                return null;
            }
        } else if (type instanceof Class) {
            if (0 == i) {
                return type;
            }
            return null;
        } else {
            if (0 == i) {
                getClass(type, 0);
            } else {
                return null;
            }
        }
        return null;

    }

    /**
     *
     * @param type
     *
     * @return
     */
    public static Class<?> getParameRawCls(Type type) {
        if (type instanceof ParameterizedType) {
            try {
                ParameterizedType outType = (ParameterizedType) type;
                return (Class) outType.getRawType();
            } catch (Exception e) {
                return null;
            }
        }
        return null;
    }

    /**
     *
     * @param type
     *
     * @return
     */
    public static int getTypeCount(Type type) {
        if (type instanceof ParameterizedType) {
            try {
                ParameterizedType outType = (ParameterizedType) type;
                return outType.getActualTypeArguments().length;
            } catch (Exception e) {
                return 0;
            }
        } else if (type instanceof Class) {
            return 0;
        }
        return 1;
    }

    private static Class<?> getGenericClass(ParameterizedType parameterizedType, int i) {
        Type genericClass = null;
        try {
            genericClass = parameterizedType.getActualTypeArguments()[i];
        } catch (Exception e) {
            return null;
        }

        if (genericClass instanceof ParameterizedType) {
            return (Class) ((ParameterizedType) genericClass).getRawType();
        } else if (genericClass instanceof GenericArrayType) {
            return (Class<?>) ((GenericArrayType) genericClass).getGenericComponentType();
        } else if (genericClass instanceof TypeVariable) {
            return getClass(((TypeVariable) genericClass).getBounds()[0], 0);
        } else if (genericClass instanceof WildcardType) {
            WildcardType wuleType = (WildcardType) genericClass;
            if (null != wuleType.getUpperBounds()[0]) {
                return getClass(wuleType.getUpperBounds()[0], 0);
            } else {
                return getClass(wuleType.getLowerBounds()[0], 0);
            }

        } else {
            return (Class<?>) genericClass;
        }
    }

    private static void avoidDeedLoop(Set<String> mapLoop, Class<?> clsFullName, Class<?> subClass) {

        String clsName = clsFullName.getName();
        //filter out simple type
        if (isWrapClass(clsFullName)) {
            return;
        }

        if (null != subClass) {
            mapLoop.remove(clsFullName);
            clsName += "_" + subClass.getSimpleName();

        }
        if (!mapLoop.contains(clsName)) {
            mapLoop.add(clsName);
        }
    }

    private final static Set<String> simpleClassType = new HashSet<String>();

    static {
        simpleClassType.add("boolean");
        simpleClassType.add("java.lang.Integer");
        simpleClassType.add("java.lang.Float");
        simpleClassType.add("java.lang.Double");
        simpleClassType.add("java.lang.Long");
        simpleClassType.add("java.lang.Short");
        simpleClassType.add("java.lang.Byte");
        simpleClassType.add("java.lang.Boolean");
        simpleClassType.add("java.lang.Character");
        simpleClassType.add("java.util.Properties");
        simpleClassType.add("java.lang.String");
        simpleClassType.add("java.util.Date");

        simpleClassType.add("java.util.Currency");
        simpleClassType.add("java.math.BigDecimal");
        simpleClassType.add("java.io.Serializable");
        simpleClassType.add("java.lang.Object");
        simpleClassType.add("java.lang.Void");

    }

    /**
     *
     * @param clsToJude
     * @return
     */
    public static boolean isWrapClass(Class<?> clsToJude) {

        if (clsToJude.isPrimitive() || clsToJude.isEnum()
            || clsToJude.getName().toLowerCase().contains("enum")
            || simpleClassType.contains(clsToJude.getName())) {
            return true;
        }

        return false;

    }
}