"""MySQL connector."""

from contextlib import contextmanager

from sqlalchemy import create_engine
from sqlalchemy.orm import declarative_base
from sqlalchemy.orm import scoped_session
from sqlalchemy.orm import sessionmaker

from deliveryhistory import config


class BaseModel(object):
    """Base model for territory data models."""

    @property
    def columns(self):
        """Get list of column names from the underlying table.

        Returns:
            list(str): list of column names from the table schema

        """
        return [column.name for column in self.__table__.columns]

    @property
    def columnitems(self):
        """Get list of columns from the underlying table.

        Returns:
            dict(column): dict of columns from the table schema

        """
        return dict(
            [(column, getattr(self, column)) for column in self.columns])

    def __repr__(self):
        """Get string representation of a model.

        Returns:
            str: string representation of a model

        """
        return '{}({})'.format(self.__class__.__name__, self.columnitems)

    def to_dict(self, include_primary_key=False, primary_key='id'):
        """Convert model to its JSON representation.

        Args:
            include_primary_key (bool): should primary key column be also
            included in generated JSON.
            primary_key (str): primary key column name

        Returns:
            dict: JSON representation of the model data

        """
        if include_primary_key:
            filtered = self.columnitems
        else:
            filtered = {
                k: v for k, v in self.columnitems.items() if k != primary_key}
        return filtered


BaseModel = declarative_base(cls=BaseModel)

_db_engine = create_engine(config.DB_CONNECTION_STRING, **config.DB_OPTIONS)
_db_session_factory = sessionmaker(bind=_db_engine, expire_on_commit=False)

_ar_db_engine = create_engine(config.AR_DB_URL, **config.DB_OPTIONS)
_ar_db_session_factory = sessionmaker(bind=_ar_db_engine, expire_on_commit=False)

_dd_db_engine = create_engine(config.DD_DB_URL, **config.DB_OPTIONS)
_dd_db_session_factory = sessionmaker(bind=_dd_db_engine, expire_on_commit=False)


@contextmanager
def session_scope():
    """Provide a transactional scope around a series of operations."""
    session = scoped_session(_db_session_factory)
    try:
        yield session
        session.commit()
    except Exception:
        session.rollback()
        raise
    finally:
        session.remove()


@contextmanager
def ar_session_scope():
    """Provide a transactional scope for ArtRelations database."""
    session = scoped_session(_ar_db_session_factory)
    try:
        yield session
        session.commit()
    except Exception:
        session.rollback()
        raise
    finally:
        session.remove()


@contextmanager
def dd_session_scope():
    """Provide a transactional scope for Direct Delivery database."""
    session = scoped_session(_dd_db_session_factory)
    try:
        yield session
        session.commit()
    except Exception:
        session.rollback()
        raise
    finally:
        session.remove()