/*
 * Copyright (c) 2011 by RibbonSoft, GmbH. All rights reserved.
 * 
 * This file is part of the QCAD project.
 *
 * Licensees holding valid QCAD Professional Edition licenses 
 * may use this file in accordance with the QCAD License
 * Agreement provided with the Software.
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, 
 * INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS 
 * FOR A PARTICULAR PURPOSE.
 * 
 * See http://www.ribbonsoft.com for further details.
 */

/**
 * Command line tool.
 * Exports a drawing file (DWG, DXF) into a PDF with several configurations for layer, scale and offset.
 *
 * TODO points are not visible (why?)
 * TODO invisible layers inside blocks are printed (why?!?)
 * TODO allow other page sizes than DIN A4
 * TODO clean up directory refrences
 */

include("/opt/qcad-3.0.0-rc2-prof-linux/scripts/File/Print/Print.js");

//printConfig is an array, each entry results in one page
//  each entry is an array with three entries: scale (0.01 means 1:100), layer name to find center of page, array of layer names visible
var printConfig = [
  [0.004, "DINA4_1_250", ["DINA4_1_250", "NORD_VERSION"]],
  [0.01, "DINA4_1_100", ["DINA4_1_100", "EG_WAND", "EG_WAND_FILL", "EG_INFO", "NORD_VERSION"]],
];

function MyPrint(guiAction, document, view) {
    Print.call(this, guiAction, document, view);
    this.di = new RDocumentInterface(document);
}

MyPrint.prototype.print = function(pdfFile) {
    var printer = new QPrinter(QPrinter.HighResolution);
    printer.setOutputFormat(QPrinter.PdfFormat);
    printer.setOutputFileName(pdfFile);
    printer.setPaperSize(new QSizeF(297, 210));
    printer.setFullPage(true);
    printer.setOrientation(QPrinter.Landscape);
    printer.setColorMode(QPrinter.Color);

    var bgColor = this.view.getBackgroundColor();
    this.view.setBackgroundColor(new RColor("white"));
    this.view.setPrinting(true);

    var painter = new QPainter();
    painter.begin(printer);

    var layers = this.document.queryAllLayers();

    //debug: print layer names
    /*for (var ld = 0; ld < layers.length; ++ld) {
        qDebug("Layer " + ld + " with id " + layers[ld] + ": " + this.document.queryLayer(layers[ld]).getName());
    }*/

    for (var page = 0; page < printConfig.length; ++page) {
        qDebug("adjusting scale, offset and layers for page: ", page + 1);
        //get scale and offset
        var scale = printConfig[page][0];
        var offsetLayerName = printConfig[page][1];
        var offset = null;
        for (var ol = 0; ol < layers.length; ++ol) {
            var offsetLayer = this.document.queryLayer(layers[ol]);
            if (offsetLayerName === offsetLayer.getName()) {
                var bBox = new RBox();
                var entities = this.document.queryLayerEntities(layers[ol]);
                for (var es = 0; es < entities.length; ++es) {
                    var entity = this.document.queryEntityDirect(entities[es]);
                    bBox.growToInclude(entity.getBoundingBox());
                }
                if (bBox.isValid()) {
                    offset = bBox.getCenter().move(new RVector(-297/scale/2, -210/scale/2));
                    //qDebug("offset is ", offset);
                }
                break;
            }
        }
        if (offset === null) {
            qDebug("offset layer not found or without entities: ", offsetLayerName);
            break;
        }
        //set visibility of all layers
        var enabledLayers = printConfig[page][2];
        var operation = new RModifyObjectsOperation();
        for (var l = 0; l < layers.length; ++l) {
            var layer = this.document.queryLayer(layers[l]);
            var frozen = true;
            for (var i = 0; i < enabledLayers.length; ++i) {
                if (enabledLayers[i] === layer.getName()) {
                    frozen = false;
                    break;
                }
            }
            //qDebug("page " + page + " layer " + layer.getName() + " is " + (frozen ? "frozen" : "visible"));
            layer.setFrozen(frozen);
            operation.addObject(layer);
        }
        //do operations and print this single page
        this.di.applyOperation(operation);
        this.di.clearPreview();
        this.di.repaintViews();
        if (page != 0) { //if this is not the first page, add new page
            printer.newPage();
        }
        qDebug("printing page: ", page + 1);
        this.doPrint(printer, painter, scale, offset);
        qDebug("page done: ", page + 1);
    }

    painter.end();
    printer.destroy();

    this.view.setBackgroundColor(bgColor);
    this.view.setPrinting(false);

    qDebug("printing finished");
};

MyPrint.prototype.doPrint = function(printer, painter, scale, offset) {
    var c = Print.getBackgroundColor(this.document);
    var qclr = new QColor(c.red(),c.green(),c.blue());
    if (!qclr.equals(new QColor(Qt.white))) {
        painter.setWorldTransform(new QTransform());
        painter.setBackground(new QBrush(qclr, Qt.SolidPattern));
        painter.eraseRect(printer.paperRect());
    }

    // paper size in mm:
    var unitScale = Print.getUnitScale(this.document);
    var widthInMM = printer.paperRect(QPrinter.Millimeter).width();
    var heightInMM = printer.paperRect(QPrinter.Millimeter).height();
    var paperBorder = new QRectF(0, 0, widthInMM, heightInMM);

    // get transformed paper border and printerFactor
    var paperBorderTransformed = paperBorder.translated(0,0);
    paperBorderTransformed.setLeft(paperBorderTransformed.left()/scale/unitScale);
    paperBorderTransformed.setRight(paperBorderTransformed.right()/scale/unitScale);
    paperBorderTransformed.setTop(paperBorderTransformed.top()/scale/unitScale);
    paperBorderTransformed.setBottom(paperBorderTransformed.bottom()/scale/unitScale);
    paperBorderTransformed = paperBorderTransformed.translated(offset.x, offset.y);
    var printerFactor = new RVector(
        printer.paperRect().width() / widthInMM,
        printer.paperRect().height() / heightInMM
    );

    // set up transform
    var transform = new QTransform();
    // move zero to bottom left corner, set up X/Y axis:
    transform.scale(1, -1);

    // scale to printer units:
    transform.scale(printerFactor.x, printerFactor.y);
    transform.translate(-paperBorder.x(), -paperBorder.y()-paperBorder.height());

    // apply user defined offset and scale:
    transform.translate(-offset.x*scale*unitScale, -offset.y*scale*unitScale);
    transform.scale(scale, scale);

    // scale drawing unit to mm, apply transformation to painter
    transform.scale(unitScale, unitScale);
    painter.setWorldTransform(transform);

    // paint visible entities (not cropped, but entities which are completely outside the box are not printed)
    this.view.paintEntities(painter, new RBox(
            new RVector(paperBorderTransformed.x(), paperBorderTransformed.y()),
            new RVector(paperBorderTransformed.x() + paperBorderTransformed.width(),
                paperBorderTransformed.y() + paperBorderTransformed.height())));
};

function main() {
    qApp.organizationName = "RibbonSoft";
    qApp.organizationDomain = "ribbonsoft.com";
    qApp.applicationVersion = RSettings.getVersionString();
    qApp.applicationName = "QCAD";
    RSettings.setApplicationName("QCAD3");
    
    RDwgImporter.registerFileImporter();

    var dwgFile = "yourInFile.dxf";
    var pdfFile = "yourOutFile.pdf";;

    var storage = new RMemoryStorage();
    var spatialIndex = new RSpatialIndexNavel();
    var doc = new RDocument(storage, spatialIndex);
    var di = new RDocumentInterface(doc);

    var scene = new RGraphicsSceneQt(di);
    var view = new RGraphicsViewImage();
    view.setScene(scene);

    if (di.importFile(dwgFile) != RDocumentInterface.IoErrorNoError) {
        qWarning("Cannot import file:", dwgFile);
        return;
    }

    di.regenerateScenes();

    QCoreApplication.processEvents();

    var p = new MyPrint(undefined, doc, view);
    p.print(pdfFile);
}

if (typeof(including)=='undefined' || including===false) {
    main();
}