# This file is part of Tryton.  The COPYRIGHT file at the top level of
# this repository contains the full copyright notices and license terms.
import datetime
import inspect
import logging
import math
import operator
import os
import subprocess
import tempfile
import time
import unicodedata
import warnings
import zipfile
from email.message import EmailMessage
from io import BytesIO
from itertools import groupby

import dateutil.tz

try:
    import html2text
except ImportError:
    html2text = None

try:
    import weasyprint
except ImportError:
    weasyprint = None

from genshi.filters import Translator
from genshi.template.text import TextTemplate

from trytond.exceptions import UserError
from trytond.i18n import gettext
from trytond.pool import Pool, PoolBase
from trytond.rpc import RPC
from trytond.tools import slugify
from trytond.transaction import Transaction, check_access
from trytond.url import URLMixin

try:
    from trytond.tools import barcode
except ImportError:
    barcode = None
try:
    from trytond.tools import qrcode
except ImportError:
    qrcode = None

warnings.simplefilter("ignore")
import relatorio.reporting  # noqa: E402

warnings.resetwarnings()
try:
    from relatorio.templates.opendocument import MANIFEST, Manifest
except ImportError:
    Manifest, MANIFEST = None, None

logger = logging.getLogger(__name__)

MIMETYPES = {
    'odt': 'application/vnd.oasis.opendocument.text',
    'odp': 'application/vnd.oasis.opendocument.presentation',
    'ods': 'application/vnd.oasis.opendocument.spreadsheet',
    'odg': 'application/vnd.oasis.opendocument.graphics',
    'txt': 'text/plain',
    'xml': 'text/xml',
    'html': 'text/html',
    'xhtml': 'text/xhtml',
    }
FORMAT2EXT = {
    'doc6': 'doc',
    'doc95': 'doc',
    'docbook': 'xml',
    'docx7': 'docx',
    'ooxml': 'xml',
    'latex': 'ltx',
    'sdc4': 'sdc',
    'sdc3': 'sdc',
    'sdd3': 'sdd',
    'sdd4': 'sdd',
    'sdw4': 'sdw',
    'sdw3': 'sdw',
    'sxd3': 'sxd',
    'sxd5': 'sxd',
    'text': 'txt',
    'xhtml': 'html',
    'xls5': 'xls',
    'xls95': 'xls',
    }

TIMEDELTA_DEFAULT_CONVERTER = {
    's': 1,
    }
TIMEDELTA_DEFAULT_CONVERTER['m'] = TIMEDELTA_DEFAULT_CONVERTER['s'] * 60
TIMEDELTA_DEFAULT_CONVERTER['h'] = TIMEDELTA_DEFAULT_CONVERTER['m'] * 60
TIMEDELTA_DEFAULT_CONVERTER['d'] = TIMEDELTA_DEFAULT_CONVERTER['h'] * 24
TIMEDELTA_DEFAULT_CONVERTER['w'] = TIMEDELTA_DEFAULT_CONVERTER['d'] * 7
TIMEDELTA_DEFAULT_CONVERTER['M'] = TIMEDELTA_DEFAULT_CONVERTER['d'] * 30
TIMEDELTA_DEFAULT_CONVERTER['Y'] = TIMEDELTA_DEFAULT_CONVERTER['d'] * 365

NO_BREAKING_SPACE = '\u00A0'

# For most OS maximum filename is 255 but Excel has a limitation which include
# the path of 218.
# As on Windows report is most likely to be open from
# C:\Users\<username>\AppData\Local\Temp\tryton_<random>\ which has a length of
# 56 with 12 for username and 8 for random. So 162 should be the maximum but we
# round it to 100.
REPORT_NAME_MAX_LENGTH = 100


class TranslateFactory:

    def __init__(self, report_name, translation):
        self.report_name = report_name
        self.translation = translation

    def __call__(self, text):
        return self.translation.get_report(self.report_name, text)


class Report(URLMixin, PoolBase):

    @classmethod
    def __setup__(cls):
        super(Report, cls).__setup__()
        cls.__rpc__ = {
            'execute': RPC(),
            }

    @classmethod
    def check_access(cls):
        pool = Pool()
        ActionReport = pool.get('ir.action.report')
        User = pool.get('res.user')

        if Transaction().user == 0:
            return

        groups = set(User.get_groups())
        report_groups = ActionReport.get_groups(cls.__name__)
        if report_groups and not groups & report_groups:
            raise UserError('Calling report %s is not allowed!' % cls.__name__)

    @classmethod
    def header_key(cls, record):
        return ()

    @classmethod
    def execute(cls, ids, data):
        '''
        Execute the report on record ids.
        The dictionary with data that will be set in local context of the
        report.
        It returns a tuple with:
            report type,
            data,
            a boolean to direct print,
            the report name (with or without the record names)
        '''
        pool = Pool()
        ActionReport = pool.get('ir.action.report')
        ModelAccess = pool.get('ir.model.access')
        cls.check_access()
        context = Transaction().context
        ids = list(map(int, ids))

        action_id = data.get('action_id')
        if action_id is None:
            action_reports = ActionReport.search([
                    ('report_name', '=', cls.__name__)
                    ])
            assert action_reports, '%s not found' % cls
            action_report = action_reports[0]
        else:
            action_report = ActionReport(action_id)

        def report_name(records, reserved_length=0):
            names = []
            name_length = 0
            record_count = len(records)
            max_length = (REPORT_NAME_MAX_LENGTH
                - reserved_length
                - len(str(record_count)) - 2)
            if action_report.record_name:
                template = TextTemplate(action_report.record_name)
            else:
                template = None
            for record in records[:5]:
                if template:
                    record_name = template.generate(record=record).render()
                else:
                    record_name = record.rec_name
                name_length += len(
                    unicodedata.normalize('NFKD', record_name)) + 1
                if name_length > max_length:
                    break
                names.append(record_name)

            name = '-'.join(names)
            if len(records) > len(names):
                name += '__' + str(record_count - len(names))
            return name

        records = []
        model = action_report.model or data.get('model')
        if model:
            records = cls._get_records(ids, model, data)

        with check_access():
            if model:
                Model = pool.get(model)
                ModelAccess.check(model, 'read')
                # Check read access
                Model.read(ids, ['id'])

        if not records:
            groups = [[]]
            headers = [{}]
        elif action_report.single:
            groups = [[r] for r in records]
            headers = [dict(cls.header_key(r)) for r in records]
        else:
            groups = []
            headers = []
            for key, group in groupby(records, key=cls.header_key):
                groups.append(list(group))
                headers.append(dict(key))

        n = len(groups)
        join_string = '-'
        if n > 1:
            padding = math.ceil(math.log10(n))
            content = BytesIO()
            with zipfile.ZipFile(content, 'w') as content_zip:
                for i, (header, group_records) in enumerate(
                        zip(headers, groups), 1):
                    oext, rcontent = cls._execute(
                        group_records, header, data, action_report)
                    number = str(i).zfill(padding)
                    filename = report_name(
                        group_records, len(number) + len(join_string))
                    filename = slugify(join_string.join([number, filename]))
                    rfilename = '%s.%s' % (filename, oext)
                    content_zip.writestr(rfilename, rcontent)
            content = content.getvalue()
            oext = 'zip'
        else:
            oext, content = cls._execute(
                groups[0], headers[0], data, action_report)
        if not isinstance(content, str):
            content = bytearray(content) if bytes == str else bytes(content)
        action_report_name = action_report.name[:REPORT_NAME_MAX_LENGTH]
        if context.get('with_rec_name', True):
            filename = join_string.join(
                filter(None, [
                    action_report_name,
                    report_name(
                        records, len(action_report_name) + len(join_string))]))
        else:
            filename = action_report_name
        return (oext, content, action_report.direct_print, filename)

    @classmethod
    def _execute(cls, records, header, data, action):
        # Ensure to restore original context
        # set_lang may modify it
        with Transaction().set_context(Transaction().context):
            report_context = cls.get_context(records, header, data)
            return cls.convert(action, cls.render(action, report_context))

    @classmethod
    def _get_records(cls, ids, model, data):
        pool = Pool()
        Model = pool.get(model)
        Config = pool.get('ir.configuration')
        Lang = pool.get('ir.lang')
        context = Transaction().context

        class TranslateModel(object):
            _languages = {}
            __class__ = Model

            def __init__(self, id):
                self.id = id
                self._language = Transaction().language

            def set_lang(self, language=None):
                if isinstance(language, Lang):
                    language = language.code
                if not language:
                    language = Config.get_language()
                self._language = language

            def __getattr__(self, name):
                if self._language not in TranslateModel._languages:
                    with Transaction().set_context(
                            context=context, language=self._language):
                        records = Model.browse(ids)
                    id2record = dict((r.id, r) for r in records)
                    TranslateModel._languages[self._language] = id2record
                else:
                    id2record = TranslateModel._languages[self._language]
                record = id2record[self.id]
                return getattr(record, name)

            def __int__(self):
                return int(self.id)

            def __str__(self):
                return '%s,%s' % (Model.__name__, self.id)

        return [TranslateModel(id) for id in ids]

    @classmethod
    def get_context(cls, records, header, data):
        pool = Pool()
        User = pool.get('res.user')
        Lang = pool.get('ir.lang')

        report_context = {}
        report_context['header'] = header
        report_context['data'] = data
        report_context['context'] = Transaction().context
        report_context['user'] = User(Transaction().user)
        report_context['records'] = records
        report_context['record'] = records[0] if records else None
        report_context['format_date'] = cls.format_date
        report_context['format_datetime'] = cls.format_datetime
        report_context['format_timedelta'] = cls.format_timedelta
        report_context['format_currency'] = cls.format_currency
        report_context['format_number'] = cls.format_number
        report_context['format_number_symbol'] = cls.format_number_symbol
        report_context['datetime'] = datetime
        if barcode:
            report_context['barcode'] = cls.barcode
        if qrcode:
            report_context['qrcode'] = cls.qrcode

        def set_lang(language=None):
            if isinstance(language, Lang):
                language = language.code
            Transaction().set_context(language=language)
        report_context['set_lang'] = set_lang

        return report_context

    @classmethod
    def _callback_loader(cls, report, template):
        if report.translatable:
            pool = Pool()
            Translation = pool.get('ir.translation')
            translate = TranslateFactory(cls.__name__, Translation)
            translator = Translator(lambda text: translate(text))
            # Do not use Translator.setup to add filter at the end
            # after set_lang evaluation
            template.filters.append(translator)
            if hasattr(template, 'add_directives'):
                template.add_directives(Translator.NAMESPACE, translator)

    @classmethod
    def render(cls, report, report_context):
        "calls the underlying templating engine to renders the report"
        template = report.get_template_cached()
        if template is None:
            mimetype = MIMETYPES[report.template_extension]
            loader = relatorio.reporting.MIMETemplateLoader()
            klass = loader.factories[loader.get_type(mimetype)]
            template = klass(BytesIO(report.report_content))
            report.set_template_cached(template)
        cls._callback_loader(report, template)
        data = template.generate(**report_context).render()
        if hasattr(data, 'getvalue'):
            data = data.getvalue()
        return data

    @classmethod
    def convert(cls, report, data, timeout=5 * 60, retry=5):
        "converts the report data to another mimetype if necessary"
        input_format = report.template_extension
        output_format = report.extension or report.template_extension

        if (weasyprint
                and input_format in {'html', 'xhtml'}
                and output_format == 'pdf'):
            return output_format, weasyprint.HTML(string=data).write_pdf()

        if input_format == output_format and output_format in MIMETYPES:
            return output_format, data

        dtemp = tempfile.mkdtemp(prefix='trytond_')
        path = os.path.join(
            dtemp, report.report_name + os.extsep + input_format)
        oext = FORMAT2EXT.get(output_format, output_format)
        mode = 'w+' if isinstance(data, str) else 'wb+'
        with open(path, mode) as fp:
            fp.write(data)
        try:
            cmd = ['soffice',
                '--headless', '--nolockcheck', '--nodefault', '--norestore',
                '--convert-to', oext, '--outdir', dtemp, path]
            output = os.path.splitext(path)[0] + os.extsep + oext
            for count in range(retry, -1, -1):
                if count != retry:
                    time.sleep(0.02 * (retry - count))
                try:
                    subprocess.check_call(cmd, timeout=timeout)
                except subprocess.CalledProcessError:
                    if count:
                        continue
                    logger.error(
                        "fail to convert %s to %s", report.report_name, oext,
                        exc_info=True)
                    break
                if os.path.exists(output):
                    with open(output, 'rb') as fp:
                        return oext, fp.read()
            else:
                logger.error(
                    'fail to convert %s to %s', report.report_name, oext)
            return input_format, data
        finally:
            try:
                os.remove(path)
                os.remove(output)
                os.rmdir(dtemp)
            except OSError:
                pass

    @classmethod
    def format_date(cls, value, lang=None, format=None):
        pool = Pool()
        Lang = pool.get('ir.lang')
        if lang is None:
            lang = Lang.get()
        return lang.strftime(value, format=format)

    @classmethod
    def format_datetime(cls, value, lang=None, format=None, timezone=None):
        pool = Pool()
        Lang = pool.get('ir.lang')
        if lang is None:
            lang = Lang.get()
        if value.tzinfo is None:
            value = value.replace(tzinfo=dateutil.tz.tzutc())
        if timezone:
            if isinstance(timezone, str):
                timezone = dateutil.tz.gettz(timezone)
            value = value.astimezone(timezone)
        return lang.strftime(value, format)

    @classmethod
    def format_timedelta(cls, value, converter=None, lang=None):
        pool = Pool()
        Lang = pool.get('ir.lang')
        if lang is None:
            lang = Lang.get()
        if not converter:
            converter = TIMEDELTA_DEFAULT_CONVERTER
        if value is None:
            return ''

        def translate(k):
            xml_id = 'ir.msg_timedelta_%s' % k
            translation = gettext(xml_id)
            return translation if translation != xml_id else k

        text = []
        value = value.total_seconds()
        sign = '-' if value < 0 else ''
        value = abs(value)
        converter = sorted(
            converter.items(), key=operator.itemgetter(1), reverse=True)
        values = []
        for k, v in converter:
            part, value = divmod(value, v)
            values.append(part)

        for (k, _), v in zip(converter[:-3], values):
            if v:
                text.append(lang.format('%d', v, True) + translate(k))
        if any(values[-3:]) or not text:
            time = '%02d:%02d' % tuple(values[-3:-1])
            if values[-1] or value:
                time += ':%02d' % values[-1]
            text.append(time)
        text = sign + ' '.join(text)
        if value:
            if not any(values[-3:]):
                # Add space if no time
                text += ' '
            text += ('%.6f' % value)[1:]
        return text.replace(' ', NO_BREAKING_SPACE)

    @classmethod
    def format_currency(
            cls, value, lang, currency, symbol=True, grouping=True,
            digits=None):
        pool = Pool()
        Lang = pool.get('ir.lang')
        if lang is None:
            lang = Lang.get()
        return lang.currency(
            value, currency, symbol=symbol, grouping=grouping, digits=digits)

    @classmethod
    def format_number(
            cls, value, lang, digits=None, grouping=True, monetary=None):
        pool = Pool()
        Lang = pool.get('ir.lang')
        if lang is None:
            lang = Lang.get()
        return lang.format_number(
            value, digits=digits, grouping=grouping, monetary=monetary)

    @classmethod
    def format_number_symbol(
            cls, value, lang, symbol, digits=None, grouping=True):
        pool = Pool()
        Lang = pool.get('ir.lang')
        if lang is None:
            lang = Lang.get()
        return lang.format_number_symbol(
            value, symbol, digits=digits, grouping=grouping)

    if barcode:
        @classmethod
        def barcode(cls, name, code, size=(), **kwargs):
            image = barcode.generate_svg(name, code, **kwargs)
            return (image, 'image/svg+xml', *size)

    if qrcode:
        @classmethod
        def qrcode(cls, code, size=(), **kwargs):
            image = qrcode.generate_svg(code, **kwargs)
            return (image, 'image/svg+xml', *size)


def get_email(report, record, languages):
    "Return email.mime and title from the report execution"
    pool = Pool()
    ActionReport = pool.get('ir.action.report')
    report_id = None
    if inspect.isclass(report) and issubclass(report, Report):
        Report_ = report
    else:
        if isinstance(report, ActionReport):
            report_name = report.report_name
            report_id = report.id
        else:
            report_name = report
        Report_ = pool.get(report_name, type='report')
    converter = None
    title = None
    msg = EmailMessage()
    msg.add_header('Content-Language', ', '.join(l.code for l in languages))
    for alternative, language in enumerate(languages):
        with Transaction().set_context(
                language=language.code, with_rec_name=False):
            ext, content, _, title = Report_.execute(
                [record.id], {
                    'action_id': report_id,
                    'language': language,
                    })
        if ext == 'txt':
            ext = 'plain'
        if ext == 'html' and html2text:
            if not converter:
                converter = html2text.HTML2Text()
            content_text = converter.handle(content)
            msg.add_alternative(content_text, subtype='plain', params={
                    'Content-Language': language.code,
                    })
        if alternative or msg.is_multipart():
            msg.add_alternative(content, subtype=ext, params={
                    'Content-Language': language.code,
                    })
        else:
            msg.set_content(content, subtype=ext, params={
                    'Content-Language': language.code,
                    })
    return msg, title