"""Adapters for native cubicweb sources.

Notes:

* extid (aka external id, the primary key of an entity in the external source

  from which it comes from) are stored in a varchar column encoded as a base64

  string. This is because it should actually be Bytes but we want an index on

  it for fast querying.

:organization: Logilab

:copyright: 2001-2010 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.

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

:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses

"""

from __future__ import with_statement

__docformat__ = "restructuredtext en"

from pickle import loads, dumps

from threading import Lock

from datetime import datetime

from base64 import b64decode, b64encode

from logilab.common.compat import any

from logilab.common.cache import Cache

from logilab.common.decorators import cached, clear_cache

from logilab.common.configuration import Method

from logilab.common.shellutils import getlogin

from logilab.database import get_db_helper

from cubicweb import UnknownEid, AuthenticationError, Binary, server, neg_role

from cubicweb import transaction as tx

from cubicweb.schema import VIRTUAL_RTYPES

from cubicweb.cwconfig import CubicWebNoAppConfiguration

from cubicweb.server import hook

from cubicweb.server.utils import crypt_password

from cubicweb.server.sqlutils import SQL_PREFIX, SQLAdapterMixIn

from cubicweb.server.rqlannotation import set_qdata

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

from cubicweb.server.sources.rql2sql import SQLGenerator

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', query, args

        try:

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

        except Exception, ex:

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

                query, args, ex.args[0])

            raise

    def fetchall(self):

        return self.cu.fetchall()

    def fetchone(self):

        return self.cu.fetchone()

def make_schema(selected, solution, table, typemap):

    """return a sql schema to store RQL query result"""

    sql = []

    varmap = {}

    for i, term in enumerate(selected):

        name = 'C%s' % i

        key = term.as_string()

        varmap[key] = '%s.%s' % (table, name)

        ttype = term.get_type(solution)

        try:

            sql.append('%s %s' % (name, typemap[ttype]))

        except KeyError:

            # assert not schema(ttype).final

            sql.append('%s %s' % (name, typemap['Int']))

    return ','.join(sql), varmap

def _modified_sql(table, etypes):

    # XXX protect against sql injection

    if len(etypes) > 1:

        restr = 'type IN (%s)' % ','.join("'%s'" % etype for etype in etypes)

    else:

        restr = "type='%s'" % etypes[0]

    if table == 'entities':

        attr = 'mtime'

    else:

        attr = 'dtime'

    return 'SELECT type, eid FROM %s WHERE %s AND %s > %%(time)s' % (

        table, restr, attr)

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)

class UndoException(Exception):

    """something went wrong during undoing"""

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):

        raise UndoException(tentity._cw._(

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

            "is already linked using this relation.")

                            % {'role': neg_role(role),

                               'rtype': rdef.rtype,

                               'eid': tentity.eid})

class NativeSQLSource(SQLAdapterMixIn, AbstractSource):

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

    """

    sqlgen_class = SQLGenerator

    options = (

        ('db-driver',

         {'type' : 'string',

          'default': 'postgres',

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

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

          }),

        ('db-host',

         {'type' : 'string',

          'default': '',

          'help': 'database host',

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

          }),

        ('db-port',

         {'type' : 'string',

          'default': '',

          'help': 'database port',

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

          }),

        ('db-name',

         {'type' : 'string',

          'default': Method('default_instance_id'),

          'help': 'database name',

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

          }),

        ('db-user',

         {'type' : 'string',

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

          'help': 'database user',

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

          }),

        ('db-password',

         {'type' : 'password',

          'default': '',

          'help': 'database password',

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

          }),

        ('db-encoding',

         {'type' : 'string',

          'default': 'utf8',

          'help': 'database encoding',

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

          }),

    )

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

        SQLAdapterMixIn.__init__(self, source_config)

        self.authentifiers = [LoginPasswordAuthentifier(self)]

        AbstractSource.__init__(self, repo, appschema, source_config,

                                *args, **kwargs)

        # sql generator

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

                                             ATTR_MAP.copy())

        # full text index helper

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

        # sql queries cache

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

        self._temp_table_data = {}

        self._eid_creation_lock = Lock()

        # XXX no_sqlite_wrap trick since we've a sqlite locking pb when

        # running unittest_multisources with the wrapping below

        if self.dbdriver == 'sqlite' and \

               not getattr(repo.config, 'no_sqlite_wrap', False):

            from cubicweb.server.sources.extlite import ConnectionWrapper

            self.get_connection = lambda: ConnectionWrapper(self)

            self.check_connection = lambda cnx: cnx

            def pool_reset(cnx):

                cnx.close()

            self.pool_reset = pool_reset

    @property

    def _sqlcnx(self):

        # XXX: sqlite connections can only be used in the same thread, so

        #      create a new one each time necessary. If it appears to be time

        #      consuming, find another way

        return SQLAdapterMixIn.get_connection(self)

    def add_authentifier(self, authentifier):

        self.authentifiers.append(authentifier)

        authentifier.source = self

        authentifier.set_schema(self.schema)

    def reset_caches(self):

        """method called during test to reset potential source caches"""

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

    def clear_eid_cache(self, eid, etype):

        """clear potential caches for the given eid"""

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

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

        self._cache.pop('Any %s' % eid, None)

    def sqlexec(self, session, sql, args=None):

        """execute the query and return its result"""

        return self.process_result(self.doexec(session, sql, args))

    def init_creating(self):

        pool = self.repo._get_pool()

        pool.pool_set()

        # check full text index availibility

        if self.do_fti:

            if not self.dbhelper.has_fti_table(pool['system']):

                if not self.repo.config.creating:

                    self.critical('no text index table')

                self.do_fti = False

        pool.pool_reset()

        self.repo._free_pool(pool)

    def backup(self, backupfile, confirm):

        """method called to create a backup of the source's data"""

        self.close_pool_connections()

        try:

            self.backup_to_file(backupfile, confirm)

        finally:

            self.open_pool_connections()

    def restore(self, backupfile, confirm, drop):

        """method called to restore a backup of source's data"""

        if self.repo.config.open_connections_pools:

            self.close_pool_connections()

        try:

            self.restore_from_file(backupfile, confirm, drop=drop)

        finally:

            if self.repo.config.open_connections_pools:

                self.open_pool_connections()

    def init(self):

        self.init_creating()

    def map_attribute(self, etype, attr, cb):

        self._rql_sqlgen.attr_map['%s.%s' % (etype, attr)] = cb

    def unmap_attribute(self, etype, attr):

        self._rql_sqlgen.attr_map.pop('%s.%s' % (etype, attr), None)

    # ISource interface #######################################################

    def compile_rql(self, rql, sols):

        rqlst = self.repo.vreg.rqlhelper.parse(rql)

        rqlst.restricted_vars = ()

        rqlst.children[0].solutions = sols

        self.repo.querier.sqlgen_annotate(rqlst)

        set_qdata(self.schema.rschema, rqlst, ())

        return rqlst

    def set_schema(self, schema):

        """set the instance'schema"""

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

        self.cache_hit, self.cache_miss, self.no_cache = 0, 0, 0

        self.schema = schema

        try:

            self._rql_sqlgen.schema = schema

        except AttributeError:

            pass # __init__

        for authentifier in self.authentifiers:

            authentifier.set_schema(self.schema)

        clear_cache(self, 'need_fti_indexation')

    def support_entity(self, etype, write=False):

        """return true if the given entity's type is handled by this adapter

        if write is true, return true only if it's a RW support

        """

        return not etype in NONSYSTEM_ETYPES

    def support_relation(self, rtype, write=False):

        """return true if the given relation's type is handled by this adapter

        if write is true, return true only if it's a RW support

        """

        if write:

            return not rtype in NONSYSTEM_RELATIONS

        # due to current multi-sources implementation, the system source

        # can't claim not supporting a relation

        return True #not rtype == 'content_for'

    def may_cross_relation(self, rtype):

        return True

    def authenticate(self, session, login, **kwargs):

        """return CWUser eid for the given login and other authentication

        information found in kwargs, else raise `AuthenticationError`

        """

        for authentifier in self.authentifiers:

            try:

                return authentifier.authenticate(session, login, **kwargs)

            except AuthenticationError:

                continue

        raise AuthenticationError()

    def syntax_tree_search(self, session, union, args=None, cachekey=None,

                           varmap=None):

        """return result from this source for a rql query (actually from

        a rql syntax tree and a solution dictionary mapping each used

        variable to a possible type). If cachekey is given, the query

        necessary to fetch the results (but not the results themselves)

        may be cached using this key.

        """

        assert dbg_st_search(self.uri, union, varmap, args, cachekey)

        # remember number of actually selected term (sql generation may append some)

        if cachekey is None:

            self.no_cache += 1

            # generate sql query if we are able to do so (not supported types...)

            sql, query_args = self._rql_sqlgen.generate(union, args, varmap)

        else:

            # sql may be cached

            try:

                sql, query_args = self._cache[cachekey]

                self.cache_hit += 1

            except KeyError:

                self.cache_miss += 1

                sql, query_args = self._rql_sqlgen.generate(union, args, varmap)

                self._cache[cachekey] = sql, query_args

        args = self.merge_args(args, query_args)

        assert isinstance(sql, basestring), repr(sql)

        try:

            cursor = self.doexec(session, sql, args)

        except (self.OperationalError, self.InterfaceError):

            # FIXME: better detection of deconnection pb

            self.info("request failed '%s' ... retry with a new cursor", sql)

            session.pool.reconnect(self)

            cursor = self.doexec(session, sql, args)

        results = self.process_result(cursor)

        assert dbg_results(results)

        return results

    def flying_insert(self, table, session, union, args=None, varmap=None):

        """similar as .syntax_tree_search, but inserts data in the

        temporary table (on-the-fly if possible, eg for the system

        source whose the given cursor come from). If not possible,

        inserts all data by calling .executemany().

        """

        assert dbg_st_search(

            self.uri, union, varmap, args,

            prefix='ON THE FLY temp data insertion into %s from' % table)

        # generate sql queries if we are able to do so

        sql, query_args = self._rql_sqlgen.generate(union, args, varmap)

        query = 'INSERT INTO %s %s' % (table, sql.encode(self._dbencoding))

        self.doexec(session, query, self.merge_args(args, query_args))

    def manual_insert(self, results, table, session):

        """insert given result into a temporary table on the system source"""

        if server.DEBUG & server.DBG_RQL:

            print '  manual insertion of', results, 'into', table