package org.yeshi.utils.generater.vo.xmlconfig;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.yeshi.utils.generater.GeneraterManagerV2;
import org.yeshi.utils.generater.annotation.admin.DaoQueryCondition;
import org.yeshi.utils.generater.annotation.admin.Show;
import org.yeshi.utils.generater.annotation.admin.form.Text;
import org.yeshi.utils.generater.entity.ClassInfo;
import org.yeshi.utils.generater.entity.admin.FormVerifyType;
import org.yeshi.utils.generater.vo.xmlconfig.admin.*;
import org.yeshi.utils.generater.vo.xmlconfig.admin.form.*;
import org.yeshi.utils.generater.vo.xmlconfig.base.ApiData;
import org.yeshi.utils.generater.vo.xmlconfig.base.FormComponent;
import org.yeshi.utils.generater.vo.xmlconfig.base.VerifyData;
import org.yeshi.utils.generater.vo.xmlconfig.dao.DaoData;
import org.yeshi.utils.generater.vo.xmlconfig.dao.DaoQuery;
import org.yeshi.utils.generater.vo.xmlconfig.service.ExceptionData;
import org.yeshi.utils.generater.vo.xmlconfig.service.ServiceData;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author hxh
 * @title: XmlConfigParseUtil
 * @description: xml配置文件解析工具类
 * @date 2022/3/28 15:02
 */
public class XmlConfigParseUtil {

    public static GenertorConfig parse(InputStream inputStream, ClassLoader classLoader) throws Exception {
        if (inputStream == null) {
            throw new FileNotFoundException();
        }
        GenertorConfig genertorConfig = new GenertorConfig();
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document root = builder.parse(inputStream);
        NodeList nodelist = root.getElementsByTagName("generator-config");
        if (nodelist.getLength() == 0) {
            throw new Exception("xml格式错误");
        }
        Node rootNode = nodelist.item(0);
        String clazz = rootNode.getAttributes().getNamedItem("class").getNodeValue();
        genertorConfig.setEntity(classLoader.loadClass(clazz));

        nodelist = rootNode.getChildNodes();
        for (int i = 0; i < nodelist.getLength(); i++) {
            Node node = nodelist.item(i);

            switch (node.getNodeName()) {
                case "dao": {
                    genertorConfig.setDao(parseDao(node));
                }
                break;
                case "service": {
                    genertorConfig.setService(parseService(node));
                }
                break;
                case "admin": {
                    genertorConfig.setAdmin(parseAdmin(node));
                }
                break;
            }


        }


        return genertorConfig;
    }

    private static DaoData parseDao(Node node) {
        DaoData daoData = new DaoData();
        daoData.setPkg(node.getAttributes().getNamedItem("package").getNodeValue());
        daoData.setMapperDir(getNodeAttributeValue(node, "mapperDir"));
        NodeList nodeList = node.getChildNodes();
        for (int i = 0; i < nodeList.getLength(); i++) {
            if (nodeList.item(i).getNodeName().equalsIgnoreCase("queryList")) {
                nodeList = nodeList.item(i).getChildNodes();
                List<DaoQuery> queryList = new ArrayList<>();
                for (int j = 0; j < nodeList.getLength(); j++) {
                    Node node1 = nodeList.item(j);
                    if (node1.getNodeName().equalsIgnoreCase("query")) {
                        DaoQuery daoQuery = new DaoQuery();
                        daoQuery.setName(getNodeAttributeValue(node1, "name"));
                        daoQuery.setQueryType(DaoQueryCondition.QueryType.valueOf(getNodeAttributeValue(node1, "type")));
                        queryList.add(daoQuery);
                    }
                }
                daoData.setQueryList(queryList);
                break;
            }
        }
        return daoData;
    }

    private static ServiceData parseService(Node node) {
        ServiceData data = new ServiceData();
        data.setInterPackage(getNodeAttributeValue(node, "interPackage"));
        data.setImplPackage(getNodeAttributeValue(node, "implPackage"));
        data.setQueryPackage(getNodeAttributeValue(node, "queryPackage"));


        NodeList nodeList = node.getChildNodes();
        for (int i = 0; i < nodeList.getLength(); i++) {
            if (nodeList.item(i).getNodeName().equalsIgnoreCase("exception")) {
                ExceptionData exceptionData = new ExceptionData();
                exceptionData.setPkg(getNodeAttributeValue(nodeList.item(i), "package"));
                exceptionData.setName(getNodeAttributeValue(nodeList.item(i), "name"));
                String base = getNodeAttributeValue(nodeList.item(i), "base");
                if (base != null) {
                    exceptionData.setBase(new ClassInfo(base.split("\\.")[base.split("\\.").length - 1], base));
                }
                data.setException(exceptionData);
                break;
            }
        }
        return data;
    }

    private static AdminData parseAdmin(Node node) {
        AdminData adminData = new AdminData();

        //解析page数据

        NodeList nodeList = node.getChildNodes();
        for (int i = 0; i < nodeList.getLength(); i++) {

            switch (nodeList.item(i).getNodeName()) {

                case "pages": {
                    Node node1 = nodeList.item(i);
                    AdminPageData adminPageData = new AdminPageData();
                    adminPageData.setTitle(getNodeAttributeValue(node1, "title"));
                    adminPageData.setPageDir(getNodeAttributeValue(node1, "pageDir"));
                    NodeList nodeList1 = node1.getChildNodes();
                    for (int i1 = 0; i1 < nodeList1.getLength(); i1++) {
                        Node node2 = nodeList1.item(i1);
                        switch (node2.getNodeName()) {
                            case "list": {
                                ListPageData listPageData = new ListPageData();
                                listPageData.setDelete(Boolean.parseBoolean(getNodeAttributeValue(node2, "delete")));
                                listPageData.setEdit(Boolean.parseBoolean(getNodeAttributeValue(node2, "edit")));
                                listPageData.setPage(Boolean.parseBoolean(getNodeAttributeValue(node2, "page")));
                                listPageData.setFileName(getNodeAttributeValue(node2, "fileName"));

                                NodeList nodeList2 = node2.getChildNodes();
                                for (int i2 = 0; i2 < nodeList2.getLength(); i2++) {
                                    Node node3 = nodeList2.item(i2);
                                    if (node3.getNodeName().equalsIgnoreCase("searchForm")) {
                                        SearchFormData searchFormData = new SearchFormData();
                                        NodeList nodeList3 = node3.getChildNodes();
                                        for (int i3 = 0; i3 < nodeList3.getLength(); i3++) {
                                            if (nodeList3.item(i3).getNodeName().equalsIgnoreCase("columns")) {
                                                searchFormData.setColumns(parseColumns(nodeList3.item(i3)));
                                                break;
                                            }
                                        }
                                        searchFormData.setPkg(getNodeAttributeValue(node3, "package"));
                                        searchFormData.setName(getNodeAttributeValue(node3, "name"));
                                        listPageData.setSearchForm(searchFormData);
                                    } else if (node3.getNodeName().equalsIgnoreCase("columns")) {
                                        listPageData.setColumns(parseColumns(node3));
                                    }
                                }
                                adminPageData.setList(listPageData);
                            }
                            break;

                            case "add": {
                                AddPageData addPageData = new AddPageData();
                                addPageData.setColumns(parseColumns(node2));
                                addPageData.setApi(null);
                                addPageData.setFileName(getNodeAttributeValue(node2, "fileName"));
                                adminPageData.setAdd(addPageData);

                            }
                            break;

                            case "update": {
                                UpdatePageData updatePageData = new UpdatePageData();
                                updatePageData.setColumns(parseColumns(node2));
                                updatePageData.setApi(null);
                                updatePageData.setFileName(getNodeAttributeValue(node2, "fileName"));
                                adminPageData.setUpdate(updatePageData);
                            }
                            break;
                        }
                    }
                    adminData.setPages(adminPageData);
                }
                break;

                case "controller": {
                    Node node1 = nodeList.item(i);
                    AdminControllerData adminControllerData = new AdminControllerData();
                    adminControllerData.setJsonp(Boolean.parseBoolean(getNodeAttributeValue(node1, "jsonp")));
                    adminControllerData.setMapping(getNodeAttributeValue(node1, "mapping"));
                    adminControllerData.setName(getNodeAttributeValue(node1, "name"));
                    adminControllerData.setPkg(getNodeAttributeValue(node1, "package"));
                    adminControllerData.setAdminVOPackage(getNodeAttributeValue(node1, "adminVOPackage"));
                    adminControllerData.setResponseBody(Boolean.parseBoolean(getNodeAttributeValue(node1, "responseBody")));
                    adminData.setController(adminControllerData);
                }
                break;
            }
        }


        return adminData;
    }

    private static String getNodeAttributeValue(Node node, String attr) {
        if (node.getAttributes().getNamedItem(attr) != null) {
            return node.getAttributes().getNamedItem(attr).getNodeValue();
        }
        return null;
    }

    private static List<ColumnData> parseColumns(Node node) {
        List<ColumnData> list = new ArrayList<>();
        NodeList nodeList = node.getChildNodes();
        for (int i = 0; i < nodeList.getLength(); i++) {
            Node node1 = nodeList.item(i);
            if (node1.getNodeName().equalsIgnoreCase("column")) {
                list.add(parseColumn(node1));
            }
        }
        return list;
    }

    private static ColumnData parseColumn(Node node) {
        ColumnData columnData = new ColumnData();
        columnData.setTitle(getNodeAttributeValue(node, "title"));
        columnData.setProperty(getNodeAttributeValue(node, "property"));
        String order = getNodeAttributeValue(node, "order");
        if (order != null) {
            columnData.setOrder(Integer.parseInt(order));
        }

        String showType = getNodeAttributeValue(node, "showType");
        if (showType != null) {
            columnData.setShowType(Show.ShowType.valueOf(showType));
        }

        columnData.setImgHeight(Integer.parseInt(getNodeAttributeValue(node, "imgHeight")));
        columnData.setImgWidth(Integer.parseInt(getNodeAttributeValue(node, "imgWidth")));


        NodeList nodeList = node.getChildNodes();
        if (nodeList != null) {
            for (int i = 0; i < nodeList.getLength(); i++) {
                FormComponent formComponent = parseFormComponent(nodeList.item(i));
                if (formComponent != null) {
                    columnData.setComponent(formComponent);
                    break;
                }
            }
        }


        return columnData;
    }


    private static FormComponent parseFormComponent(Node node) {

        switch (node.getNodeName()) {

            case "text": {
                FormComponentText formComponentText = new FormComponentText();
                formComponentText.setDateFormat(getNodeAttributeValue(node, "dateFormat"));
                formComponentText.setDesc(getNodeAttributeValue(node, "desc"));
                formComponentText.setInputType(Text.Type.valueOf(getNodeAttributeValue(node, "inputType")));
                String maxLength = getNodeAttributeValue(node, "maxLength");
                String minlength = getNodeAttributeValue(node, "minlength");
                if (maxLength != null) {
                    formComponentText.setMaxLength(Integer.parseInt(maxLength));
                }

                if (minlength != null) {
                    formComponentText.setMinLength(Integer.parseInt(minlength));
                }

                formComponentText.setPlaceHolder(getNodeAttributeValue(node, "placeHolder"));
                formComponentText.setTextArea(Boolean.parseBoolean(getNodeAttributeValue(node, "isTextArea")));

                formComponentText.setEnable(Boolean.parseBoolean(getNodeAttributeValue(node, "enable")));
                formComponentText.setNotify(getNodeAttributeValue(node, "notify"));

                NodeList nodeList = node.getChildNodes();
                for (int i = 0; i < nodeList.getLength(); i++) {
                    if (nodeList.item(i).getNodeName().equalsIgnoreCase("verify")) {
                        formComponentText.setVerify(parseVerify(nodeList.item(i)));
                    }
                }
                return formComponentText;
            }
            case "select": {
                FormComponentSelect select = new FormComponentSelect();
                NodeList nodeList = node.getChildNodes();
                for (int i = 0; i < nodeList.getLength(); i++) {
                    switch (nodeList.item(i).getNodeName()) {
                        case "api": {
                            select.setApi(parseApi(nodeList.item(i)));
                        }
                        break;
                        case "values": {
                            select.setValues(parseValues(nodeList.item(i)));
                        }
                        break;
                        case "verify": {
                            select.setVerify(parseVerify(nodeList.item(i)));
                        }
                        break;
                    }
                }

                select.setEnable(Boolean.parseBoolean(getNodeAttributeValue(node, "enable")));
                select.setNotify(getNodeAttributeValue(node, "notify"));

                return select;
            }
            case "switch": {
                FormComponentSwitch formComponentSwitch = new FormComponentSwitch();
                formComponentSwitch.setEnable(Boolean.parseBoolean(getNodeAttributeValue(node, "enable")));
                formComponentSwitch.setNotify(getNodeAttributeValue(node, "notify"));
                return formComponentSwitch;
            }
            case "img": {
                FormComponentImg img = new FormComponentImg();
                img.setEditLink(Boolean.parseBoolean(getNodeAttributeValue(node, "editLink")));

                NodeList nodeList = node.getChildNodes();
                for (int i = 0; i < nodeList.getLength(); i++) {
                    if (nodeList.item(i).getNodeName().equalsIgnoreCase("api")) {
                        img.setApi(parseApi(nodeList.item(i)));
                        break;
                    }
                }

                String height = getNodeAttributeValue(node, "height");
                if (height != null) {
                    img.setHeight(Integer.parseInt(height));
                }
                String width = getNodeAttributeValue(node, "width");
                if (width != null) {
                    img.setWidth(Integer.parseInt(width));
                }
                img.setEnable(Boolean.parseBoolean(getNodeAttributeValue(node, "enable")));
                img.setNotify(getNodeAttributeValue(node, "notify"));
                return img;
            }
            case "radioGroup": {
                FormComponentRadioGroup radioGroup = new FormComponentRadioGroup();
                NodeList nodeList = node.getChildNodes();
                for (int i = 0; i < nodeList.getLength(); i++) {
                    if (nodeList.item(i).getNodeName().equalsIgnoreCase("values")) {
                        radioGroup.setValues(parseValues(nodeList.item(i)));
                        break;
                    }
                }
                radioGroup.setEnable(Boolean.parseBoolean(getNodeAttributeValue(node, "enable")));
                radioGroup.setNotify(getNodeAttributeValue(node, "notify"));
                return radioGroup;
            }
        }
        return null;
    }

    private static VerifyData parseVerify(Node node) {

        if (node == null) {
            return null;
        }

        VerifyData verifyData = new VerifyData();
        verifyData.setType(FormVerifyType.valueOf(getNodeAttributeValue(node, "type")));
        verifyData.setExpress(getNodeAttributeValue(node, "express"));
        verifyData.setNotify(getNodeAttributeValue(node, "notify"));
        verifyData.setRequire(Boolean.parseBoolean(getNodeAttributeValue(node, "require")));
        return verifyData;
    }

    private static ApiData parseApi(Node node) {
        if (node == null) {
            return null;
        }
        ApiData apiData = new ApiData();
        apiData.setPath(getNodeAttributeValue(node, "path"));
        NodeList nodeList = node.getChildNodes();
        for (int i = 0; i < nodeList.getLength(); i++) {
            if (nodeList.item(i).getNodeName().equalsIgnoreCase("params")) {
                apiData.setParams(parseValues(nodeList.item(i)));
            }
        }
        return apiData;
    }

    private static Map<String, Object> parseValues(Node node) {
        if (node == null) {
            return null;
        }
        Map<String, Object> values = new HashMap<>();
        NodeList nodeList = node.getChildNodes();
        for (int i = 0; i < nodeList.getLength(); i++) {
            if (nodeList.item(i).getNodeName().equalsIgnoreCase("value")) {
                values.put(getNodeAttributeValue(nodeList.item(i), "key"), nodeList.item(i).getNodeValue());
            }
        }
        return values;
    }


    public static void main(String[] args) throws Exception {
        GenertorConfig config = XmlConfigParseUtil.parse(new FileInputStream("D:\\workspace\\server\\utils\\src\\test\\test.xml"), null);
        GeneraterManagerV2.getInstance().init("D:\\workspace\\server\\utils\\src\\test\\java", config);
        GeneraterManagerV2.getInstance().createWholeFunction();
        System.out.println(config);
    }


}