design/designer-base/src/main/java/com/fr/design/mainframe/guide/collect/GuideCollector.java

package com.fr.design.mainframe.guide.collect;

import com.fr.base.io.XMLReadHelper;
import com.fr.design.mainframe.guide.base.Guide;
import com.fr.design.mainframe.guide.base.GuideManager;
import com.fr.log.FineLoggerFactory;
import com.fanruan.product.ProductConstants;
import com.fr.stable.StableUtils;
import com.fr.stable.xml.XMLPrintWriter;
import com.fr.stable.xml.XMLReadable;
import com.fr.stable.xml.XMLTools;
import com.fr.stable.xml.XMLable;
import com.fr.stable.xml.XMLableReader;
import com.fr.third.javax.xml.stream.XMLStreamException;
import com.fr.third.org.apache.commons.io.FileUtils;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;

public class GuideCollector implements XMLable {
    private static final String ROOT_XML = "GuideCollector";
    private static final String GUIDE_XML = "Guide";
    private static final String FILE_NAME = "guide.info";
    private static GuideCollector collector;

    private boolean showHint;
    private List<Guide> cacheGuides;

    public static GuideCollector getInstance() {
        if (collector == null) {
            collector = new GuideCollector();
        }
        return collector;
    }

    public GuideCollector() {
        cacheGuides = new ArrayList<>();
    }

    public boolean isShowHint() {
        return showHint;
    }

    public void setShowHint(boolean showHint) {
        this.showHint = showHint;
        saveInfo();
    }

    public void load() {
        for(Guide cacheGuide : cacheGuides) {
            Guide guide = GuideManager.getInstance().getGuide(cacheGuide.getId());
            if (guide != null) {
                guide.setComplete(cacheGuide.isComplete());
            }
        }
    }

    public void saveInfo() {
        cacheGuides = GuideManager.getInstance().getAllGuide();
        try {
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            XMLTools.writeOutputStreamXML(this, out);
            out.flush();
            out.close();
            String fileContent = new String(out.toByteArray(), StandardCharsets.UTF_8);
            FileUtils.writeStringToFile(getInfoFile(), fileContent, StandardCharsets.UTF_8);
        } catch (Exception ex) {
            FineLoggerFactory.getLogger().error(ex.getMessage());
        }
    }

    private File getInfoFile() {
        File file = new File(StableUtils.pathJoin(ProductConstants.getEnvHome(), FILE_NAME));
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
        } catch (Exception ex) {
            FineLoggerFactory.getLogger().error(ex.getMessage(), ex);
        }
        return file;
    }

    public void loadFromFile() {
        if (!getInfoFile().exists()) {
            return;
        }
        XMLableReader reader = null;
        try (InputStream in = new FileInputStream(getInfoFile())) {
            reader = XMLReadHelper.createXMLableReader(in, XMLPrintWriter.XML_ENCODER);
            if (reader == null) {
                return;
            }
            reader.readXMLObject(this);
        } catch (FileNotFoundException e) {
        } catch (XMLStreamException | IOException e) {
            FineLoggerFactory.getLogger().error(e.getMessage(), e);
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
            } catch (XMLStreamException e) {
                FineLoggerFactory.getLogger().error(e.getMessage(), e);
            }
        }
    }

    @Override
    public void readXML(XMLableReader xmLableReader) {
        String tagName = xmLableReader.getTagName();
        if (tagName.equals(ROOT_XML)) {
            showHint = xmLableReader.getAttrAsBoolean("showHint", false);
            xmLableReader.readXMLObject(new XMLReadable() {
                public void readXML(XMLableReader reader) {
                    String tagName = reader.getTagName();
                    if (tagName.equals(GUIDE_XML)) {
                        Guide guide = new Guide();
                        guide.setId(reader.getAttrAsString("id", null));
                        guide.setComplete(reader.getAttrAsBoolean("isComplete", false));
                        cacheGuides.add(guide);
                    }

                }
            });
        }
    }

    @Override
    public void writeXML(XMLPrintWriter writer) {
        writer.startTAG(ROOT_XML);
        writer.attr("showHint", showHint);
        for(Guide guide : GuideManager.getInstance().getAllGuide()) {
            writer.startTAG(GUIDE_XML);
            writer.attr("id", guide.getId());
            writer.attr("isComplete", guide.isComplete());
            writer.end();
        }
        writer.end();


    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return null;
    }
}