/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
 */
package com.megatim.reporting.adhoc.process;

import com.megatim.dynamic.reports.pojo.DisplayCondition;
import com.megatim.reporting.adhoc.pojo.Constantes;
import com.megatim.reporting.adhoc.pojo.components.Border;
import com.megatim.reporting.adhoc.pojo.components.Component;
import com.megatim.reporting.adhoc.pojo.components.Image;
import com.megatim.reporting.adhoc.pojo.components.Label;
import com.megatim.reporting.adhoc.pojo.components.Line;
import com.megatim.reporting.adhoc.pojo.components.Paragraph;
import com.megatim.reporting.adhoc.pojo.components.TextField;
import com.megatim.reporting.adhoc.pojo.components.ValueElement;
import com.megatim.reporting.adhoc.pojo.enums.ReportOrientation;
import static com.megatim.reporting.adhoc.pojo.enums.ValueElementType.FIELD;
import static com.megatim.reporting.adhoc.pojo.enums.ValueElementType.GENERATE;
import static com.megatim.reporting.adhoc.pojo.enums.ValueElementType.PARAMETER;
import com.megatim.reporting.adhoc.pojo.layouts.ColumnData;
import com.megatim.reporting.adhoc.pojo.layouts.ColumnHeader;
import com.megatim.reporting.adhoc.pojo.layouts.MainReport;
import com.megatim.reporting.adhoc.pojo.layouts.PageFooter;
import com.megatim.reporting.adhoc.pojo.layouts.PageHeader;
import com.megatim.reporting.adhoc.pojo.layouts.Report;
import com.megatim.reporting.adhoc.pojo.layouts.SubReport;
import com.megatim.reporting.adhoc.pojo.layouts.Title;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.List;
import java.util.UUID;

/**
 *
 * @author ASUS
 */
public class GenerateJRXML {

//    private final String JRXML_EXTENSION = "jrxml";
    private final String REPORT_PARTS = "report-parts";

    private final ClassLoader classLoader = GenerateJRXML.class.getClassLoader();

    public void generateJrxml(Report report, String jrxmlFolder) throws Exception {
        Path jrxmlPath = Paths.get(jrxmlFolder, report.getName() + ".jrxml");

        generateReport(report, jrxmlPath);

        for (SubReport sub : report.getSubReports()) {
            jrxmlPath = Paths.get(jrxmlFolder, sub.getName() + ".jrxml");

            generateReport(sub, jrxmlPath);
        }

    }

    private void generateReport(MainReport report, Path reportPath) throws Exception {

        try ( BufferedWriter bufferWriter = Files.newBufferedWriter(reportPath, StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.SYNC)) {

            bufferWriter.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + System.lineSeparator());

            bufferWriter.write("<jasperReport xmlns=\"http://jasperreports.sourceforge.net/jasperreports\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "
                    + "xsi:schemaLocation=\"http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd\" "
                    + "name=\"" + report.getName() + "\" pageWidth=\"" + report.getPageWidth() + "\" pageHeight=\"" + report.getPageHeight() + "\"" + orientation(report.getOrientation())
                    + "columnWidth=\"" + report.getColumnWidth() + "\" leftMargin=\"" + report.getLeftMargin() + "\" rightMargin=\"" + report.getRightMargin() + "\" topMargin=\"" + report.getTopMargin() + "\" "
                    + "bottomMargin=\"" + report.getBottomMargin() + "\"" + setWhenResourceMissingType(report.getWhenResourceMissingType())
                    + setWhenNoDataType(report.getWhenNoDataType())
                    + "uuid=\"" + UUID.randomUUID() + "\">" + System.lineSeparator());

            addPageProperties(bufferWriter);

            addParameters(report, bufferWriter);

            addFields(report, bufferWriter);

            addVariables(bufferWriter);

            addGroups(bufferWriter);

            addtitle(report.getTitle(), bufferWriter);

            addPageHeader(report.getPageHeader(), bufferWriter);

            if (report.isDetail()) {
                if (report instanceof Report) {
                    Report rep = (Report) report;
                    addDetailDetail(report.getColumnHeader(), report.getColumnData(), rep.getSubReports(), bufferWriter);

                } else {
                    addDetailDetail(report.getColumnHeader(), report.getColumnData(), null, bufferWriter);
                }

            } else {
                addListeColumnHeader(report.getColumnHeader(), bufferWriter);

                if (report instanceof Report) {
                    Report rep = (Report) report;
                    addListeDetail(report.getColumnData(), rep.getSubReports(), bufferWriter);

                } else {
                    addListeDetail(report.getColumnData(), null, bufferWriter);
                }
            }

            addPageFooter(report.getPageFooter(), bufferWriter);

            bufferWriter.write("</jasperReport>");

        }
    }

    private void addPageProperties(BufferedWriter bufferWriter) throws IOException {
        InputStream inputStream = classLoader.getResourceAsStream(REPORT_PARTS + "/page-properties.xml");
        readFile(inputStream, bufferWriter);
    }

    /**
     * Méthode qui ajoute les paramètres à l'état
     *
     * @param bufferWriter
     * @throws IOException
     */
    private void addParameters(MainReport report, BufferedWriter bufferWriter) throws IOException {
        InputStream inputStream = classLoader.getResourceAsStream(REPORT_PARTS + "/parameters.xml");
        readFile(inputStream, bufferWriter);

        for (ValueElement param : report.getParameters().values()) {
            bufferWriter.write("\t<parameter name=\"" + param.getName() + setClasse(param.getClasse()) + " isForPrompting=\"false\"/>" + System.lineSeparator());
        }

        bufferWriter.write("" + System.lineSeparator());
    }

    /**
     * Méthode qui ajoute les champs de l'entité à l'état
     *
     * @param bufferWriter
     */
    private void addFields(MainReport report, BufferedWriter bufferWriter) throws IOException {

        for (ValueElement field : report.getFields().values()) {
            bufferWriter.write("\t<field name=\"" + field.getName() + setClasse(field.getClasse()) + ">" + System.lineSeparator());
            bufferWriter.write("\t\t<fieldDescription><![CDATA[" + field.getName() + "]]></fieldDescription>" + System.lineSeparator());
            bufferWriter.write("\t</field>" + System.lineSeparator());
        }

        bufferWriter.write("\t" + System.lineSeparator());
    }

    /**
     * Méthode qui ajoute les variables
     *
     * @param bufferWriter
     * @throws IOException
     */
    private void addVariables(BufferedWriter bufferWriter) throws IOException {
        InputStream inputStream = classLoader.getResourceAsStream(REPORT_PARTS + "/variables.xml");
        readFile(inputStream, bufferWriter);
    }

    /**
     * Méthode qui ajoute les groupes
     *
     * @param bufferWriter
     * @throws IOException
     */
    private void addGroups(BufferedWriter bufferWriter) throws IOException {
        InputStream inputStream = classLoader.getResourceAsStream(REPORT_PARTS + "/groups.xml");
        readFile(inputStream, bufferWriter);
    }

    private void addtitle(Title title, BufferedWriter bufferWriter) throws Exception {

        if (title != null) {
            bufferWriter.write("\t <title>" + System.lineSeparator());
            bufferWriter.write("\t\t <band height=\"" + title.getHeight() + setSplitType(title.getSplitType()) + " >" + System.lineSeparator());
            bufferWriter.write("\t\t\t <property name=\"com.jaspersoft.studio.unit.height\" value=\"px\"/>" + System.lineSeparator());

            addComponents(title.getComponents(), bufferWriter);

            bufferWriter.write("\t\t </band>" + System.lineSeparator());
            bufferWriter.write("\t </title>" + System.lineSeparator());
        }

    }

    private void addPageHeader(PageHeader pageHeader, BufferedWriter bufferWriter) throws Exception {

        if (pageHeader != null) {
            bufferWriter.write("\t <pageHeader>" + System.lineSeparator());
            bufferWriter.write("\t\t <band height=\"" + pageHeader.getHeight() + setSplitType(pageHeader.getSplitType()) + " >" + System.lineSeparator());
            bufferWriter.write("\t\t <property name=\"com.jaspersoft.studio.unit.height\" value=\"px\"/>" + System.lineSeparator());

            addComponents(pageHeader.getComponents(), bufferWriter);

            bufferWriter.write("\t\t </band>" + System.lineSeparator());
            bufferWriter.write("\t </pageHeader>" + System.lineSeparator());
        }
    }

    private void addListeColumnHeader(ColumnHeader columnHeader, BufferedWriter bufferWriter) throws Exception {

        if (columnHeader != null) {
            bufferWriter.write("\t <columnHeader>" + System.lineSeparator());
            bufferWriter.write("\t\t <band height=\"" + columnHeader.getHeight() + setSplitType(columnHeader.getSplitType()) + " >" + System.lineSeparator());
            bufferWriter.write("\t\t <property name=\"com.jaspersoft.studio.unit.height\" value=\"px\"/>" + System.lineSeparator());

            addComponents(columnHeader.getComponents(), bufferWriter);

            bufferWriter.write("\t\t </band>" + System.lineSeparator());
            bufferWriter.write("\t </columnHeader>" + System.lineSeparator());
        }
    }

    private void addListeDetail(ColumnData columnData, List<SubReport> subReports, BufferedWriter bufferWriter) throws Exception {

        if (columnData != null || (subReports != null && !subReports.isEmpty())) {

            bufferWriter.write("\t <detail>" + System.lineSeparator());

            addListeColumnData(columnData, bufferWriter);

            addSubReports(subReports, bufferWriter);

            bufferWriter.write("\t </detail>" + System.lineSeparator());
        }
    }

    private void addDetailDetail(ColumnHeader columnHeader, ColumnData columnData, List<SubReport> subReports, BufferedWriter bufferWriter) throws Exception {
        bufferWriter.write("\t <detail>" + System.lineSeparator());

        if ((columnData != null && columnHeader != null)) {

            bufferWriter.write("\t\t <band height=\"" + columnData.getHeight() + setSplitType(columnData.getSplitType()) + " >" + System.lineSeparator());
            bufferWriter.write("\t\t <property name=\"com.jaspersoft.studio.unit.height\" value=\"px\"/>" + System.lineSeparator());

            addComponents(columnData.getComponents(), bufferWriter);
            addComponents(columnHeader.getComponents(), bufferWriter);

            bufferWriter.write("\t\t </band>" + System.lineSeparator());

        }
        if (subReports != null && !subReports.isEmpty()) {
            addSubReports(subReports, bufferWriter);
        }
        bufferWriter.write("\t </detail>" + System.lineSeparator());
    }

    private void addListeColumnData(ColumnData columnData, BufferedWriter bufferWriter) throws Exception {

        if (columnData != null) {
            bufferWriter.write("\t\t <band height=\"" + columnData.getHeight() + setSplitType(columnData.getSplitType()) + " >" + System.lineSeparator());
            bufferWriter.write("\t\t <property name=\"com.jaspersoft.studio.unit.height\" value=\"px\"/>" + System.lineSeparator());

            addComponents(columnData.getComponents(), bufferWriter);

            bufferWriter.write("\t\t </band>" + System.lineSeparator());
        }

    }

    private void addSubReports(List<SubReport> subReports, BufferedWriter bufferWriter) throws Exception {

        if (subReports != null && !subReports.isEmpty()) {

            for (SubReport sub : subReports) {
                bufferWriter.write("\t\t <band height=\"" + sub.getHeight() + setSplitType(sub.getSplitType()) + " >" + System.lineSeparator());
                bufferWriter.write("\t\t\t <property name=\"com.jaspersoft.studio.unit.height\" value=\"px\"/>" + System.lineSeparator());
                bufferWriter.write("\t\t\t<subreport isUsingCache=\"" + sub.isUsingCache() + "\" runToBottom=\"" + sub.isRunToBottom() + "\""
                        + setOverflowType(sub.getOverflowType()) + ">" + System.lineSeparator());
                bufferWriter.write("\t\t\t\t<reportElement stretchType=\"" + sub.getStretchType() + "\" x=\"" + sub.getX() + "\" y=\"" + sub.getY() + "\" width=\"" + sub.getWidth()
                        + "\" height=\"" + sub.getHeight() + "\" isPrintInFirstWholeBand=\"" + sub.isPrintInFirtWholeBand() + "\" isPrintWhenDetailOverflows=\"" + sub.isPrintWhenDetailOverflows()
                        + "\" uuid=\"" + UUID.randomUUID() + "\">" + System.lineSeparator());

                writeUnits(bufferWriter);

                bufferWriter.write("\t\t\t\t</reportElement>" + System.lineSeparator());

                bufferWriter.write("\t\t\t\t<dataSourceExpression><![CDATA[new net.sf.jasperreports.engine.data.JRBeanCollectionDataSource($F{" + sub.getDataSource() + "})]]></dataSourceExpression>" + System.lineSeparator());
                bufferWriter.write("\t\t\t\t<subreportExpression><![CDATA[$P{SUBREPORT_DIR} + \"" + sub.getName() + ".jasper\"]]></subreportExpression>" + System.lineSeparator());
                bufferWriter.write("\t\t\t</subreport>" + System.lineSeparator());
                bufferWriter.write("\t\t</band>" + System.lineSeparator());
            }
        }
    }

    private void addPageFooter(PageFooter pageFooter, BufferedWriter bufferWriter) throws Exception {

        if (pageFooter != null) {
            bufferWriter.write("\t <pageFooter>" + System.lineSeparator());
            bufferWriter.write("\t\t <band height=\"" + pageFooter.getHeight() + setSplitType(pageFooter.getSplitType()) + ">" + System.lineSeparator());
            bufferWriter.write("\t\t <property name=\"com.jaspersoft.studio.unit.height\" value=\"px\"/>" + System.lineSeparator());

            addComponents(pageFooter.getComponents(), bufferWriter);

            bufferWriter.write("\t\t </band>" + System.lineSeparator());
            bufferWriter.write("\t </pageFooter>" + System.lineSeparator());
        }
    }

    private void setComponentBorder(Border border, BufferedWriter bufferWriter) throws IOException {

        if (border != null && (border.getLeftBorder() > 0 || border.getTopBorder() > 0 || border.getRightBorder() > 0 || border.getBottomBorder() > 0)) {

            bufferWriter.write("\t\t\t\t<box ");

            if (border.getLeftPadding() > 0) {
                bufferWriter.write("leftPadding=\"" + border.getLeftPadding() + "\" ");
            }
            if (border.getRightPadding() > 0) {
                bufferWriter.write("rightPadding=\"" + border.getRightPadding() + "\" ");
            }
            if (border.getTopPadding() > 0) {
                bufferWriter.write("topPadding=\"" + border.getTopPadding() + "\"");
            }
            if (border.getBottomPadding() > 0) {
                bufferWriter.write("bottomPadding=\"" + border.getBottomPadding() + "\"");
            }
            bufferWriter.write(" >" + System.lineSeparator());
            bufferWriter.write("\t\t\t\t\t<pen");

            bufferWriter.write(setLineStyle(border.getLineStyle()));
            bufferWriter.write(setLineColor(border.getLineColor()));

            bufferWriter.write("/>" + System.lineSeparator());

            if (border.getTopBorder() > 0) {
                bufferWriter.write("\t\t\t\t\t<topPen lineWidth=\"" + border.getTopBorder() + "\"/>" + System.lineSeparator());
            }
            if (border.getLeftBorder() > 0) {
                bufferWriter.write("\t\t\t\t\t<leftPen lineWidth=\"" + border.getLeftBorder() + "\"/>" + System.lineSeparator());
            }
            if (border.getBottomBorder() > 0) {
                bufferWriter.write("\t\t\t\t\t<bottomPen lineWidth=\"" + border.getBottomBorder() + "\"/>" + System.lineSeparator());
            }
            if (border.getRightBorder() > 0) {
                bufferWriter.write("\t\t\t\t\t<rightPen lineWidth=\"" + border.getRightBorder() + "\"/>" + System.lineSeparator());
            }

            bufferWriter.write("\t\t\t\t</box>" + System.lineSeparator());
        }
    }

    private String setSplitType(String splitType) {

        if (splitType != null && !splitType.isEmpty()) {
            return "\" splitType=\"" + splitType + "\" ";

        } else {
            return "";
        }
    }

    private String setClasse(Class<?> classe) {

        if (classe != null) {
            return "\" class=\"" + classe.getName() + "\" ";

        } else {
            return "java.lang.String";
        }
    }

    private String setForeColor(String color) {

        if (color != null && !color.isEmpty()) {
            return " forecolor=\"" + color + "\" ";

        } else {
            return "";
        }

    }

    private String setLineColor(String color) {
        StringBuilder colorMessage = new StringBuilder("");

        if (color != null && !color.isEmpty()) {
            colorMessage.append(" lineColor=\"").append(color).append("\" ");

        } else {
            colorMessage.append(" lineColor=\"#000000\" ");
        }

        return colorMessage.toString();
    }

    private String setLineStyle(String lineStyle) {
        StringBuilder lineMessage = new StringBuilder(" lineWidth=\"1.0\" ");

        if (lineStyle != null && !lineStyle.isEmpty()) {
            lineMessage.append("lineStyle=\"").append(lineStyle).append("\" ");

        } else {
            lineMessage.append("lineStyle=\"Solid\" ");
        }
        return lineMessage.toString();
    }

    private void addComponents(List<Component> components, BufferedWriter bufferWriter) throws Exception {

        for (Component c : components) {

            if (c instanceof Image) {

                Image image = (Image) c;
                addImage(image, bufferWriter);

            } else if (c instanceof TextField) {

                TextField textField = (TextField) c;
                addTextField(textField, bufferWriter);

            } else if (c instanceof Label) {

                Label label = (Label) c;
                addLabel(label, bufferWriter);

            } else if (c instanceof Line) {

                Line line = (Line) c;
                addLine(line, bufferWriter);

            }
        }
    }

    private void writeValueElement(BufferedWriter bufferWriter, ValueElement valueElt) throws IOException, InstantiationException, IllegalAccessException {

        if (valueElt != null) {
            switch (valueElt.getValueElementType()) {

                case PARAMETER:
                    bufferWriter.write("$P{" + valueElt.getName() + "}");
                    break;

                case FIELD:
                    bufferWriter.write("$F{" + valueElt.getName() + "}");
                    break;

                case GENERATE:
                    bufferWriter.write(generateValue(valueElt));
                    break;

                default:
                    bufferWriter.write(valueElt.getValue());
                    break;

            }
        } else {
            bufferWriter.write("" + null);
        }
    }

    //Génère une instance de la classe java.util.Date()
    private String generateValue(ValueElement valueElt) throws InstantiationException, IllegalAccessException {
        Class classe = valueElt.getClasse();

        return "new " + classe.getName() + "()";

    }

    private void writeUnits(BufferedWriter bufferWriter) throws IOException {
        bufferWriter.write("\t\t\t\t\t<property name=\"com.jaspersoft.studio.unit.x\" value=\"px\"/>" + System.lineSeparator());
        bufferWriter.write("\t\t\t\t\t<property name=\"com.jaspersoft.studio.unit.width\" value=\"px\"/>" + System.lineSeparator());
        bufferWriter.write("\t\t\t\t\t<property name=\"com.jaspersoft.studio.unit.y\" value=\"px\"/>" + System.lineSeparator());
        bufferWriter.write("\t\t\t\t\t<property name=\"com.jaspersoft.studio.unit.height\" value=\"px\"/>" + System.lineSeparator());
    }

    private void readFile(InputStream inputStream, BufferedWriter bufferWriter) throws IOException {

        try ( InputStreamReader isr = new InputStreamReader(inputStream, StandardCharsets.UTF_8);  BufferedReader reader = new BufferedReader(isr)) {

            String line = "";

            while ((line = reader.readLine()) != null) {
                bufferWriter.write(line + System.lineSeparator());
            }
        }
    }

    private void addImage(Image image, BufferedWriter bufferWriter) throws Exception {

        if (image != null) {
            bufferWriter.write("\t\t<image scaleImage=\"" + image.getScaleImage() + "\" hAlign=\"" + image.gethAlign() + "\" vAlign=\"" + image.getvAlign() + "\">" + System.lineSeparator());
            bufferWriter.write("\t\t\t<reportElement x=\"" + image.getX() + "\" y=\"" + image.getY() + "\" width=\"" + image.getWidth() + "\" height=\"" + image.getHeight()
                    + setStretchType(image.getStretchType()) + "\" uuid=\"" + UUID.randomUUID() + "\">" + System.lineSeparator());

            writeUnits(bufferWriter);

            bufferWriter.write(setPrintWhenExpression(image.getDisplayCondition()) + System.lineSeparator());

            bufferWriter.write("\t\t\t\t</reportElement>" + System.lineSeparator());

            setComponentBorder(image.getBorder(), bufferWriter);

            bufferWriter.write("\t\t\t<graphicElement fill=\"Solid\"/>" + System.lineSeparator());
            bufferWriter.write("\t\t\t<imageExpression><![CDATA[");

            ValueElement valueElt = image.getValueElement();

            writeValueElement(bufferWriter, valueElt);

            bufferWriter.write("]]></imageExpression>" + System.lineSeparator());
            bufferWriter.write("\t\t</image>" + System.lineSeparator());
        }
    }

    private void addTextField(TextField textField, BufferedWriter bufferWriter) throws Exception {

        if (textField != null) {
            bufferWriter.write("\t\t\t<textField " + addEvaluationTime(textField) + addPattern(textField.getPattern()) + " isBlankWhenNull=\"" + textField.isBlankWhenNull() + "\""
                    + " textAdjust=\"" + textField.getTextAdjust() + "\">" + System.lineSeparator());
            bufferWriter.write("\t\t\t\t <reportElement x=\"" + textField.getX() + "\" y=\"" + textField.getY() + "\" width=\"" + textField.getWidth() + "\" height=\"" + textField.getHeight() + "\""
                    + " isRemoveLineWhenBlank=\"" + textField.isRemoveLineWhenBlank() + "\"" + setForeColor(textField.getForeColor()) + setStretchType(textField.getStretchType()) + " isPrintInFirstWholeBand=\"" + textField.isPrintInFirtWholeBand()
                    + "\" isPrintWhenDetailOverflows=\"" + textField.isPrintWhenDetailOverflows() + "\"" + " uuid=\"" + UUID.randomUUID() + "\">" + System.lineSeparator());

            writeUnits(bufferWriter);

            bufferWriter.write(setPrintWhenExpression(textField.getDisplayCondition()) + System.lineSeparator());

            bufferWriter.write("\t\t\t\t</reportElement>" + System.lineSeparator());

            setComponentBorder(textField.getBorder(), bufferWriter);

            bufferWriter.write("\t\t\t\t<textElement textAlignment=\"" + textField.gethAlign() + "\" verticalAlignment=\"" + textField.getvAlign() + "\">" + System.lineSeparator());
            bufferWriter.write("\t\t\t\t\t<font fontName=\"" + textField.getFontName() + "\" size=\"" + textField.getSize() + "\" isBold=\"" + textField.isBold() + "\" isUnderline=\"" + textField.isUnderLine() + "\""
                    + "/>" + System.lineSeparator());

            bufferWriter.write(setParagraph(textField.getParagraph()) + System.lineSeparator());

            bufferWriter.write("\t\t\t\t</textElement>" + System.lineSeparator());
            bufferWriter.write("\t\t\t\t<textFieldExpression><![CDATA[");

            if (textField.isLineNumber()) {
                bufferWriter.write("String.valueOf($V{LINE_NUMBER})");

            } else if (textField.isPageNumber()) {
                bufferWriter.write("\" Page \"+String.valueOf($V{REPORT_PAGE})+\" / \"+String.valueOf($V{PAGE_NUMBER})");
            } else {
                ValueElement valueElt = textField.getValueElement();
                writeValueElement(bufferWriter, valueElt);
            }

            bufferWriter.write("]]></textFieldExpression>" + System.lineSeparator());
            bufferWriter.write("\t\t\t</textField>" + System.lineSeparator());
        }

    }

    private String addEvaluationTime(TextField textField) {

        if (textField.isPageNumber()) {
            return " evaluationTime=\"Auto\" ";

        } else {
            return "";
        }
    }

    private String addPattern(String pattern) {

        if (pattern != null && !pattern.isEmpty()) {
            return " pattern=\"" + pattern + "\" ";

        } else {
            return "";
        }
    }

    private void addLabel(Label label, BufferedWriter bufferWriter) throws IOException {

        if (label != null) {
            bufferWriter.write("\t\t\t<staticText>" + System.lineSeparator());
            bufferWriter.write("\t\t\t\t <reportElement x=\"" + label.getX() + "\" y=\"" + label.getY() + "\" width=\"" + label.getWidth() + "\" height=\"" + label.getHeight() + "\""
                    + setStretchType(label.getStretchType()) + setForeColor(label.getForeColor()) + " uuid=\"" + UUID.randomUUID() + "\">" + System.lineSeparator());

            writeUnits(bufferWriter);

            bufferWriter.write(setPrintWhenExpression(label.getDisplayCondition()) + System.lineSeparator());

            bufferWriter.write("\t\t\t\t</reportElement>" + System.lineSeparator());

            setComponentBorder(label.getBorder(), bufferWriter);

            bufferWriter.write("\t\t\t\t<textElement textAlignment=\"" + label.gethAlign() + "\" verticalAlignment=\"" + label.getvAlign() + "\">" + System.lineSeparator());
            bufferWriter.write("\t\t\t\t\t<font fontName=\"" + label.getFontName() + "\" size=\"" + label.getSize() + "\" isBold=\"" + label.isBold() + "\" isUnderline=\"" + label.isUnderLine() + "\""
                    + "/>" + System.lineSeparator());

            bufferWriter.write(setParagraph(label.getParagraph()) + System.lineSeparator());

            bufferWriter.write("\t\t\t\t</textElement>" + System.lineSeparator());

            bufferWriter.write("\t\t\t\t<text><![CDATA[" + label.getValue() + "]]></text>" + System.lineSeparator());
            bufferWriter.write("\t\t\t</staticText>" + System.lineSeparator());
        }
    }

    private void addLine(Line line, BufferedWriter bufferWriter) throws IOException {

        if (line != null) {
            bufferWriter.write("\t\t\t<line>" + System.lineSeparator());
            bufferWriter.write("\t\t\t\t <reportElement x=\"" + line.getX() + "\" y=\"" + line.getY() + "\" width=\"" + line.getWidth() + "\" height=\"" + line.getHeight()
                    + setStretchType(line.getStretchType()) + "\" isRemoveLineWhenBlank=\"true\"" + " forecolor=\"" + line.getForeColor() + "\" uuid=\"" + UUID.randomUUID() + "\">" + System.lineSeparator());

            writeUnits(bufferWriter);

            bufferWriter.write(setPrintWhenExpression(line.getDisplayCondition()) + System.lineSeparator());

            bufferWriter.write("\t\t\t\t</reportElement>" + System.lineSeparator());

            bufferWriter.write("\t\t\t\t<graphicElement>" + System.lineSeparator());
            bufferWriter.write("\t\t\t\t\t<pen lineWidth=\"" + line.getLineWidth() + "\" lineStyle=\"" + line.getLineStyle()
                    + "\"/>" + System.lineSeparator());
            bufferWriter.write("\t\t\t\t</graphicElement>" + System.lineSeparator());
            bufferWriter.write("\t\t\t</line>" + System.lineSeparator());
        }
    }

    private String setStretchType(String stretchType) {

        if (stretchType != null && !stretchType.isEmpty()) {
            return " stretchType=\"" + stretchType + "\"";

        } else {
            return "";
        }

    }

    private String setWhenNoDataType(String whenNoDataType) {

        if (whenNoDataType != null && !whenNoDataType.isEmpty()) {
            return " whenNoDataType=\"" + whenNoDataType + "\" ";

        } else {
            return "";
        }
    }

    private String setWhenResourceMissingType(String whenResourceMissingType) {

        if (whenResourceMissingType != null && !whenResourceMissingType.isEmpty()) {
            return " whenResourceMissingType=\"" + whenResourceMissingType + "\" ";

        } else {
            return "";
        }
    }

    private String setOverflowType(String overflowType) {
        if (overflowType != null && !overflowType.isEmpty()) {
            return " overflowType=\"" + overflowType + "\" ";

        } else {
            return "";
        }
    }

    private String setPrintWhenExpression(DisplayCondition condition) {
        StringBuilder chaine = new StringBuilder();

        if (condition != null && condition.getLeftOperand() != null && condition.getRightOperand() != null && condition.getOperator() != null && condition.getOperandType() != null
                && !condition.getLeftOperand().isEmpty() && !condition.getRightOperand().isEmpty() && !condition.getOperator().isEmpty() && !condition.getOperandType().isEmpty()) {

            chaine.append("<printWhenExpression><![CDATA[$");

            if (condition.getOperandType().equalsIgnoreCase(Constantes.OPERAND_TYPE_VARIABLE)) {
                chaine.append("V");

            } else if (condition.getOperandType().equalsIgnoreCase(Constantes.OPERAND_TYPE_PARAMETER)) {
                chaine.append("P");

            } else if (condition.getOperandType().equalsIgnoreCase(Constantes.OPERAND_TYPE_FIELD)) {
                chaine.append("F");
            }
            chaine.append("{").append(condition.getLeftOperand()).append("} ").append(condition.getOperator()).append(condition.getRightOperand());
            chaine.append("]]></printWhenExpression>");

            return chaine.toString();

        } else {
            return "";
        }
    }

    private String setParagraph(Paragraph paragraph) {
        StringBuilder chaine = new StringBuilder("");

        if (paragraph != null) {
            chaine.append("\t\t\t\t\t<paragraph ");

            if (paragraph.getLineSpacing() != null && !paragraph.getLineSpacing().isEmpty()) {
                chaine.append("lineSpacing=\"").append(paragraph.getLineSpacing()).append("\" ");
            }
            chaine.append("lineSpacingSize=\"").append(paragraph.getLineSpacingSize()).append("\" ");
            chaine.append("firstLineIndent=\"").append(paragraph.getFirstLineIndent()).append("\" ");
            chaine.append("leftIndent=\"").append(paragraph.getLeftIndent()).append("\" ");
            chaine.append("rightIndent=\"").append(paragraph.getRightIndent()).append("\" ");
            chaine.append("spacingBefore=\"").append(paragraph.getSpacingBefore()).append("\" ");
            chaine.append("spacingAfter=\"").append(paragraph.getSpacingAfter()).append("\" ");
            chaine.append("/>");
        }
        return chaine.toString();
    }

    private String orientation(ReportOrientation orientation) {
        if (orientation != null && orientation.equals(ReportOrientation.LANDSCAPE)) {
            return " orientation=\"" + ReportOrientation.LANDSCAPE.toString() + "\" ";
        } else {
            return " ";
        }
    }
}