# -*- coding: utf-8 -*-

import logging
import tempfile

from flask import request, Response, json, render_template
from flask.views import MethodView

from py3o.template import Template

from PyPDF2 import PdfFileMerger

log = logging.getLogger(__name__)

ALLOWED_FORMATS = ["pdf", "doc", "docx", "odt"]

PDF_MIMETYPE = "application/pdf"

MIMETYPES = {
    "odt": "application/vnd.oasis.opendocument.text",
    "doc": "application/msword",
    "docx": "application/vnd.openxmlformats-officedocument"
    ".wordprocessingml.document",
    "pdf": PDF_MIMETYPE,
}

DEFAULT_MIMETYPE = "application/octet-stream"


class ConvertView(MethodView):

    def __init__(self, pyuno_driver_name="", hostname="localhost", port=2001):
        driver_module = self._load_driver_module(pyuno_driver_name)
        self.convertor = driver_module.Convertor(hostname, port)

    def _load_driver_module(self, pyuno_driver_name):
        return __import__(pyuno_driver_name, globals(), locals(),
                          ["Convertor"])

    def is_format_supported(self, fformat):
        return fformat and fformat.lower() in ALLOWED_FORMATS

    def post(self):
        ffile = request.files['file']
        if not ffile.filename:
            return "Please upload a file for conversion", 401

        fformat = request.form['format']
        if not self.is_format_supported(fformat):
            return "Format %s not allowed" % fformat, 401

        datadict = self.get_datadict()

        mimetype = self.get_mimetype_for_format(fformat)

        outfile = self.save_form_file(ffile)

        if datadict:
            try:
                tfile = tempfile.NamedTemporaryFile()
                t = Template(outfile, tfile)
                t.render(datadict)
                outfile.close()
                outfile = tfile
            except:
                log.exception("Template error")
                return "Template error", 500

        if fformat != "odt":
            try:
                outfile = self.convert(outfile, fformat)
            except:
                log.exception("Conversion error")
                return "Conversion error", 500

        return Response(outfile, mimetype=mimetype)

    def get(self):
        return render_template("convert.html")

    def save_form_file(self, infile):
        outfile = tempfile.NamedTemporaryFile()
        infile.save(outfile)
        infile.close()
        outfile.seek(0)
        return outfile

    def convert(self, infile, fformat):
        outfile = tempfile.NamedTemporaryFile()

        self.convertor.convert(infile.name, outfile.name, fformat)

        infile.close()
        return outfile

    def get_mimetype_for_format(self, fformat):
        return MIMETYPES.get(fformat, DEFAULT_MIMETYPE)

    def get_datadict(self):
        vars = request.form.get('datadict')
        if not vars:
            return None
        return json.loads(vars)


class MergeView(MethodView):

    def get(self):
        return render_template("merge.html")

    def post(self):
        merger = PdfFileMerger()
        ffiles = request.files.getlist('files')

        for ffile in ffiles:
            merger.append(ffile)

        outfile = tempfile.NamedTemporaryFile()

        merger.write(outfile.name)

        merger.close()
        return Response(outfile, mimetype=PDF_MIMETYPE)


class TemplateView(MethodView):

    template_name = ""

    def __init__(self, template_name=None):
        if template_name:
            self.template_name = template_name

    def get_template_name(self):
        return self.template_name

    def get(self):
        return render_template(self.get_template_name())