# copyright 2003-2016 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr

#

# This file is part of CubicWeb.

#

# CubicWeb is free software: you can redistribute it and/or modify it under the

# terms of the GNU Lesser General Public License as published by the Free

# Software Foundation, either version 2.1 of the License, or (at your option)

# any later version.

#

# CubicWeb 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 Lesser General Public License for more

# details.

#

# You should have received a copy of the GNU Lesser General Public License along

# with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.

"""Adapters for native cubicweb sources."""

from threading import Lock

from datetime import datetime

from contextlib import contextmanager

from os.path import basename

import pickle

import re

import itertools

import zipfile

import logging

import sys

from logilab.common.decorators import cached, clear_cache

from logilab.common.configuration import Method

from logilab.common.shellutils import getlogin, ASK

from logilab.database import get_db_helper, sqlgen

from yams.schema import role_name

from cubicweb import (UnknownEid, AuthenticationError, ValidationError, Binary,

                      UniqueTogetherError, UndoTransactionException, ViolatedConstraint)

from cubicweb import transaction as tx, server, neg_role, _

from cubicweb.utils import QueryCache

from cubicweb.schema import VIRTUAL_RTYPES

from cubicweb.cwconfig import CubicWebNoAppConfiguration

from cubicweb.server import hook

from cubicweb.server import schema2sql as y2sql

from cubicweb.server.utils import crypt_password, verify_and_update

from cubicweb.server.sqlutils import SQL_PREFIX, SQLAdapterMixIn

from cubicweb.server.rqlannotation import set_qdata

from cubicweb.server.hook import CleanupDeletedEidsCacheOp

from cubicweb.server.edition import EditedEntity

from cubicweb.server.sources import AbstractSource, dbg_st_search, dbg_results

from cubicweb.server.sources.rql2sql import SQLGenerator

from cubicweb.misc.source_highlight import highlight

from cubicweb.statsd_logger import statsd_timeit

ATTR_MAP = {}

NONSYSTEM_ETYPES = set()

NONSYSTEM_RELATIONS = set()

class LogCursor(object):

    def __init__(self, cursor):

        self.cu = cursor

    def execute(self, query, args=None):

        """Execute a query.

        it's a function just so that it shows up in profiling

        """

        if server.DEBUG & server.DBG_SQL:

            print('exec', highlight(query, "SQL"), args)

        try:

            self.cu.execute(str(query), args)

        except Exception as ex:

            print("sql: %r\n args: %s\ndbms message: %r" % (

                highlight(query, "SQL"), args, ex.args[0]))

            raise

    def fetchall(self):

        return self.cu.fetchall()

    def fetchone(self):

        return self.cu.fetchone()

def sql_or_clauses(sql, clauses):

    select, restr = sql.split(' WHERE ', 1)

    restrclauses = restr.split(' AND ')

    for clause in clauses:

        restrclauses.remove(clause)

    if restrclauses:

        restr = '%s AND (%s)' % (' AND '.join(restrclauses),

                                 ' OR '.join(clauses))

    else:

        restr = '(%s)' % ' OR '.join(clauses)

    return '%s WHERE %s' % (select, restr)

def rdef_table_column(rdef):

    """return table and column used to store the given relation definition in

    the database

    """

    return (SQL_PREFIX + str(rdef.subject),

            SQL_PREFIX + str(rdef.rtype))

def rdef_physical_info(dbhelper, rdef):

    """return backend type and a boolean flag if NULL values should be allowed

    for a given relation definition

    """

    if not rdef.object.final:

        return dbhelper.TYPE_MAPPING['Int']

    coltype = y2sql.type_from_rdef(dbhelper, rdef)

    allownull = rdef.cardinality[0] != '1'

    return coltype, allownull

class _UndoException(Exception):

    """something went wrong during undoing"""

    def __str__(self):

        """Called by the unicode builtin; should return a Unicode object

        Type of _UndoException message must be `unicode` by design in CubicWeb.

        """

        return self.args[0]

def _undo_check_relation_target(tentity, rdef, role):

    """check linked entity has not been redirected for this relation"""

    card = rdef.role_cardinality(role)

    if card in '?1' and tentity.related(rdef.rtype, role):

        msg = tentity._cw._(

            "Can't restore %(role)s relation %(rtype)s to entity %(eid)s which "

            "is already linked using this relation.")

        raise _UndoException(msg % {'role': neg_role(role),

                                    'rtype': rdef.rtype,

                                    'eid': tentity.eid})

def _undo_rel_info(cnx, subj, rtype, obj):

    entities = []

    for role, eid in (('subject', subj), ('object', obj)):

        try:

            entities.append(cnx.entity_from_eid(eid))

        except UnknownEid:

            msg = cnx._(

                "Can't restore relation %(rtype)s, %(role)s entity %(eid)s"

                " doesn't exist anymore.")

            raise _UndoException(msg % {'role': cnx._(role),

                                        'rtype': cnx._(rtype),

                                        'eid': eid})

    sentity, oentity = entities

    try:

        rschema = cnx.vreg.schema.rschema(rtype)

        rdef = rschema.rdefs[(sentity.cw_etype, oentity.cw_etype)]

    except KeyError:

        msg = cnx._(

            "Can't restore relation %(rtype)s between %(subj)s and "

            "%(obj)s, that relation does not exists anymore in the "

            "schema.")

        raise _UndoException(msg % {'rtype': cnx._(rtype),

                                    'subj': subj,

                                    'obj': obj})

    return sentity, oentity, rdef

def _undo_has_later_transaction(cnx, eid):

    return cnx.system_sql('''\

SELECT T.tx_uuid FROM transactions AS TREF, transactions AS T

WHERE TREF.tx_uuid='%(txuuid)s' AND T.tx_uuid!='%(txuuid)s'

AND T.tx_time>=TREF.tx_time

AND (EXISTS(SELECT 1 FROM tx_entity_actions AS TEA

            WHERE TEA.tx_uuid=T.tx_uuid AND TEA.eid=%(eid)s)

     OR EXISTS(SELECT 1 FROM tx_relation_actions as TRA

               WHERE TRA.tx_uuid=T.tx_uuid AND (

                   TRA.eid_from=%(eid)s OR TRA.eid_to=%(eid)s))

     )''' % {'txuuid': cnx.transaction_data['undoing_uuid'],

             'eid': eid}).fetchone()

class DefaultEidGenerator(object):

    __slots__ = ('source', 'cnx', 'lock')

    def __init__(self, source):

        self.source = source

        self.cnx = None

        self.lock = Lock()

    def close(self):

        if self.cnx:

            self.cnx.close()

        self.cnx = None

    def create_eid(self, _cnx, count=1):

        # lock needed to prevent 'Connection is busy with results for another

        # command (0)' errors with SQLServer

        assert count > 0

        with self.lock:

            return self._create_eid(count)

    def _create_eid(self, count):

        # internal function doing the eid creation without locking.

        # needed for the recursive handling of disconnections (otherwise we

        # deadlock on self._eid_cnx_lock

        source = self.source

        if self.cnx is None:

            self.cnx = source.get_connection()

        cnx = self.cnx

        try:

            cursor = cnx.cursor()

            for sql in source.dbhelper.sqls_increment_numrange('entities_id_seq', count):

                cursor.execute(sql)

            eid = cursor.fetchone()[0]

        except (source.OperationalError, source.InterfaceError):

            # FIXME: better detection of deconnection pb

            source.warning("trying to reconnect create eid connection")

            self.cnx = None

            return self._create_eid(count)

        except source.DbapiError as exc:

            # We get this one with pyodbc and SQL Server when connection was reset

            if exc.args[0] == '08S01':

                source.warning("trying to reconnect create eid connection")

                self.cnx = None

                return self._create_eid(count)

            else:

                raise

        except Exception:  # WTF?

            cnx.rollback()

            self.cnx = None

            source.exception('create eid failed in an unforeseen way on SQL statement %s', sql)

            raise

        else:

            cnx.commit()

            return eid

class SQLITEEidGenerator(object):

    __slots__ = ('source', 'lock')

    def __init__(self, source):

        self.source = source

        self.lock = Lock()

    def close(self):

        pass

    def create_eid(self, cnx, count=1):

        assert count > 0

        source = self.source

        with self.lock:

            for sql in source.dbhelper.sqls_increment_numrange('entities_id_seq', count):

                cursor = source.doexec(cnx, sql)

            return cursor.fetchone()[0]

class NativeSQLSource(SQLAdapterMixIn, AbstractSource):

    """adapter for source using the native cubicweb schema (see below)

    """

    sqlgen_class = SQLGenerator

    options = (

        ('db-driver',

         {'type': 'string',

          'default': 'postgres',

          # XXX use choice type

          'help': 'database driver (postgres, sqlite, sqlserver2005)',

          'group': 'native-source', 'level': 0,

          }),

        ('db-host',

         {'type': 'string',

          'default': '',

          'help': 'database host',

          'group': 'native-source', 'level': 1,

          }),

        ('db-port',

         {'type': 'string',

          'default': '',

          'help': 'database port',

          'group': 'native-source', 'level': 1,

          }),

        ('db-name',

         {'type': 'string',

          'default': Method('default_instance_id'),

          'help': 'database name',

          'group': 'native-source', 'level': 0,

          }),

        ('db-namespace',

         {'type': 'string',

          'default': '',

          'help': 'database namespace (schema) name',

          'group': 'native-source', 'level': 1,

          }),

        ('db-user',

         {'type': 'string',

          'default': CubicWebNoAppConfiguration.mode == 'user' and getlogin() or 'cubicweb',

          'help': 'database user',

          'group': 'native-source', 'level': 0,

          }),

        ('db-password',

         {'type': 'password',

          'default': '',

          'help': 'database password',

          'group': 'native-source', 'level': 0,

          }),

        ('db-encoding',

         {'type': 'string',

          'default': 'utf8',

          'help': 'database encoding',

          'group': 'native-source', 'level': 1,

          }),

        ('db-extra-arguments',

         {'type': 'string',

          'default': '',

          'help': 'set to "Trusted_Connection" if you are using SQLServer and '

                  'want trusted authentication for the database connection',

          'group': 'native-source', 'level': 2,

          }),

        ('db-statement-timeout',

         {'type': 'int',

          'default': 0,

          'help': 'sql statement timeout, in milliseconds (postgres only)',

          'group': 'native-source', 'level': 2,

          }),

    )

    def __init__(self, repo, source_config, *args, **kwargs):

        SQLAdapterMixIn.__init__(self, source_config, repairing=repo.config.repairing)

        self.authentifiers = [LoginPasswordAuthentifier(self)]

        if repo.config['allow-email-login']:

            self.authentifiers.insert(0, EmailPasswordAuthentifier(self))

        AbstractSource.__init__(self, repo, source_config, *args, **kwargs)

        # sql generator

        self._rql_sqlgen = self.sqlgen_class(self.schema, self.dbhelper,

                                             ATTR_MAP.copy())

        # full text index helper

        self.do_fti = not repo.config['delay-full-text-indexation']

        # sql queries cache

        self._cache = QueryCache(repo.config['rql-cache-size'])

        # (etype, attr) / storage mapping

        self._storages = {}

        self.binary_to_str = self.dbhelper.dbapi_module.binary_to_str

        if self.dbdriver == 'sqlite':

            self.eid_generator = SQLITEEidGenerator(self)

        else:

            self.eid_generator = DefaultEidGenerator(self)

        self.create_eid = self.eid_generator.create_eid

    def check_config(self, source_entity):

        if source_entity.config:

            msg = _("Configuration of the system source goes to "

                    "the 'sources' file, not in the database")

            raise ValidationError(source_entity.eid, {role_name('config', 'subject'): msg})

    def check_urls(self, source_entity):

        if source_entity.url:

            msg = _("Configuration of the system source goes to "

                    "the 'sources' file, not in the database")

            raise ValidationError(source_entity.eid, {role_name('config', 'subject'): msg})

    def add_authentifier(self, authentifier):

        self.authentifiers.append(authentifier)

        authentifier.source = self

        authentifier.set_schema(self.schema)

    def clear_caches(self, eids, etypes):

        """Clear potential source caches."""

        if eids is None:

            self._cache = QueryCache(self.repo.config['rql-cache-size'])

        else:

            cache = self._cache

            for eid, etype in zip(eids, etypes):

                cache.pop('Any X WHERE X eid %s' % eid, None)

                cache.pop('Any %s' % eid, None)

                if etype is not None:

                    cache.pop('Any X WHERE X eid %s, X is %s' % (eid, etype), None)