#!/usr/bin/env python3

# ~ Empresa Libre
# ~ Copyright (C) 2016-2019  Mauricio Baeza Servin (public@elmau.net)
# ~
# ~ 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 3 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, see <http://www.gnu.org/licenses/>.

import base64
import collections
import datetime
import json
import logging
import math
import os
import shutil
import smtplib
import sqlite3
import subprocess
import threading
import zipfile
from pathlib import Path

from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email.mime.text import MIMEText
from email import encoders
from email.utils import formatdate
from io import BytesIO

import lxml.etree as ET
import requests

from cryptography.fernet import Fernet
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from dateutil import parser

import seafileapi


LOG_FORMAT = '%(asctime)s - %(levelname)s - %(message)s'
LOG_DATE = '%d/%m/%Y %H:%M:%S'
logging.addLevelName(logging.ERROR, '\033[1;41mERROR\033[1;0m')
logging.addLevelName(logging.DEBUG, '\x1b[33mDEBUG\033[1;0m')
logging.addLevelName(logging.INFO, '\x1b[32mINFO\033[1;0m')
logging.basicConfig(level=logging.DEBUG, format=LOG_FORMAT, datefmt=LOG_DATE)
log = logging.getLogger(__name__)
logging.getLogger('peewee').setLevel(logging.WARNING)


TIMEOUT = 10
PATH_INVOICES = 'facturas'


#~ https://github.com/kennethreitz/requests/blob/v1.2.3/requests/structures.py#L37
class CaseInsensitiveDict(collections.MutableMapping):
    """
    A case-insensitive ``dict``-like object.
    Implements all methods and operations of
    ``collections.MutableMapping`` as well as dict's ``copy``. Also
    provides ``lower_items``.
    All keys are expected to be strings. The structure remembers the
    case of the last key to be set, and ``iter(instance)``,
    ``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()``
    will contain case-sensitive keys. However, querying and contains
    testing is case insensitive:
        cid = CaseInsensitiveDict()
        cid['Accept'] = 'application/json'
        cid['aCCEPT'] == 'application/json'  # True
        list(cid) == ['Accept']  # True
    For example, ``headers['content-encoding']`` will return the
    value of a ``'Content-Encoding'`` response header, regardless
    of how the header name was originally stored.
    If the constructor, ``.update``, or equality comparison
    operations are given keys that have equal ``.lower()``s, the
    behavior is undefined.
    """
    def __init__(self, data=None, **kwargs):
        self._store = dict()
        if data is None:
            data = {}
        self.update(data, **kwargs)

    def __setitem__(self, key, value):
        # Use the lowercased key for lookups, but store the actual
        # key alongside the value.
        self._store[key.lower()] = (key, value)

    def __getitem__(self, key):
        return self._store[key.lower()][1]

    def __delitem__(self, key):
        del self._store[key.lower()]

    def __iter__(self):
        return (casedkey for casedkey, mappedvalue in self._store.values())

    def __len__(self):
        return len(self._store)

    def lower_items(self):
        """Like iteritems(), but with all lowercase keys."""
        return (
            (lowerkey, keyval[1])
            for (lowerkey, keyval)
            in self._store.items()
        )

    def __eq__(self, other):
        if isinstance(other, collections.Mapping):
            other = CaseInsensitiveDict(other)
        else:
            return NotImplemented
        # Compare insensitively
        return dict(self.lower_items()) == dict(other.lower_items())

    # Copy is required
    def copy(self):
        return CaseInsensitiveDict(self._store.values())

    def __repr__(self):
        return '%s(%r)' % (self.__class__.__name__, dict(self.items()))


class SendMail(object):

    def __init__(self, config):
        self._config = config
        self._server = None
        self._error = ''
        self._is_connect = self._login()

    @property
    def is_connect(self):
        return self._is_connect

    @property
    def error(self):
        return self._error

    def _login(self):
        hosts = ('gmail' in self._config['server'] or
                'outlook' in self._config['server'])
        try:
            if self._config['ssl'] and hosts:
                self._server = smtplib.SMTP(
                    self._config['server'],
                    self._config['port'], timeout=TIMEOUT)
                self._server.ehlo()
                self._server.starttls()
                self._server.ehlo()
            elif self._config['ssl']:
                self._server = smtplib.SMTP_SSL(
                    self._config['server'],
                    self._config['port'], timeout=TIMEOUT)
                self._server.ehlo()
            else:
                self._server = smtplib.SMTP(
                    self._config['server'],
                    self._config['port'], timeout=TIMEOUT)
            self._server.login(self._config['user'], self._config['pass'])
            return True
        except smtplib.SMTPAuthenticationError as e:
            if '535' in str(e):
                self._error = 'Nombre de usuario o contraseña inválidos'
                return False
            if '534' in str(e) and 'gmail' in self._config['server']:
                self._error = 'Necesitas activar el acceso a otras ' \
                    'aplicaciones en tu cuenta de GMail'
                return False
        except smtplib.SMTPException as e:
            self._error = str(e)
            return False
        except Exception as e:
            self._error = str(e)
            return False
        return

    def send(self, options):
        try:
            message = MIMEMultipart()
            message['From'] = self._config['user']
            message['To'] = options['to']
            message['CC'] = options.get('copy', '')
            message['Subject'] = options['subject']
            message['Date'] = formatdate(localtime=True)
            if options.get('confirm', False):
                message['Disposition-Notification-To'] = message['From']
            message.attach(MIMEText(options['message'], 'html'))
            for f in options.get('files', ()):
                part = MIMEBase('application', 'octet-stream')
                if isinstance(f[0], str):
                    part.set_payload(f[0].encode('utf-8'))
                else:
                    part.set_payload(f[0])
                encoders.encode_base64(part)
                part.add_header(
                    'Content-Disposition',
                    "attachment; filename={}".format(f[1]))
                message.attach(part)

            receivers = options['to'].split(',') + message['CC'].split(',')
            self._server.sendmail(
                self._config['user'], receivers, message.as_string())
            return ''
        except Exception as e:
            return str(e)

    def close(self):
        try:
            self._server.quit()
        except:
            pass
        return


class CfdiToDict(object):
    NS = {
        'cfdi': 'http://www.sat.gob.mx/cfd/3',
        'divisas': 'http://www.sat.gob.mx/divisas',
    }

    def __init__(self, xml):
        self._values = {}
        self._root = ET.parse(BytesIO(xml.encode())).getroot()
        self._get_values()

    @property
    def values(self):
        return self._values

    def _get_values(self):
        self._complementos()
        return

    def _complementos(self):
        complemento = self._root.xpath('//cfdi:Complemento', namespaces=self.NS)[0]

        divisas = complemento.xpath('//divisas:Divisas', namespaces=self.NS)
        if divisas:
            d = CaseInsensitiveDict(divisas[0].attrib)
            d.pop('version', '')
            self._values.update({'divisas': d})
        return


def _call(args):
    return subprocess.check_output(args, shell=True).decode()


def _join(*paths):
    return os.path.join(*paths)


def run_in_thread(fn):
    def run(*k, **kw):
        t = threading.Thread(target=fn, args=k, kwargs=kw)
        t.start()
        return t
    return run


def send_mail(data):
    msg = ''
    ok = True
    server = SendMail(data['server'])
    if server.is_connect:
        msg = server.send(data['mail'])
    else:
        msg = server.error
        ok = False
    server.close()

    return {'ok': ok, 'msg': msg}


def round_up(value):
    return int(math.ceil(value))


def _get_key(password):
    digest = hashes.Hash(hashes.SHA256(), backend=default_backend())
    digest.update(password.encode())
    key = base64.urlsafe_b64encode(digest.finalize())
    return key


def encrypt(data, password):
    f = Fernet(_get_key(password))
    return f.encrypt(data.encode()).decode()


def decrypt(data, password):
    f = Fernet(_get_key(password))
    return f.decrypt(data.encode()).decode()


def to_bool(value):
    return bool(int(value))


def get_url(url):
    r = requests.get(url).text
    return r


def parse_date(value, next_day=False):
    d = parser.parse(value)
    if next_day:
        return d + datetime.timedelta(days=1)
    return d


def to_zip(files):
    zip_buffer = BytesIO()

    with zipfile.ZipFile(zip_buffer, 'a', zipfile.ZIP_DEFLATED, False) as zip_file:
        for file_name, data in files.items():
            zip_file.writestr(file_name, data)

    return zip_buffer.getvalue()


def db_delete(user, path):
    dt = datetime.datetime.now().strftime('%y%m%d_%H%M')
    path_bk = _join(path, 'tmp', '{}_{}.bk'.format(user, dt))
    args = 'pg_dump -U postgres -Fc {} > "{}"'.format(user, path_bk)
    try:
        _call(args)
    except:
        pass

    args = 'psql -U postgres -c "DROP DATABASE {0};"'.format(user)
    try:
        _call(args)
    except:
        pass

    args = 'psql -U postgres -c "DROP ROLE {0};"'.format(user)
    try:
        _call(args)
    except:
        pass
    return


def _get_pass(rfc):
    return rfc


def _backup_db(rfc, data, path_bk, is_mv, url_seafile):
    if data['type'] != 'postgres':
        return

    log.info('Generando backup de: {}'.format(rfc))
    bk_name = '{}.bk'.format(rfc.lower())
    path_db = _join(path_bk, bk_name)
    args = 'pg_dump -U postgres -Fc {} > "{}"'.format(data['name'], path_db)
    result = _call(args)
    log.info('\tBackup local generado...')
    if is_mv:
        path_target = _join(Path.home(), PATH_INVOICES)
        if Path(path_target).exists():
            path_target = _join(path_target, bk_name)
            shutil.copy(path_db, path_target)
        else:
            log.error('\tNo existe la carpeta compartida...')

    sql = 'select correo_timbrado, token_soporte from emisor;'
    args = 'psql -U postgres -d {} -Atc "{}"'.format(data['name'], sql)
    result = _call(args)
    if not result:
        log.error('\tSin datos para backup remoto')
        return

    data = result.strip().split('|')
    if not data[1]:
        log.error('\tSin token de soporte')
        return
    # ~ email = data[0]
    # ~ uuid = data[1]
    # ~ email = 'hola@elmau.net'
    # ~ uuid = 'cc42c591-cf66-499a-ae70-c09df5646be9'

    # ~ log.debug(url_seafile, email, _get_pass(rfc))
    # ~ client = seafileapi.connect(url_seafile, email, _get_pass(rfc))
    # ~ repo = client.repos.get_repo(uuid)
    # ~ print(repo)

    return


def db_backup(path_companies, path_bk, is_mv, url_seafile):
    con = sqlite3.connect(path_companies)
    cursor = con.cursor()
    sql = "SELECT * FROM names"
    cursor.execute(sql)
    rows = cursor.fetchall()
    if rows is None:
        return
    cursor.close()
    con.close()

    for rfc, data in rows:
        _backup_db(rfc, json.loads(data), path_bk, is_mv, url_seafile)

    return


def now():
    return datetime.datetime.now().replace(microsecond=0)


def get_days(date):
    return (now() - date).days