"""Utility functions to support database interactions in tests."""

import sys
from contextlib import contextmanager
from functools import wraps
from unittest import mock

from participant import config
from participant.connectors import mysql
from participant.models.artist_name_updates import (
    ArtistInfo,
    ArtistYoutubeDeliverySettings,
    Project,
    ReleaseArtist,
    Releases,
    Track,
    TrackArtist,
    TrackWriter,
)
from sqlalchemy import text

CREATE_ARTIST_INFO_TABLE = """
CREATE TABLE IF NOT EXISTS `artist_info`
(
    `artist_id` INTEGER NOT NULL PRIMARY KEY,
    `vendor_id` INTEGER NOT NULL,
    `name` VARCHAR(255) NOT NULL
)
"""


DROP_ARTIST_INFO_TABLE = """
DROP TABLE IF EXISTS `artist_info`
"""


CREATE_RELEASE_ARTIST_TABLE = """
CREATE TABLE IF NOT EXISTS `release_artist`
(
    `release_artist_id` INTEGER NOT NULL PRIMARY KEY,
    `artist_name` VARCHAR(255),
    `upc` BIGINT,
    `release_id` INTEGER NOT NULL,
    `artist_info_id` INTEGER NULL
)
"""


DROP_RELEASE_ARTIST_TABLE = """
DROP TABLE IF EXISTS `release_artist`
"""


CREATE_RELEASES_TABLE = """
CREATE TABLE IF NOT EXISTS `releases`
(
    `release_id` INTEGER NOT NULL PRIMARY KEY,
    `upc` BIGINT,
    `artist_id` INTEGER NOT NULL,
    `project_id` INTEGER NOT NULL,
    `last_updated` DATETIME NULL
)
"""


DROP_RELEASES_TABLE = """
DROP TABLE IF EXISTS `releases`
"""


CREATE_PROJECT_TABLE = """
CREATE TABLE IF NOT EXISTS `project`
(
    `project_id` INTEGER NOT NULL PRIMARY KEY,
    `vendor_id` INTEGER NOT NULL,
    `artist_id` INTEGER NOT NULL
)
"""


DROP_PROJECT_TABLE = """
DROP TABLE IF EXISTS `project`
"""

CREATE_TRACK_TABLE = """
CREATE TABLE IF NOT EXISTS `track`
(
    `id` INTEGER NOT NULL PRIMARY KEY,
    `release_id` INTEGER NOT NULL
)
"""


DROP_TRACK_TABLE = """
DROP TABLE IF EXISTS `track`
"""


CREATE_ARTIST_YT_DELIVERY_SETTINGS_TABLE = """
CREATE TABLE IF NOT EXISTS `artist_yt_delivery_settings`
(
    `id` INTEGER NOT NULL PRIMARY KEY,
    `artist_id` INTEGER NOT NULL
)
"""


DROP_ARTIST_YT_DELIVERY_SETTINGS_TABLE = """
DROP TABLE IF EXISTS `artist_yt_delivery_settings`
"""


CREATE_TRACK_ARTIST_TABLE = """
CREATE TABLE IF NOT EXISTS `track_artist`
(
    `id` INTEGER NOT NULL PRIMARY KEY,
    `name` VARCHAR(255),
    `track_id` INTEGER NOT NULL,
    `artist_info_id` INTEGER NULL
)
"""


DROP_TRACK_ARTIST_TABLE = """
DROP TABLE IF EXISTS `track_artist`
"""


CREATE_TRACK_WRITER_TABLE = """
CREATE TABLE IF NOT EXISTS `track_writer`
(
    `track_writer_id` INTEGER NOT NULL PRIMARY KEY,
    `writer_name` VARCHAR(255),
    `upc` BIGINT,
    `unique_track_id` INTEGER NOT NULL,
    `artist_info_id` INTEGER NULL
)
"""


DROP_TRACK_WRITER_TABLE = """
DROP TABLE IF EXISTS `track_writer`
"""


def execute_sql(*args):
    """Run a series of queries safely within the test environment."""
    with mysql.ar_db_session() as session:
        _exit_if_not_test_environment(session)

        for query in args:
            session.execute(query)


def seed_models(models):
    """Save the given model(s) to the DB.

    Args:
        models (list): list of model instances to save.

    """
    if not hasattr(models, '__iter__'):
        models = [models]

    with mysql.db_session() as session:
        _exit_if_not_test_environment(session)
        for model in models:
            session.add(model)
        session.flush()

        # detach the objects from this session so tests can interrogate them
        for model in models:
            session.expunge(model)


def test_schema(function):
    """Test schema.

    Decorator that creates the test DB schema before a function call and
    tears the schema down after the function call has finished.

    This just creates the schema and does not seed data. Indvidual test cases
    can use factories to seed data as needed.

    Args:
        function (func): function to be called after creating the test schema.

    Returns:
        Function: The decorated function.

    """

    @wraps(function)
    def call_function_within_db_context(*args, **kwargs):
        execute_sql(
            text(CREATE_ARTIST_INFO_TABLE),
            text(CREATE_RELEASE_ARTIST_TABLE),
            text(CREATE_RELEASES_TABLE),
            text(CREATE_PROJECT_TABLE),
            text(CREATE_TRACK_TABLE),
            text(CREATE_TRACK_ARTIST_TABLE),
            text(CREATE_TRACK_WRITER_TABLE),
            text(CREATE_ARTIST_YT_DELIVERY_SETTINGS_TABLE),
        )

        try:
            function_return = function(*args, **kwargs)
        finally:
            execute_sql(
                text(DROP_ARTIST_INFO_TABLE),
                text(DROP_RELEASE_ARTIST_TABLE),
                text(DROP_RELEASES_TABLE),
                text(DROP_PROJECT_TABLE),
                text(DROP_TRACK_TABLE),
                text(DROP_TRACK_ARTIST_TABLE),
                text(DROP_TRACK_WRITER_TABLE),
                text(DROP_ARTIST_YT_DELIVERY_SETTINGS_TABLE),
            )

        return function_return

    return call_function_within_db_context


def _exit_if_not_test_environment(session):
    """For safety, only run tests in test environment pointed to sqlite.

    Exit immediately if not in test environment or not pointed to
    sqlite.

    """
    if config.ENVIRONMENT != config.TEST_ENVIRONMENT:
        sys.exit('Environment must be set to {}.'.format(config.TEST_ENVIRONMENT))
    if 'sqlite' not in session.bind.url.drivername:
        sys.exit('Tests must point to sqlite database.')


def mock_db_session(mocker):
    """Create a mock database sesssion.

    Also mock the db_session context manager to use the mock session.

    """
    mock_session = mock.Mock(query=mock.Mock())

    @contextmanager
    def fake_session_manager():
        yield mock_session

    mocker.patch.object(mysql, 'ar_db_session', fake_session_manager)

    return mock_session


def insert_release_artist_data():
    """Insert data into release artist."""
    with mysql.ar_db_session() as session:
        release_artist = ReleaseArtist(
            release_artist_id=123, artist_name='test', upc=12345678, release_id=123
        )
        session.add(release_artist)
        session.commit()


def insert_releases_data():
    """Insert data into releases."""
    with mysql.ar_db_session() as session:
        releases = Releases(release_id=123, upc=12345678, artist_id=321, project_id=321)
        session.add(releases)
        session.commit()


def insert_artist_info_data():
    """Insert data into artist_info."""
    with mysql.ar_db_session() as session:
        artist_info = ArtistInfo(artist_id=321, vendor_id=25824, name='test')
        session.add(artist_info)
        session.commit()


def insert_track_artist_data():
    """Insert data into track_artist."""
    with mysql.ar_db_session() as session:
        track_artist = TrackArtist(track_artist_id=321, name='test', track_id=32)
        session.add(track_artist)
        session.commit()


def insert_track_data():
    """Insert data into track."""
    with mysql.ar_db_session() as session:
        track = Track(id=32, release_id=123)
        session.add(track)
        session.commit()


def insert_track_writer_data():
    """Insert data into track_writer."""
    with mysql.ar_db_session() as session:
        track_writer = TrackWriter(
            track_writer_id=321, writer_name='test', upc=12345678, unique_track_id=32
        )
        session.add(track_writer)
        session.commit()


def insert_project_data():
    """Insert data into project."""
    with mysql.ar_db_session() as session:
        project = Project(project_id=321, vendor_id=25824, artist_id=321)
        session.add(project)
        session.commit()


def insert_artist_yt_delivery_settings():
    """Insert data into artist_yt_delivery_settings."""
    with mysql.ar_db_session() as session:
        artist_yt_delivery_settings = ArtistYoutubeDeliverySettings(
            id=123, artist_id=321
        )
        session.add(artist_yt_delivery_settings)
        session.commit()