# pylint: disable=redefined-outer-name,unused-argument,invalid-name,too-many-locals
import os
from datetime import timedelta
from typing import Tuple, Type, Union
from unittest import mock

import boto3
import pytest
from _pytest.fixtures import SubRequest
from dapd_db_schema.schemas import workflow as schema
from moto import mock_s3
from smelog.factory import SmeBoundLogger

from dapd_public_api_scraper.config import entity
from dapd_public_api_scraper.entity.base import Task
from dapd_public_api_scraper.repository import postgres
from dapd_public_api_scraper.utils.misc import utcnow
from tests.entities import AppleMusicMetaEntity, SpotifyMetaEntity
from tests.utils import get_album, get_artist, get_playlist, get_track

ROOT_PATH: str = os.path.dirname(__file__)
TaskAndItemResponse = Tuple[
    Task,
    Union[AppleMusicMetaEntity, SpotifyMetaEntity],
    Type[Union[AppleMusicMetaEntity, SpotifyMetaEntity]],
    str
]  # yapf: disable


@pytest.fixture
def logger():
    return mock.create_autospec(SmeBoundLogger)


@pytest.fixture
def db(logger, request: SubRequest):
    if not request.node.get_closest_marker('integration'):
        yield mock.Mock()
    else:
        db_url = os.getenv('DB_URL')
        conn = postgres.Postgres(logger, 'test', params=entity.Postgres(db_url))
        yield conn
        conn.disconnect()


@pytest.fixture(scope='function', autouse=True)
def aws_credentials():
    os.environ['AWS_ACCESS_KEY_ID'] = 'testing'
    os.environ['AWS_SECRET_ACCESS_KEY'] = 'testing'
    os.environ['AWS_SECURITY_TOKEN'] = 'testing'
    os.environ['AWS_SESSION_TOKEN'] = 'testing'
    os.environ['AWS_DEFAULT_REGION'] = 'us-east-2'


@pytest.fixture(scope='function')
def s3_client(aws_credentials):
    with mock_s3():
        del os.environ['AWS_DEFAULT_REGION']  # moto_s3 fails when region is set
        yield boto3.client('s3')


@pytest.fixture(scope='session')
def s3_backup_dir() -> str:
    return os.path.join(ROOT_PATH, 's3_backup')


@pytest.fixture(scope='session')
def s3_backup_apple_music_dir(s3_backup_dir) -> str:
    return os.path.join(s3_backup_dir, 'apple_music')


@pytest.fixture(scope='session')
def s3_backup_spotify_dir(s3_backup_dir) -> str:
    return os.path.join(s3_backup_dir, 'spotify')


@pytest.fixture(scope='session')
def schemas_dir() -> str:
    return os.path.join(ROOT_PATH, 'schemas')


@pytest.fixture(scope='session')
def schemas_apple_music_dir(schemas_dir) -> str:
    return os.path.join(schemas_dir, 'apple_music')


@pytest.fixture(scope='session')
def schemas_spotify_dir(schemas_dir) -> str:
    return os.path.join(schemas_dir, 'spotify')


@pytest.fixture(scope='session')
def raw_data_dir() -> str:
    return os.path.join(ROOT_PATH, 'raw_data')


@pytest.fixture(scope='session')
def raw_data_apple_music_dir(raw_data_dir) -> str:
    return os.path.join(raw_data_dir, 'apple_music')


@pytest.fixture(scope='session')
def raw_data_spotify_dir(raw_data_dir) -> str:
    return os.path.join(raw_data_dir, 'spotify')


@pytest.fixture
def album_test(
    db: postgres.Postgres,
    data_source_test: schema.DataSource,
    task_and_item__indirect: TaskAndItemResponse,
) -> schema.Album:
    task, item, *_ = task_and_item__indirect
    now = utcnow()
    album = get_album(
        id=task.id,
        name=item.name,
        label=item.name,
        data_source_id=data_source_test.id,
        created_at=now,
        expired_at=now + timedelta(hours=4),
    )

    db.session.add(album)
    db.session.commit()

    yield album

    db.session.query(schema.Album).delete()
    db.session.commit()


@pytest.fixture
def artist_test(
    db: postgres.Postgres,
    data_source_test: schema.DataSource,
    task_and_item__indirect: TaskAndItemResponse,
) -> schema.Artist:
    task, item, *_ = task_and_item__indirect
    now = utcnow()
    artist = get_artist(
        id=task.id,
        name=item.name,
        label=item.name,
        data_source_id=data_source_test.id,
        created_at=now,
        expired_at=now + timedelta(hours=4),
    )

    db.session.add(artist)
    db.session.commit()

    yield artist

    db.session.query(schema.Artist).delete()
    db.session.commit()


@pytest.fixture
def playlist_test(
    db: postgres.Postgres,
    data_source_test: schema.DataSource,
    task_and_item__indirect: TaskAndItemResponse,
) -> schema.Playlist:
    task, *_ = task_and_item__indirect
    now = utcnow()
    playlist = get_playlist(
        name='pop',
        label='pop100',
        id=task.id,
        data_source_id=data_source_test.id,
        storefront_id=task.storefront,
        created_at=now,
        expired_at=now + timedelta(hours=4),
    )

    db.session.add(playlist)
    db.session.commit()

    yield playlist

    db.session.query(schema.Playlist).delete()
    db.session.commit()


@pytest.fixture
def track_test(
    db: postgres.Postgres,
    data_source_test: schema.DataSource,
    task_and_item__indirect: TaskAndItemResponse,
) -> schema.Track:
    task, item, *_ = task_and_item__indirect
    now = utcnow()
    track = get_track(
        id=task.id,
        name=item.name,
        label=item.name,
        data_source_id=data_source_test.id,
        created_at=now,
        expired_at=now + timedelta(hours=4),
    )

    db.session.add(track)
    db.session.commit()

    yield track

    db.session.query(schema.Track).delete()
    db.session.commit()