# pylint: disable=unused-argument,protected-access,too-many-arguments
import json
import os
from typing import Dict
from unittest import mock

import boto3
import pytest
from boto3_type_annotations.s3 import Client as S3Client
from db_schema.postgres import connection
from db_schema.schemas import slz
from moto import mock_s3
from slz_storage.repository import Repository

from slz_spotify_charts_data_extender.entities import Config, Payload
from slz_spotify_charts_data_extender.repository import ContentStatusRepository
from slz_spotify_charts_data_extender.service import S3Service, Service, VendorAPIService
from . import FIXTURES_PATH


def get_public_data(market: str) -> Dict:
    public_data_path = os.path.join(
        FIXTURES_PATH, 'public_data', f'spotify_public_data_{market}.json'
    )
    if not os.path.exists(public_data_path):
        return {}
    data = {}
    with open(public_data_path, 'r') as _file:
        data = json.load(_file)
    return data


def get_df_source_data(market: str) -> Dict:
    source_data_path = os.path.join(FIXTURES_PATH, 'df_source', f'df_source_{market}.json')
    if not os.path.exists(source_data_path):
        return {}
    data = {}
    with open(source_data_path, 'r') as _file:
        data = json.load(_file)
    return data


@pytest.fixture
def config_test():
    return Config(
        environment='test',
        rds_secret_key='rds_secret_key',
        sentry_secret_key=None,
        config_bucket='config_bucket',
        source_bucket='decompressed_bucket',
        target_bucket='target_bucket',
        vendor_api_timeout='1000',
        vendor_api_cache_ttl='1000',
        vendor_api_host='https://test_hostname',
        auth_token_url='https://test_url',
        auth_client_id='test_client_id',
        auth_client_secret='test_client_secret',
        auth_audience='test_audience',
        concurrency='0',
        track_chunk_size=50,
    )


@pytest.fixture
def payload_test():
    return Payload(
        uow_id='spotify-20210801-sme-charts_daily_regional-v1',
        dsp='spotify',
        report_type='charts_daily_regional',
        application='charts',
        version='v1',
        licensor='sme',
        report_date='2021-08-01',
        job_id='test_job',
        recurrence_type='daily',
        chart_type='regional'
    )


@pytest.fixture
def vendor_api_service(payload_test, config_test):
    vendor_api = VendorAPIService(config=config_test, logger=mock.Mock())
    vendor_api._get_auth_token = mock.Mock(return_value='Bearer test')
    return vendor_api


@pytest.fixture
def s3_client(config_test):
    with mock_s3():
        buckets = [config_test.config_bucket, config_test.target_bucket, config_test.source_bucket]
        s3_client_: S3Client = boto3.client('s3')
        for bucket in buckets:
            s3_client_.create_bucket(Bucket=bucket)

        yield s3_client_

        s3_resource = boto3.resource('s3')
        for bucket in buckets:
            bucket = s3_resource.Bucket(bucket)
            bucket.objects.all().delete()
            bucket.delete()


@pytest.fixture
def s3_service(payload_test, config_test):
    return S3Service(logger=mock.Mock(), payload=payload_test, config=config_test)


@pytest.fixture
def main_service_no_db(payload_test, config_test, s3_service, vendor_api_service):
    return Service(
        logger=mock.Mock(),
        config=config_test,
        payload=payload_test,
        s3_service=s3_service,
        vendor_api_service=vendor_api_service,
        content_status_repository=mock.Mock()
    )


@pytest.fixture(scope='session')
def db():
    pg = connection.get_session(
        host=os.environ.get('PG_HOST', '0.0.0.0'),
        port=os.environ.get('PG_PORT', 5432),
        db=os.environ.get('PG_DB', 'slz'),
        user=os.environ.get('PG_USER', 'admin'),
        password=os.environ.get('PG_PASSWORD', 'admin'),
        engine_params={'echo': True}
    )

    yield pg


@pytest.fixture
def unit_of_work(db):
    report = db.query(slz.Report).filter(slz.Report.report_name == 'charts_daily_regional').one()
    unit_of_work = slz.UnitOfWork(
        **{
            'unit_of_work_code': 'spotify-20210801-sme-charts_daily_regional-v1',
            'reprocess_id': '',
            'report_date': '2021-08-01',
            'report_id': report.report_id,
            'licensor_id': 1,
            'version': 'v1',
            'activity_status': 'NOT_IN_PROGRESS',
            'completeness_status': 'ACTIVE',
            'next_run_at': '2021-08-02 08:26:09.715337',
            'created_at': '2021-08-01 01:00:58.806272',
            'last_updated_at': '2021-08-01 08:20:58.481813',
            'is_force_complete': False,
            'priority': 5
        }
    )
    db.add(unit_of_work)
    db.flush()

    yield unit_of_work


@pytest.fixture
def slz_repository(db):
    return Repository(
        logger=mock.Mock(),
        pg_conn=db,
    )


@pytest.fixture
def content_status_repository(payload_test, config_test, slz_repository):
    return ContentStatusRepository(
        logger=mock.Mock(),
        payload=payload_test,
        slz_pg_repository=slz_repository,
        config=config_test
    )