Dépôt officiel du code source de l'ERP OpenConcerto

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 package org.openconcerto.openoffice.generation;

import org.openconcerto.openoffice.ODSingleXMLDocument;

import org.openconcerto.openoffice.XMLFormatVersion;

import org.openconcerto.openoffice.generation.desc.ReportPart;

import org.openconcerto.openoffice.generation.desc.ReportType;

import org.openconcerto.openoffice.generation.desc.part.CaseReportPart;

import org.openconcerto.openoffice.generation.desc.part.ConditionalPart;

import org.openconcerto.openoffice.generation.desc.part.ForkReportPart;

import org.openconcerto.openoffice.generation.desc.part.GeneratorReportPart;

import org.openconcerto.openoffice.generation.desc.part.InsertReportPart;

import org.openconcerto.openoffice.generation.desc.part.SubReportPart;

import org.openconcerto.utils.RTInterruptedException;

import org.openconcerto.utils.Tuple2;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.io.IOException;

import java.text.DateFormat;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Stack;

import java.util.concurrent.Callable;

import java.util.concurrent.FutureTask;

import java.util.concurrent.TimeoutException;

import org.jdom.Element;

import org.jdom.JDOMException;

import org.jdom.filter.Filter;

import net.jcip.annotations.GuardedBy;

import ognl.Ognl;

import ognl.OgnlException;

import ognl.OgnlRuntime;

import ognl.PropertyAccessor;

/**

 * Représente la génération d'un rapport.

 *

 * @author Sylvain Cuaz

 * @param <C> type of GenerationCommon

 */

public class ReportGeneration<C extends GenerationCommon> {

    static {

        OgnlRuntime.setPropertyAccessor(Element.class, new PropertyAccessor() {

            public Object getProperty(Map context, Object target, Object name) {

                Element elem = (Element) target;

                String n = (String) name;

                // retourne le premier, TODO collections, attributes

                return elem.getChild(n);

            }

            public void setProperty(Map context, Object target, Object name, Object value) throws OgnlException {

                // impossible

                throw new OgnlException("", new UnsupportedOperationException("setProperty not supported on XML elements"));

            }

        });

    }

    static private final boolean isInterruptedExn(final Throwable e) {

        return e instanceof InterruptedException || e instanceof RTInterruptedException;

    }

    // instance members

    private final ReportType type;

    private C common;

    private XMLFormatVersion formatVersion;

    // Inheritable to allow generators to spawn threads

    private final InheritableThreadLocal<ReportPart> currentParts;

    private final InheritableThreadLocal<DocumentGenerator> currentGenerator;

    @GuardedBy("this")

    private Throwable interruptCause;

    // tous les générateurs s'exécuter dans ce groupe

    @GuardedBy("this")

    private List<Thread> thg;

    private final List<PropertyChangeListener> taskListeners;

    private final PropertyChangeListener taskListener;

    private Map<String, Object> commonData;

    /**

     * Crée une nouvelle instance pour générer un rapport.

     *

     * @param type le type de rapport à générer.

     */

    public ReportGeneration(ReportType type) {

        this.type = new ReportType(type, this);

        // ne pas créer common tout de suite car il peut faire appel à des propriétés initialisées

        // seulement après dans le constructeur d'1 sous classe

        this.common = null;

        this.commonData = null;

        this.currentParts = new InheritableThreadLocal<ReportPart>();

        this.currentGenerator = new InheritableThreadLocal<DocumentGenerator>();

        this.interruptCause = null;

        this.thg = null;

        this.taskListeners = new ArrayList<PropertyChangeListener>();

        this.taskListener = new PropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent evt) {

                for (final PropertyChangeListener l : ReportGeneration.this.taskListeners) {

                    l.propertyChange(evt);

                }

            }

        };

    }

    protected final ODSingleXMLDocument createTaskAndGenerate(GeneratorReportPart part) throws IOException, InterruptedException {

        final GenerationTask task = new GenerationTask(part.getName(), this.getCommon().createGenerator(part));

        task.addPropertyChangeListener(this.taskListener);

        try {

            synchronized (this) {

                this.currentGenerator.set(task.getGenerator());

            }

            final ODSingleXMLDocument res = task.generate();

            synchronized (this) {

                this.currentGenerator.set(null);

            }

            return res;

        } catch (IOException exn) {

            throw new IOException("Impossible de générer '" + part + "'", exn);

        }

    }

    public void addTaskListener(PropertyChangeListener l) {

        this.taskListeners.add(l);

    }

    /**

     * A new document generation has just begun.

     */

    protected void beginGeneration() {

    }

    /**

     * Whether to insert a page break between report parts. This implementation always return

     * <code>true</code>.

     *

     * @return <code>true</code> if a page break should be inserted.

     */

    protected boolean pageBreak() {

        return true;

    }

    /**

     * The GenerationCommon needed for this generation. This implementation just returns a

     * {@link GenerationCommon}.

     *

     * @param name name of the requested common.

     * @return the corresponding common.

     */

    @SuppressWarnings("unchecked")

    protected C createCommon(String name) {

        return (C) new GenerationCommon<ReportGeneration<?>>(this);

    }

    /**

     * Génére le rapport.

     *

     * @return le fichier généré, ou <code>null</code> si interruption.

     * @throws Throwable si erreur lors de la génération.

     */

    public final ODSingleXMLDocument generate() throws Throwable {

        final Map<String, ODSingleXMLDocument> res = this.generateMulti();

        if (res.size() != 1)

            throw new IllegalStateException("more than one document: " + res);

        else

            return res.get(null);

    }

    /**

     * Generate a report with multiple documents. The main document has the <code>null</code> ID.

     *

     * @return the generated documents, indexed by ID, or <code>null</code> if interrupted.

     * @throws Throwable if an error occurs.

     * @see #generate()

     */

    public final Map<String, ODSingleXMLDocument> generateMulti() throws Throwable {

        synchronized (this) {

            this.interruptCause = null;

            this.thg = new ArrayList<>();

        }

        Map<String, ODSingleXMLDocument> f = null;

        final FutureTask<Map<String, ODSingleXMLDocument>> future = new FutureTask<Map<String, ODSingleXMLDocument>>(new Callable<Map<String, ODSingleXMLDocument>>() {

            public Map<String, ODSingleXMLDocument> call() throws Exception {

                return createDocument();

            }

        });

        // Don't pass a ThreadGroup, since every thread created, including "cache timeout", JDBC

        // threads will be in it. But these threads must out-live this generation.

        final Thread thr = new Thread(null, future);

        this.registerThread(thr);

        thr.start();

        try {

            f = future.get();

        } catch (Exception e) {

            assert f == null;

            // If one thread was interrupted (or failed), interrupt the others

            this.interrupt(e);

        } finally {

            // Make sure all threads are stopped and don't prevent this from being garbage

            // collected.

            final List<Thread> toJoin;

            synchronized (this) {

                toJoin = this.thg;

                this.thg = null;

            }

            for (final Thread t : toJoin) {

                // If no exception occurred, then should already be finished but if there was one in

                // a thread, another thread might be stuck on some I/O for a while before it can

                // process the interrupt.

                t.join(4500);

                if (t.isAlive())

                    throw new TimeoutException("Thread still not terminated : " + t);

            }

        }

        final Map<String, ODSingleXMLDocument> res;

        synchronized (this) {

            if (this.interruptCause != null && !isInterruptedExn(this.interruptCause)) {

                throw this.interruptCause;

            } else if (Thread.currentThread().isInterrupted()) {

                res = null;

            } else {

                res = f;

            }

        }

        if (res != null) {

            for (final Entry<String, ODSingleXMLDocument> e : res.entrySet()) {

                this.getCommon().postProcessDocument(e.getValue());

            }

        }

        return res;

    }

    public final synchronized void registerThread(final Thread thr) {

        this.thg.add(thr);

    }

    protected final void interrupt(Throwable cause) {

        synchronized (this) {

            if (this.interruptCause == null) {

                this.interruptCause = cause;

                for (final Thread thr : this.thg) {

                    thr.interrupt();

                }

            }

        }

    }

    private Map<String, ODSingleXMLDocument> createDocument() throws IOException, OgnlException, InterruptedException {

        // recompute common data for each run

        this.commonData = null;

        this.beginGeneration();

        final ODSingleXMLDocument emptyDocument = this.createEmptyDocument();

        synchronized (this) {

            this.formatVersion = emptyDocument.getFormatVersion();

        }

        final Map<String, ODSingleXMLDocument> res = new HashMap<String, ODSingleXMLDocument>();

        res.put(null, emptyDocument);

        // les threads

        final Map<String, GenThread> forked = new HashMap<String, GenThread>();

        // a stack to handle SubReportPart (and their optional document)

        final Stack<Tuple2<Iterator<ReportPart>, ODSingleXMLDocument>> s = new Stack<Tuple2<Iterator<ReportPart>, ODSingleXMLDocument>>();

        s.push(Tuple2.create(this.type.getParts().iterator(), res.get(null)));

        while (hasNext(s) && !Thread.currentThread().isInterrupted()) {

            final Iterator<ReportPart> i = s.peek().get0();

            final ODSingleXMLDocument currentDoc = s.peek().get1();

            final ReportPart part = i.next();

            // always set current part, so that the condition can use it.

            synchronized (this) {

                this.currentParts.set(part);

            }

            if (this.mustGenerate(part)) {

                if (part instanceof ForkReportPart) {

                    GenThread thread = new GenThread(part.getName(), ((ForkReportPart) part).getChildren());

                    forked.put(part.getName(), thread);

                    this.registerThread(thread);

                    thread.start();

                } else if (part instanceof SubReportPart) {

                    final SubReportPart subReportPart = (SubReportPart) part;

                    // the document for <sub>

                    final ODSingleXMLDocument newDoc;

                    final String docID = subReportPart.getDocumentID();

                    if (docID == null) {

                        newDoc = currentDoc;

                    } else if (res.containsKey(docID)) {

                        newDoc = res.get(docID);

                    } else if (subReportPart.isSinglePart()) {

                        newDoc = null;

                        res.put(docID, this.createTaskAndGenerate(((GeneratorReportPart) subReportPart.getChildren().iterator().next())));

                    } else {

                        newDoc = this.createEmptyDocument();

                        res.put(docID, newDoc);

                    }

                    // ajoute ses enfants

                    if (newDoc != null)

                        s.push(Tuple2.create(subReportPart.getChildren().iterator(), newDoc));

                } else if (part instanceof InsertReportPart) {

                    final GenThread thread = forked.get(part.getName());

                    if (thread == null)

                        throw new IllegalStateException(part.getName() + " has not been forked previously.");

                    final List<ODSingleXMLDocument> forkedList = thread.getRes();

                    if (forkedList == null) {

                        Thread.currentThread().interrupt();

                    } else {

                        for (final ODSingleXMLDocument doc : forkedList) {

                            add(currentDoc, doc);

                        }

                    }

                } else if (part instanceof CaseReportPart) {

                    s.push(Tuple2.create(((CaseReportPart) part).evaluate(this).iterator(), currentDoc));

                } else {

                    add(currentDoc, this.createTaskAndGenerate(((GeneratorReportPart) part)));

                }

            }

            synchronized (this) {

                this.currentParts.set(null);

            }

        }

        synchronized (this) {

            this.formatVersion = null;

        }

        return res;

    }

    private boolean hasNext(final Stack<Tuple2<Iterator<ReportPart>, ODSingleXMLDocument>> s) {

        if (s.peek().get0().hasNext())

            return true;

        else {

            // the current iterator is done, so remove it

            s.pop();

            if (s.isEmpty())

                return false;

            else

                return this.hasNext(s);

        }

    }

    private ODSingleXMLDocument createEmptyDocument() throws IOException, InterruptedException {

        final ODSingleXMLDocument f;

        final DocumentGenerator templateGenerator = this.getCommon().getStyleTemplateGenerator(this.type.getTemplate());

        if (templateGenerator == null)

            try {

                f = ODSingleXMLDocument.createFromPackage(this.type.getTemplate());

            } catch (JDOMException e) {

                throw new IOException("invalid template " + this.type.getTemplate(), e);

            }

        else

            f = templateGenerator.generate();

        // seulement intéressé par les styles et les user fields

        // TODO y passer dans fwk OO

        f.getBody().removeContent(new Filter() {

            public boolean matches(Object obj) {

                if (obj instanceof Element) {

                    final Element elem = (Element) obj;

                    final boolean isUserField = elem.getNamespace().equals(f.getVersion().getTEXT()) && elem.getName().equals("user-field-decls");

                    return !isUserField;

                } else

                    return true;

            }

        });

        this.getCommon().preProcessDocument(f);

        assert f != null;

        return f;

    }

    private final void add(final ODSingleXMLDocument f, final ODSingleXMLDocument toAdd) {

        // whether the added document is the first following the style template

        f.add(toAdd, f.getNumero() > 0 && pageBreak());

    }

    private final boolean mustGenerate(ReportPart part) throws OgnlException {

        if (part instanceof ConditionalPart) {

            final ConditionalPart p = (ConditionalPart) part;

            return p.getCondition() == null || evaluatePredicate(p.getCondition());

        } else

            return true;

    }

    public final boolean evaluatePredicate(String p) throws OgnlException {

        return ((Boolean) Ognl.getValue(p, getCommonData())).booleanValue();

    }

    /**

     * Une thread qui pour une liste de générateurs.

     */

    private class GenThread extends Thread {

        private final List m;

        private final List<ODSingleXMLDocument> res;

        public GenThread(String name, List generators) {

            super(name);

            this.m = generators;

            this.res = new ArrayList<ODSingleXMLDocument>(generators.size());

        }

        public void run() {

            final Iterator i = this.m.iterator();

            try {

                while (i.hasNext() && !Thread.currentThread().isInterrupted()) {

                    // ATTN les fork ne peuvent être imbriqués

                    final GeneratorReportPart part = (GeneratorReportPart) i.next();

                    this.res.add(ReportGeneration.this.createTaskAndGenerate(part));

                }

            } catch (Exception e) {

                ReportGeneration.this.interrupt(e);

            }

        }

        /**

         * Retourne la liste des documents générés.

         *

         * @return la liste, ou bien <code>null</code> s'il y a interruption.

         */

        public final List<ODSingleXMLDocument> getRes() {

            // on s'assure d'avoir fini

            try {

                if (!this.isInterrupted()) {

                    this.join();

                    return this.res;

                }

            } catch (InterruptedException exn) {

                // justement on fait rien

            }

            return null;

        }

    }

    // *** getter

    /**

     * Ognl data used in the evaluation of conditions among other things.

     *

     * @return a map of objects.

     */

    public final Map<String, Object> getCommonData() {

        if (this.commonData == null) {

            // set it before initializing it, that way even if initCommonData() needs a previous

            // value stored it won't loop infinitely (eg initCommonData() has

            // { put("a", "A") ; put("bPlus", getReportType().getParam("b")+"Plus"); }

            // and "b" is defined as a + "B" )

            this.commonData = new HashMap<String, Object>();

            this.initCommonData(this.commonData);

        }

        return Collections.unmodifiableMap(this.commonData);

    }

    protected void initCommonData(final Map<String, Object> res) {

        res.put("rg", this);

        res.put("variante", this.getReportType().getParam("variante"));

        res.put("dateFmt", DateFormat.getDateInstance(DateFormat.LONG));

        try {

            res.put("join", Ognl.getValue(":[@org.openconcerto.utils.CollectionUtils@join( #this, #sep == null ? ', ' : #sep )]", null));

            res.put("silentFirst", Ognl.getValue(":[#this.size == 0 ? null : #this[0]]", null));

        } catch (OgnlException exn) {

            // n'arrive jamais, la syntaxe est correcte

            exn.printStackTrace();

        }

    }

    public synchronized final XMLFormatVersion getFormatVersion() {

        return this.formatVersion;

    }

    @Override

    public String toString() {

        return "generation of '" + this.getReportType() + "'";

    }

    public final C getCommon() {

        if (this.common == null)

            this.common = this.createCommon(this.type.getCommon());

        return this.common;

    }

    public final ReportType getReportType() {

        return this.type;

    }

    public synchronized final ReportPart getCurrentPart() {

        return this.currentParts.get();

    }

    public synchronized final DocumentGenerator getCurrentGenerator() {

        return this.currentGenerator.get();

    }

}