"""

   Schema module providing common schema operations.

"""

import warnings

from UserDict import DictMixin

import sqlalchemy

from sqlalchemy.schema import ForeignKeyConstraint

from sqlalchemy.schema import UniqueConstraint

from kallithea.lib.dbmigrate.migrate.exceptions import *

from kallithea.lib.dbmigrate.migrate.changeset import SQLA_06, SQLA_07

from kallithea.lib.dbmigrate.migrate.changeset.databases.visitor import (get_engine_visitor,

                                                                         run_single_visitor)

__all__ = [

    'create_column',

    'drop_column',

    'alter_column',

    'rename_table',

    'rename_index',

    'ChangesetTable',

    'ChangesetColumn',

    'ChangesetIndex',

    'ChangesetDefaultClause',

    'ColumnDelta',

]

def create_column(column, table=None, *p, **kw):

    """Create a column, given the table.

    API to :meth:`ChangesetColumn.create`.

    """

    if table is not None:

        return table.create_column(column, *p, **kw)

    return column.create(*p, **kw)

def drop_column(column, table=None, *p, **kw):

    """Drop a column, given the table.

    API to :meth:`ChangesetColumn.drop`.

    """

    if table is not None:

        return table.drop_column(column, *p, **kw)

    return column.drop(*p, **kw)

def rename_table(table, name, engine=None, **kw):

    """Rename a table.

    If Table instance is given, engine is not used.

    API to :meth:`ChangesetTable.rename`.

    :param table: Table to be renamed.

    :param name: New name for Table.

    :param engine: Engine instance.

    :type table: string or Table instance

    :type name: string

    :type engine: obj

    """

    table = _to_table(table, engine)

    table.rename(name, **kw)

def rename_index(index, name, table=None, engine=None, **kw):

    """Rename an index.

    If Index instance is given,

    table and engine are not used.

    API to :meth:`ChangesetIndex.rename`.

    :param index: Index to be renamed.

    :param name: New name for index.

    :param engine: Engine instance.

    :type index: string or Index instance

    :type name: string

    :type table: string or Table instance

    :type engine: obj

    """

    index = _to_index(index, table, engine)

    index.rename(name, **kw)

def alter_column(*p, **k):

    """Alter a column.

    This is a helper function that creates a :class:`ColumnDelta` and

    runs it.

    :argument column:

      The name of the column to be altered or a

      :class:`ChangesetColumn` column representing it.

    :param table:

      A :class:`~sqlalchemy.schema.Table` or table name to

      for the table where the column will be changed.

    :param engine:

      The :class:`~sqlalchemy.engine.base.Engine` to use for table

      reflection and schema alterations.

    :returns: A :class:`ColumnDelta` instance representing the change.

    """

    if 'table' not in k and isinstance(p[0], sqlalchemy.Column):

        k['table'] = p[0].table

    if 'engine' not in k:

        k['engine'] = k['table'].bind

    # deprecation

    if len(p) >= 2 and isinstance(p[1], sqlalchemy.Column):

        warnings.warn(

            "Passing a Column object to alter_column is deprecated."

            " Just pass in keyword parameters instead.",

            MigrateDeprecationWarning

            )

    engine = k['engine']

    # enough tests seem to break when metadata is always altered

    # that this crutch has to be left in until they can be sorted

    # out

    k['alter_metadata']=True

    delta = ColumnDelta(*p, **k)

    visitorcallable = get_engine_visitor(engine, 'schemachanger')

    engine._run_visitor(visitorcallable, delta)

    return delta

def _to_table(table, engine=None):

    """Return if instance of Table, else construct new with metadata"""

    if isinstance(table, sqlalchemy.Table):

        return table

    # Given: table name, maybe an engine

    meta = sqlalchemy.MetaData()

    if engine is not None:

        meta.bind = engine

    return sqlalchemy.Table(table, meta)

def _to_index(index, table=None, engine=None):

    """Return if instance of Index, else construct new with metadata"""

    if isinstance(index, sqlalchemy.Index):

        return index

    # Given: index name; table name required

    table = _to_table(table, engine)

    ret = sqlalchemy.Index(index)

    ret.table = table

    return ret

class ColumnDelta(DictMixin, sqlalchemy.schema.SchemaItem):

    """Extracts the differences between two columns/column-parameters

        May receive parameters arranged in several different ways:

        * **current_column, new_column, \*p, \*\*kw**

            Additional parameters can be specified to override column

            differences.

        * **current_column, \*p, \*\*kw**

            Additional parameters alter current_column. Table name is extracted

            from current_column object.