Application: gvSIG desktop » gvSIG Document Layout

package org.gvsig.app.project.documents.layout.report;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.geom.Point2D;

import java.io.ByteArrayInputStream;

import java.io.File;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.List;

import java.util.Objects;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.json.JsonNumber;

import javax.json.JsonObject;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import org.apache.commons.codec.DecoderException;

import org.apache.commons.codec.binary.Hex;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICoordTrans;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.gui.styling.SymbolSelector;

import org.gvsig.app.project.documents.Document;

import org.gvsig.app.project.documents.layout.LayoutContext;

import org.gvsig.app.project.documents.layout.fframes.FFrameView;

import org.gvsig.app.project.documents.layout.fframes.IFFrame;

import org.gvsig.app.project.documents.layout.gui.LayoutPanel;

import static org.gvsig.app.project.documents.layout.report.LayoutReportActionFactory.LAYOUT_REPORT_ACTION_NAME;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.app.project.documents.view.gui.IView;

import org.gvsig.app.project.documents.view.legend.gui.ISymbolSelector;

import org.gvsig.desktopopen.DesktopOpen;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureQuery;

import org.gvsig.fmap.dal.feature.FeatureSelection;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.dal.swing.DataSwingManager;

import org.gvsig.fmap.dal.swing.report.AbstractReportAction;

import org.gvsig.fmap.dal.swing.report.ReportActionFactory;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontext.layers.vectorial.GraphicLayer;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.json.Json;

import org.gvsig.pdf.lib.api.PDFDocument;

import org.gvsig.pdf.lib.api.PDFLocator;

import org.gvsig.pdf.lib.api.PDFManager;

import org.gvsig.pdf.swing.api.PDFSwingLocator;

import org.gvsig.pdf.swing.api.PDFSwingManager;

import org.gvsig.pdf.swing.api.PDFViewer;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.IFillSymbol;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.ToolsSwingUtils;

import org.gvsig.tools.swing.api.task.JTaskStatus;

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.swing.api.windowmanager.WindowManager_v2;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.ToolsUtilLocator;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class LayoutReportActionImpl extends AbstractReportAction implements LayoutReportAction {

    public static LayoutReportActionImpl createFakeLayoutReportAction(Document doc) {

        ApplicationManager application = ApplicationLocator.getApplicationManager();

        DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

        Feature f = null;

        FeatureStore theStore = null;

        ReportActionFactory theFactory = dataSwingManager.getReportActionFactory(LAYOUT_REPORT_ACTION_NAME);

        try {

            IWindow activeView = application.getActiveWindow(ViewDocument.class);

            ViewDocument viewdoc = (ViewDocument) ((IView)activeView).getDocument();

            FLyrVect layer = viewdoc.getMapContext().getLayers().getFirstActiveVectorLayer();

            theStore = layer.getFeatureStore();

            if( theStore.isFeatureSelectionEmpty() ) {

                f = theStore.first();

            } else {

                f = theStore.getFeatureSelection().first();

            }

        } catch(Throwable t) {

            LOGGER.debug("Can't retrieve test feature",t);

        }

        LayoutReportActionImpl report = new LayoutReportActionImpl(theFactory, theStore, f);

        report.getSymbolTable().setVar("$LAYOUT", doc);

        report.getSymbolTable().setVar("$PAGE", 1);

        report.getSymbolTable().setVar("$PAGES", 1);

        return report;        

    }

    private final JsonObject json;

    private final FeatureStore store;

    private FeatureQuery query;

    private FeatureSet selection;

    private Feature current_row;

    private MutableSymbolTable symbolTable;

    private FeatureSymbolTable fSymbolTable;

    private boolean centerToCurrentRow;

    private boolean zoomToCurrentRow;

    private double bufferSize;

    private boolean useInternalPdfViewer;

    private Iterable<Feature> set;

    private int featuresCount;

    private String viewTag;

    private boolean highlightRecord;

    private ISymbol highlightSymbol;

//    private Color fillColor;

//    private Color lineColor;

    @SuppressWarnings("OverridableMethodCallInConstructor")

    private LayoutReportActionImpl(ReportActionFactory factory, FeatureStore store, JsonObject json) {

        super(factory, null);

        this.json = json;

        this.store = store;

        this.selection = null;

        this.query = null;

        this.current_row = null;

        this.setReportName(this.json.getString(LAYOUT_REPORT_NAME, store.getName()));

        this.setReportLabel(this.json.getString(LAYOUT_REPORT_LABEL, this.getReportName()));

        this.highlightRecord = this.json.getBoolean(LAYOUT_REPORT_HIGHLIGHT_RECORD, true);

        this.highlightSymbol = createSymbol(this.json.getString(LAYOUT_REPORT_HIGHLIGHT_SYMBOL, null));

//        this.fillColor = new Color(this.json.getInt(LAYOUT_REPORT_FILL_COLOR, Color.WHITE.getRGB()&(0x2F<<24)));

//        this.lineColor = new Color(this.json.getInt(LAYOUT_REPORT_LINE_COLOR, Color.WHITE.getRGB()));

        this.setCenterToCurrentRow(this.json.getBoolean(LAYOUT_REPORT_CENTER_TO_CURRENT_ROW, true));

        this.setZoomToCurrentRow(this.json.getBoolean(LAYOUT_REPORT_ZOOM_TO_CURRENT_ROW, true));

        this.setBufferSize(0.0);

        if(this.json.containsKey(LAYOUT_REPORT_BUFFER_SIZE)){

            JsonNumber theSize = this.json.getJsonNumber(LAYOUT_REPORT_BUFFER_SIZE);

            if(theSize != null){

                this.setBufferSize(theSize.doubleValue());

            }

        } 

        this.setViewTag(this.json.getString(LAYOUT_REPORT_VIEW_TAG, null));

        this.setUseInternalPdfViewer(this.json.getBoolean(LAYOUT_REPORT_USE_INTERNAL_PDF_VIEWER, true));

    }

    @SuppressWarnings("OverridableMethodCallInConstructor")

    private LayoutReportActionImpl(ReportActionFactory factory, FeatureStore store, Feature feature) {

        // Fake layoutReportAction constructor

        this(

                factory, 

                store, 

                Json.createObjectBuilder()

                .add(LAYOUT_REPORT_NAME, store.getName())

                .add(LAYOUT_REPORT_TYPE, LAYOUT_REPORT_ACTION_NAME)

                .add(LAYOUT_REPORT_LABEL, store.getName())

                .build()

        );

        try {

            this.selection = store.createFeatureSelection();

            ((FeatureSelection)this.selection).select(feature);

        } catch(Throwable t) {

            LOGGER.debug("Can't initialize selection",t);

        }

        this.query = store.createFeatureQuery(feature.createFilter());

        this.current_row = feature;

    }

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public LayoutReportActionImpl(ReportActionFactory factory, FeatureStore store, FeatureQuery query, FeatureSet selection, final JsonObject json) {

        this(factory, store, json);

        this.selection = selection;

        this.query = query;

    }

    public Feature row() {

        return this.current_row;

    }

    private Iterable<Feature> features() {

        if( this.set == null ) {

                if(this.selection == null){

                try {

                    FeatureSet fset = store.getFeatureSet(query);

                    this.featuresCount = fset.size();

                    this.set = fset;

                } catch (DataException ex) {

                    throw new RuntimeException("Can't create dynamic-text report.", ex);

                }

            } else {

                this.featuresCount = this.selection.size();

                if(this.selection instanceof FeatureSelection){

                    this.set = this.store.getFeaturesIterable(((FeatureSelection)this.selection).referenceIterator());

                } else {

                    this.set = this.selection;

                    DisposeUtils.bind(this.set);

                }

            }

        }

        return this.set;

    }

    @Override

    public void actionPerformed(ActionEvent e) {

        if (!this.isEnabled()) {

            return;

        }

        I18nManager i18n = ToolsLocator.getI18nManager();

        final WindowManager_v2 windowManager = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

        final JTaskStatus taskStatusPanel = ToolsSwingLocator.getTaskStatusSwingManager().createJTaskStatus();

        final LayoutReportAction report = this;

        SimpleTaskStatus theStatus = this.getStatus();

        theStatus.setIndeterminate();

        taskStatusPanel.setShowRemoveTaskButton(false);

        taskStatusPanel.bind(theStatus);

        ToolsSwingUtils.ensureRowsCols(taskStatusPanel, 4, 100, 5, 200);

        windowManager.showWindow(

                taskStatusPanel.asJComponent(),

                i18n.getTranslation("_Creating_report")+" '" + this.getReportLabel() + "'...",

                WindowManager.MODE.TOOL

        );

        Thread task = new Thread(() -> {

            List<File> singlePdfFiles = new ArrayList();

            Iterable<Feature> features = null; 

            try {

                String title = this.getReportLabel();

                String creator = "gvSIG-desktop";

                String subject = "Layout report";

                File pdfFile = ToolsLocator.getFoldersManager().getUniqueTemporaryFile("report.pdf");

                        int pag = 0;

                        features = features();

                        theStatus.setRangeOfValues(1, featuresCount);

                        theStatus.message(i18n.getTranslation("_Building_pages"));

                        for (Feature feature : features) {

                            if( theStatus.isCancellationRequested() ) {

                                theStatus.cancel();

                                return;

                            }

                            File f = printReport(feature, ++pag);

                            singlePdfFiles.add(f);

                            theStatus.incrementCurrentValue();

                        }

                        theStatus.message(i18n.getTranslation("_Building_pdf"));

                        PDFManager pdfManager = PDFLocator.getPDFManager();

                        pdfManager.merge(singlePdfFiles, pdfFile, title, creator, subject, theStatus);

                        if (this.isUseInternalPdfViewer()) {

                            this.showEmbedded(pdfFile);

                        } else {

                            this.showExternal(pdfFile);

                        }

                        theStatus.terminate();

                        SwingUtilities.invokeLater(() -> {

                            taskStatusPanel.setVisible(false);

                        });

            } catch (Throwable t) {

                LOGGER.warn("Can't create layout report.", t);

                theStatus.abort();

            } finally {

                for (File singlePdfFile : singlePdfFiles) {

                    singlePdfFile.delete();

                }

                DisposeUtils.disposeQuietly(features);

            }

        }, "Report_" + report.getReportName());

        task.start();

    }

    private File printReport(Feature feature, int page) throws Exception {

        this.current_row = feature;

        final LayoutPanel layout = this.loadTemplate();

        final LayoutContext context = layout.getLayoutContext();

        final Document document = layout.getDocument();

        this.getSymbolTable();

        fSymbolTable.setFeature(current_row);

        this.symbolTable.setVar("$LAYOUT", document);

        this.symbolTable.setVar("$PAGE", page);

        this.symbolTable.setVar("$PAGES", this.featuresCount);

        File pdfFile = null;

        Object previous_report = document.getProperty("$REPORT");

        try {

            document.setProperty("$REPORT", this);

            /*

                TODO: Aqui podriamos consultar en el json para ver si hacemos:

                x zoom al envelope de la geometria de current_row, 

                x si le aplicamos un buffer antes a ese envelop, 

                X si la seleccionamos... 

                - asi como con que vista tenemos que hacerlo. ????

             */

            int count = 1;

            MapContext mapContext = null;

            MapContext mapContextCandidate = null;

            for (IFFrame frame : context.getAllFFrames()) {

                if (frame instanceof FFrameView) {

                    if (mapContextCandidate == null) {

                        mapContextCandidate = ((FFrameView) frame).getMapContext();

                    }

                    String frameTag = frame.getTag();

                    String countTag = "#" + count;

                    if (StringUtils.equalsIgnoreCase(this.getViewTag(), frameTag)

                            || StringUtils.equalsIgnoreCase(this.getViewTag(), countTag)) {

                        mapContext = ((FFrameView) frame).getMapContext();

                        break;

                    }

                }

            }

            if (mapContext == null) {

                mapContext = mapContextCandidate;

            };

            FeatureStore storeInLayout = this.store;

            if (mapContext != null) {

                mapContext.setPrintGraphicsLayer(this.isHighlightRecord());

                ICoordTrans ct = null;

                for (FLayer layer : mapContext.getLayers().getLayers(null)) {

                    if (layer instanceof FLyrVect) {

                        FeatureStore layerStore = ((FLyrVect) layer).getFeatureStore();

                        if (layerStore != null) {

                            if (layerStore.getParameters().isTheSameStore(this.store.getParameters())) {

                                storeInLayout = layerStore;

                                ct = ((FLyrVect) layer).getCoordTrans();

                                break;

                            }

                        }

                    }

                }

                Geometry geom = this.current_row.getDefaultGeometry();

                if (geom != null) {

                    geom = geom.cloneGeometry();

                    if (ct != null && ct.getPOrig().equals(geom.getProjection())) {

                        geom.reProject(ct);

                    } else if (!geom.getProjection().equals(mapContext.getProjection())) {

                        ct = geom.getProjection().getCT(mapContext.getProjection());

                        geom.reProject(ct);

                    }

                    if (isZoomToCurrentRow()) {

                        Envelope envelope = geom

                                .getEnvelope().getGeometry().buffer(getBufferSize()).getEnvelope();

                        mapContext.getViewPort().setEnvelope(envelope);

                    } else if (isCenterToCurrentRow()) {

                        Envelope envelope = geom

                                .getEnvelope().getGeometry().buffer(getBufferSize()).getEnvelope();

                        center(mapContext, envelope);

                    } else {

                        //DO NOTHING ??

                    }

                    if(this.isHighlightRecord()){

                        GraphicLayer graphicsLayer = mapContext.getGraphicsLayer();

                        graphicsLayer.clear();

                        int idSymbol = graphicsLayer.addSymbol(this.highlightSymbol);

                        //TODO: Decidir si aplicamos el simbolo a la geometr?a o al resto

//                        geom = mapContext.getViewPort().getAdjustedEnvelope().getGeometry().difference(geom);

                        graphicsLayer.addGraphic("", geom, idSymbol);

                    }

                }

            }

            context.fullRefresh();

            layout.getLayoutControl().getLayoutDraw().initialize();

            pdfFile = ToolsLocator.getFoldersManager().getUniqueTemporaryFile("report.pdf");

            layout.layoutToPDF(pdfFile);

        } finally {

            document.setProperty("$REPORT", previous_report);

        }

        return pdfFile;

    }

    private void center(MapContext mapContext, Envelope envelope) throws LocatorException, CreateEnvelopeException {

        ViewPort viewPort = mapContext.getViewPort();

        Envelope oldExtent = viewPort.getAdjustedEnvelope();

        double oldCenterX = oldExtent.getCenter(0);

        double oldCenterY = oldExtent.getCenter(1);

        double centerX = envelope.getCenter(0);

        double centerY = envelope.getCenter(1);

        Point2D.Double center = new Point2D.Double(centerX, centerY);

        double movX = centerX - oldCenterX;

        double movY = centerY - oldCenterY;

        double minx = oldExtent.getMinimum(0) + movX;

        double miny = oldExtent.getMinimum(1) + movY;

        double maxX = oldExtent.getMaximum(0) + movX;

        double maxY = oldExtent.getMaximum(1) + movY;

        Envelope extent = GeometryLocator.getGeometryManager().createEnvelope(

                minx, miny,

                maxX, maxY,

                Geometry.SUBTYPES.GEOM2D);

        viewPort.setEnvelope(extent);

    }

    private void showEmbedded(File pdfFile) {

        if (!SwingUtilities.isEventDispatchThread()) {

            SwingUtilities.invokeLater(() -> {

                showEmbedded(pdfFile);

            });

            return;

        }

        try {

            final WindowManager windowManager = ToolsSwingLocator.getWindowManager();

            final PDFSwingManager pdfSwingManager = PDFSwingLocator.getPDFSwingManager();

            final PDFManager pdfManager = PDFLocator.getPDFManager();

            final PDFDocument pdfdoc = pdfManager.createPDFDocument(pdfFile);

            PDFViewer viewer = pdfSwingManager.createPDFViewer();

            viewer.put(pdfdoc);

            viewer.setMode(PDFViewer.MODE_LIGHT);

            JComponent comp = viewer.asJComponent();

            Dimension size = ToolsSwingUtils.ensureRowsCols(comp.getPreferredSize(), 20, 100, 40, 150);

            comp.setSize(size);

            String title = "Report: " + this.getLabel();

            windowManager.showWindow(

                    comp,

                    title,

                    WindowManager.MODE.WINDOW

            );

        } catch (Exception ex) {

            LOGGER.warn("Can't show pdf file '" + Objects.toString(pdfFile) + "'", ex);

            I18nManager i18n = ToolsLocator.getI18nManager();

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            dialogs.messageDialog(

                    i18n.getTranslation("_Cant_show_pdf_file")+" (" + Objects.toString(pdfFile) + ")\n\n"+BaseException.getMessageStack(ex, 0),

                    "Creating report '" + this.getReportLabel() + "'",

                    JOptionPane.WARNING_MESSAGE

            );

        }

    }

    private void showExternal(File pdfFile) {

        if (!SwingUtilities.isEventDispatchThread()) {

            SwingUtilities.invokeLater(() -> {

                showExternal(pdfFile);

            });

            return;

        }

        DesktopOpen desktop = ToolsUtilLocator.getToolsUtilManager().createDesktopOpen();

        desktop.open(pdfFile);

    }

    private LayoutPanel loadTemplate() throws Exception {

        ResourcesStorage resources = store.getResourcesStorage();

        if (resources == null) {

            return null;

        }

        String templateName = this.json.getString(LAYOUT_REPORT_TEMPLATE_NAME, LAYOUT_REPORT_DEFAULT_TEMPLATE_NAME); // "1.layout"...

        ResourcesStorage.Resource resource = resources.getResource(templateName);

        InputStream is = null;

        try {

            is = resource.asInputStream();

            PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

            PersistentState persistentState = persistenceManager.loadState(is);

            LayoutPanel layout = (LayoutPanel) persistenceManager.create(persistentState);

            return layout;

        } finally {

            IOUtils.closeQuietly(is);

        }

    }

    public MutableSymbolTable getSymbolTable() {

        if( this.symbolTable == null ) {

            this.symbolTable = ExpressionUtils.createSymbolTable();

            fSymbolTable = DALLocator.getDataManager().createFeatureSymbolTable();

            fSymbolTable.setFeature(current_row);

            this.symbolTable.addSymbolTable(fSymbolTable);

            this.symbolTable.setVar("$REPORT", this);

        }

        return this.symbolTable;

    }

    @Override

    public String evaluateDynamicText(String s) {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getExpressionEvaluatorManager();

        if( !manager.isDynamicText(s) ) {

            return s;

        }

        String x = manager.evaluateDynamicText(

                this.getSymbolTable(), 

                s, 

                null, 

                this.store.getResourcesStorage()

        );

        return x;

    }

    @Override

    public boolean isCenterToCurrentRow() {

        return this.centerToCurrentRow;

    }

    @Override

    public void setCenterToCurrentRow(boolean centerToCurrentRow) {

        this.centerToCurrentRow = centerToCurrentRow;

    }

    @Override

    public boolean isZoomToCurrentRow() {

        return this.zoomToCurrentRow;

    }

    @Override

    public void setZoomToCurrentRow(boolean zoomToCurrentRow) {

        this.zoomToCurrentRow = zoomToCurrentRow;

    }

    @Override

    public double getBufferSize() {

        return bufferSize;

    }

    @Override

    public void setBufferSize(double bufferSize) {

        this.bufferSize = bufferSize;

    }

    @Override

    public String getViewTag() {

        return viewTag;

    }

    @Override

    public void setViewTag(String viewTag) {

        this.viewTag = viewTag;

    }

    public  boolean isUseInternalPdfViewer() {

        return useInternalPdfViewer;

    }

    @Override

    public void setUseInternalPdfViewer(boolean useInternalPdfViewer) {

        this.useInternalPdfViewer = useInternalPdfViewer;

    }

    @Override

    public boolean isHighlightRecord() {

        return this.highlightRecord;

    }

    @Override

    public void setHighlightRecord(boolean b) {

        this.highlightRecord = b;

    }

    private ISymbol createSymbol(String s) {

        FeatureAttributeDescriptor geomAttr = this.store.getDefaultFeatureTypeQuietly().getDefaultGeometryAttribute();

        if (geomAttr == null) {

            return null;

        }

        int geomType = geomAttr.getGeomType().getType();

        try {

            if (StringUtils.isBlank(s)) {

                return MapContextLocator.getMapContextManager().createSymbol(geomType);

            }

            byte[] bytes = Hex.decodeHex(s.toCharArray());

            PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

            InputStream in = new ByteArrayInputStream(bytes);

            ISymbol symbol = (ISymbol) persistenceManager.getObject(in);

            return symbol;

        } catch (DecoderException ex) {

            return MapContextLocator.getMapContextManager().createSymbol(geomType);

        }

    }

}