# -*- coding: utf-8 -*-
#
# This file is part of the qpageview package.
#
# Copyright (c) 2019 - 2019 by Wilbert Berendsen
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
# See http://www.gnu.org/licenses/ for more information.

"""
Export Pages to different file formats.
"""

import os

from PyQt5.QtCore import QBuffer, QIODevice, QMimeData, QPoint, QSizeF, Qt, QUrl
from PyQt5.QtGui import QDrag, QGuiApplication, QImage, QPageSize, QPdfWriter

from . import poppler
from . import util


class AbstractExporter:
    """Base class to export a rectangular area of a Page to a file.

    Specialized subclasses implement each format.

    You instantiate a subclass with a Page and a rectangle. The rectangle may
    be None, to specify the full page. After instantiation, you can set
    attributes to configure the export. The following attributes are supported::

        resolution = 300
        autocrop = False
        oversample = 1
        grayscale = False
        paperColor = None
        forceVector = True  # force the render backend to be Arthur for
                            # exporting PDF pages to vector-based formats

    After setting the attributes, you call one or more of save(), copyData(),
    copyFile(), mimeData() or tempFileMimeData(), which will trigger the export
    because they internally call data(), which caches its return value until
    setPage() is called again.

    Not all exporters support all attributes, the supportXXX attributes specify
    whether an attribute is supported or not.

    """
    # user settings:
    resolution = 300
    antialiasing = True
    autocrop = False
    oversample = 1
    grayscale = False
    paperColor = None
    forceVector = True  # force the render backend to be Arthur for PDF pages

    # properties of exporter:
    wantsVector = True
    supportsResolution = True
    supportsAntialiasing = True
    supportsAutocrop = True
    supportsOversample = True
    supportsGrayscale = True
    supportsPaperColor = True

    mimeType = "application/octet-stream"
    filename = ""
    defaultBasename = "document"
    defaultExt = ""

    def __init__(self, page, rect=None):
        self.setPage(page, rect)

    def setPage(self, page, rect=None):
        self._page = page.copy()
        if self._page.renderer:
            self._page.renderer = page.renderer.copy()
        self._rect = rect
        self._result = None   # where the exported object is stored
        self._tempFile = None
        self._autoCropRect = None
        self._document = None
        self._pixmap = None

    def page(self):
        """Return our page, setting the renderer to our preferences."""
        p = self._page.copy()
        p.paperColor = self.paperColor
        if self._page.renderer:
            p.renderer = self._page.renderer.copy()
            p.renderer.paperColor = self.paperColor
            p.renderer.antialiasing = self.antialiasing
            if self.forceVector and self.wantsVector and \
                    isinstance(p, poppler.PopplerPage) and poppler.popplerqt5:
                p.renderer.printRenderBackend = \
                    poppler.popplerqt5.Poppler.Document.ArthurBackend
        return p

    def autoCroppedRect(self):
        """Return the rect, autocropped if desired."""
        if not self.autocrop:
            return self._rect
        if self._autoCropRect is None:
            p = self._page
            dpiX = p.width / p.defaultSize().width() * p.dpi
            dpiY = p.height / p.defaultSize().height() * p.dpi
            image = p.image(self._rect, dpiX, dpiY)
            rect = util.autoCropRect(image)
            # add one pixel to prevent loosing small joins or curves etc
            rect = image.rect() & rect.adjusted(-1, -1, 1, 1)
            if self._rect is not None:
                rect.translate(self._rect.topLeft())
            self._autoCropRect = rect
        return self._autoCropRect

    def export(self):
        """Perform the export, based on the settings, and return the exported data object."""

    def successful(self):
        """Return True when export was successful."""
        return self.data() is not None

    def data(self):
        """Return the export result, assuming it is binary data of the exported file."""
        if self._result is None:
            self._result = self.export()
        return self._result

    def document(self):
        """Return a one-page Document to display the image to export.

        Internally calls createDocument(), and caches the result, setting the
        papercolor to the papercolor attribute if the exporter supports
        papercolor.

        """
        if self._document is None:
            doc = self._document = self.createDocument()
            if self.paperColor and self.paperColor.isValid():
                for p in doc.pages():
                    p.paperColor = self.paperColor
        return self._document

    def createDocument(self):
        """Create and return a one-page Document to display the image to export."""

    def renderer(self):
        """Return a renderer for the document(). By default, None is returned."""
        return None

    def copyData(self):
        """Copy the QMimeData() to the clipboard."""
        QGuiApplication.clipboard().setMimeData(self.mimeData())

    def mimeData(self):
        """Return a QMimeData() object representing the exported data."""
        data = QMimeData()
        data.setData(self.mimeType, self.data())
        return data

    def save(self, filename):
        """Save the exported image to a file."""
        with open(filename, "wb") as f:
            f.write(self.data())

    def suggestedFilename(self):
        """Return a suggested file name for the file to export.

        The name is based on the filename (if set) and also contains the
        directory path. But the name will never be the same as the filename
        set in the filename attribute.

        """
        if self.filename:
            base = os.path.splitext(self.filename)[0]
            name = base + self.defaultExt
            if name == self.filename:
                name = base + "-export" + self.defaultExt
        else:
            name = self.defaultBasename + self.defaultExt
        return name

    def tempFilename(self):
        """Save data() to a tempfile and returns the filename."""
        if self._tempFile is None:
            if self.filename:
                basename = os.path.splitext(os.path.basename(self.filename))[0]
            else:
                basename = self.defaultBasename
            d = util.tempdir()
            fname = self._tempFile = os.path.join(d, basename + self.defaultExt)
            self.save(fname)
        return self._tempFile

    def tempFileMimeData(self):
        """Save the exported image to a temp file and return a QMimeData object for the url."""
        data = QMimeData()
        data.setUrls([QUrl.fromLocalFile(self.tempFilename())])
        return data

    def copyFile(self):
        """Save the exported image to a temp file and copy its name to the clipboard."""
        QGuiApplication.clipboard().setMimeData(self.tempFileMimeData())

    def pixmap(self, size=100):
        """Return a small pixmap to use for dragging etc."""
        if self._pixmap is None:
            paperColor = self.paperColor if self.supportsPaperColor else None
            page = self.document().pages()[0]
            self._pixmap = page.pixmap(paperColor=paperColor)
        return self._pixmap

    def drag(self, parent, mimeData):
        """Called by dragFile and dragData. Execs a QDrag on the mime data."""
        d = QDrag(parent)
        d.setMimeData(mimeData)
        d.setPixmap(self.pixmap())
        d.setHotSpot(QPoint(-10, -10))
        return d.exec_(Qt.CopyAction)

    def dragData(self, parent):
        """Start dragging the data. Parent can be any QObject."""
        return self.drag(parent, self.mimeData())

    def dragFile(self, parent):
        """Start dragging the data. Parent can be any QObject."""
        return self.drag(parent, self.tempFileMimeData())


class ImageExporter(AbstractExporter):
    """Export a rectangular area of a Page (or the whole page) to an image."""
    wantsVector = False
    defaultBasename = "image"
    defaultExt = ".png"

    def export(self):
        """Create the QImage representing the exported image."""
        res = self.resolution
        if self.oversample != 1:
            res *= self.oversample
        i = self.page().image(self._rect, res, res, self.paperColor)
        if self.oversample != 1:
            i = i.scaled(i.size() / self.oversample, transformMode=Qt.SmoothTransformation)
        if self.grayscale:
            i = i.convertToFormat(QImage.Format_Grayscale8)
        if self.autocrop:
            i = i.copy(util.autoCropRect(i))
        return i

    def image(self):
        return self.data()

    def createDocument(self):
        from . import image
        return image.ImageDocument([self.image()], self.renderer())

    def copyData(self):
        QGuiApplication.clipboard().setImage(self.image())

    def mimeData(self):
        data = QMimeData()
        data.setImageData(self.image())
        return data

    def save(self, filename):
        if not self.image().save(filename):
            raise OSError("Could not save image")


class SvgExporter(AbstractExporter):
    """Export a rectangular area of a Page (or the whole page) to a SVG file."""
    mimeType = "image/svg"
    supportsGrayscale = False
    supportsOversample = False
    defaultBasename = "image"
    defaultExt = ".svg"

    def export(self):
        rect = self.autoCroppedRect()
        buf = QBuffer()
        buf.open(QBuffer.WriteOnly)
        success = self.page().svg(buf, rect, self.resolution, self.paperColor)
        buf.close()
        if success:
            return buf.data()

    def createDocument(self):
        from . import svg
        return svg.SvgDocument([self.data()], self.renderer())


class PdfExporter(AbstractExporter):
    """Export a rectangular area of a Page (or the whole page) to a PDF file."""
    mimeType = "application/pdf"
    supportsGrayscale = False
    supportsOversample = False
    defaultExt = ".pdf"

    def export(self):
        rect = self.autoCroppedRect()
        buf = QBuffer()
        buf.open(QBuffer.WriteOnly)
        success = self.page().pdf(buf, rect, self.resolution, self.paperColor)
        buf.close()
        if success:
            return buf.data()

    def createDocument(self):
        from . import poppler
        return poppler.PopplerDocument(self.data(), self.renderer())


class EpsExporter(AbstractExporter):
    """Export a rectangular area of a Page (or the whole page) to an EPS file."""
    mimeType = "application/postscript"
    supportsGrayscale = False
    supportsOversample = False
    defaultExt = ".eps"

    def export(self):
        rect = self.autoCroppedRect()
        buf = QBuffer()
        buf.open(QBuffer.WriteOnly)
        success = self.page().eps(buf, rect, self.resolution, self.paperColor)
        buf.close()
        if success:
            return buf.data()

    def createDocument(self):
        from . import poppler
        rect = self.autoCroppedRect()
        buf = QBuffer()
        buf.open(QBuffer.WriteOnly)
        success = self.page().pdf(buf, rect, self.resolution, self.paperColor)
        buf.close()
        return poppler.PopplerDocument(buf.data(), self.renderer())


def pdf(filename, pageList, resolution=72, paperColor=None):
    """Export the pages in pageList to a PDF document.

    filename can be a string or any QIODevice. The pageList is a list of the
    Page objects to export.

    Normally vector graphics are rendered, but in cases where that is not
    possible, the resolution will be used to determine the DPI for the
    generated rendering.

    The computedRotation attribute of the pages is used to determine the
    rotation.

    Make copies of the pages if you run this function in a background thread.

    """
    pdf = QPdfWriter(filename)
    pdf.setCreator("qpageview")
    pdf.setResolution(resolution)

    for n, page in enumerate(pageList):
        # map to the original page
        source = page.pageRect()
        # scale to target size
        w = source.width() * page.scaleX
        h = source.height() * page.scaleY
        if page.computedRotation & 1:
            w, h = h, w
        targetSize = QSizeF(w, h)
        if n:
            pdf.newPage()
        layout = pdf.pageLayout()
        layout.setMode(layout.FullPageMode)
        layout.setPageSize(QPageSize(targetSize * 72.0 / page.dpi, QPageSize.Point))
        pdf.setPageLayout(layout)
        # TODO handle errors?
        page.output(pdf, source, paperColor)