from ..adapters.firebird import FireBird
from ..objects import Expression
from .base import SQLDialect
from . import dialects, sqltype_for


@dialects.register_for(FireBird)
class FireBirdDialect(SQLDialect):
    @sqltype_for('text')
    def type_text(self):
        return 'BLOB SUB_TYPE 1'

    @sqltype_for('bigint')
    def type_bigint(self):
        return 'BIGINT'

    @sqltype_for('double')
    def type_double(self):
        return 'DOUBLE PRECISION'

    @sqltype_for('decimal')
    def type_decimal(self):
        return 'DECIMAL(%(precision)s,%(scale)s)'

    @sqltype_for('blob')
    def type_blob(self):
        return 'BLOB SUB_TYPE 0'

    @sqltype_for('id')
    def type_id(self):
        return 'INTEGER PRIMARY KEY'

    @sqltype_for('big-id')
    def type_big_id(self):
        return 'BIGINT PRIMARY KEY'

    @sqltype_for('reference')
    def type_reference(self):
        return 'INTEGER REFERENCES %(foreign_key)s ' + \
            'ON DELETE %(on_delete_action)s'

    @sqltype_for('big-reference')
    def type_big_reference(self):
        return 'BIGINT REFERENCES %(foreign_key)s ' + \
            'ON DELETE %(on_delete_action)s'

    def sequence_name(self, tablename):
        return self.quote('genid_%s' % tablename)

    def trigger_name(self, tablename):
        return 'trg_id_%s' % tablename

    @property
    def random(self):
        return 'RAND()'

    def not_null(self, default, field_type):
        return 'DEFAULT %s NOT NULL' % \
            self.adapter.represent(default, field_type)

    def epoch(self, val, query_env={}):
        return "DATEDIFF(second, '1970-01-01 00:00:00', %s)" % \
            self.expand(val, query_env=query_env)

    def substring(self, field, parameters, query_env={}):
        return 'SUBSTRING(%s from %s for %s)' % (
            self.expand(field, query_env=query_env), parameters[0],
            parameters[1])

    def length(self, val, query_env={}):
        return "CHAR_LENGTH(%s)" % self.expand(val, query_env=query_env)

    def contains(self, first, second, case_sensitive=True, query_env={}):
        if first.type.startswith('list:'):
            second = Expression(None, self.concat('|', Expression(
                None, self.replace(second, ('|', '||'), query_env)), '|'))
        return '(%s CONTAINING %s)' % (
            self.expand(first, query_env=query_env),
            self.expand(second, 'string', query_env=query_env))

    def select(self, fields, tables, where=None, groupby=None, having=None,
               orderby=None, limitby=None, distinct=False, for_update=False):
        dst, whr, grp, order, limit, offset, upd = '', '', '', '', '', '', ''
        if distinct is True:
            dst = ' DISTINCT'
        elif distinct:
            dst = ' DISTINCT ON (%s)' % distinct
        if where:
            whr = ' %s' % self.where(where)
        if groupby:
            grp = ' GROUP BY %s' % groupby
            if having:
                grp += ' HAVING %s' % having
        if orderby:
            order = ' ORDER BY %s' % orderby
        if limitby:
            (lmin, lmax) = limitby
            limit = ' FIRST %i' % (lmax - lmin)
            offset = ' SKIP %i' % lmin
        if for_update:
            upd = ' FOR UPDATE'
        return 'SELECT%s%s%s %s FROM %s%s%s%s%s;' % (
            dst, limit, offset, fields, tables, whr, grp, order, upd)

    def drop_table(self, table, mode):
        sequence_name = table._sequence_name
        return [
            'DROP TABLE %s %s;' % (table._rname, mode),
            'DROP GENERATOR %s;' % sequence_name]

    def truncate(self, table, mode=''):
        return [
            'DELETE FROM %s;' % table._rname,
            'SET GENERATOR %s TO 0;' % table._sequence_name]