"""Test utils."""
from datetime import datetime
import os
import unittest
from unittest.mock import ANY

import boto3
import config
from constants import queries
from ddex_ingester_common.helpers.rds import run_rds_query

logger = config.get_current_logger(config.app_logger)


def assert_ingestion_not_started(start_execution_by_arn, s3_key_name):
    """Assert sfn ingestion_not_started."""
    if isinstance(s3_key_name, str):
        try:
            start_execution_by_arn. \
                assert_any_call(ANY, ANY, s3_key_name, ANY, ANY)
        except AssertionError:
            return
        raise AssertionError()
    else:
        for key in s3_key_name:
            try:
                start_execution_by_arn. \
                    assert_any_call(ANY, ANY, key, ANY, ANY)
            except AssertionError:
                continue
            raise AssertionError()


def assert_ingestion_started(start_execution_by_arn, s3_key_name,
                             artwork_ingestion_only=False):
    """Assert sfn ingestion_started."""
    if isinstance(s3_key_name, str):
        start_execution_by_arn. \
            assert_any_call(ANY, ANY, s3_key_name, ANY, ANY,
                            artwork_ingestion_only)
    else:
        for key in s3_key_name:
            start_execution_by_arn. \
                assert_any_call(ANY, ANY, key, ANY, ANY,
                                artwork_ingestion_only)


class DdexQueryTest(unittest.TestCase):
    """Basic class for integration testing."""

    @staticmethod
    def set_ddex_delivery_to_ingest_succeeded(key):
        """Set ddex delivery status to ingest_succeeded"""
        query = f"""
          UPDATE ddex_ingester.ddex_delivery_to_ingest_query_test
          SET status = 'ingest_succeeded'
          WHERE s3_key_name = '{key}';
        """

        run_rds_query(
            logger,
            config.RDS_HOST,
            config.RDS_DB_NAME,
            config.RDS_RW_USER,
            config.RDS_PASSWORD,
            query,
            None,
        )

    @staticmethod
    def insert_ddex_delivery(s3_key_name,
                             original_release_datetime,
                             has_artwork=0,
                             is_confidential=0,
                             status='delivered'
                             ):
        if is_confidential == 1 or str(is_confidential).lower() == 'true':
            is_confidential = 1
        elif is_confidential == 0 or str(is_confidential).lower() == 'false':
            is_confidential = 0

        if has_artwork == 1 or str(has_artwork).lower() == 'true':
            has_artwork = 1
        elif has_artwork == 0 or str(has_artwork).lower() == 'false':
            has_artwork = 0

        grid = s3_key_name.split('/')[-1].split('.')[0]
        insert_query = f"""
        INSERT INTO ddex_ingester.ddex_delivery_to_ingest_query_test
            (catalog_ingestion_source_id, received_timestamp, s3_bucket_name, 
             s3_key_name, status, LAST_UPDATED, is_confidential, has_artwork,
             original_release_datetime, grid)
        VALUES( 5, CURRENT_TIMESTAMP, 'test_scenario_1', 
                '{s3_key_name}', '{status}',  CURRENT_TIMESTAMP, {is_confidential}, {has_artwork},
                '{original_release_datetime}', '{grid}');
         """

        run_rds_query(
            logger,
            config.RDS_HOST,
            config.RDS_DB_NAME,
            config.RDS_RW_USER,
            config.RDS_PASSWORD,
            insert_query,
            None,
        )

    @staticmethod
    def cleanup_ddex_delivery_to_ingest_query_test():
        delete_query = "delete from " \
                       "ddex_ingester.ddex_delivery_to_ingest_query_test"

        run_rds_query(logger,
                      config.RDS_HOST,
                      config.RDS_DB_NAME,
                      config.RDS_RW_USER,
                      config.RDS_PASSWORD,
                      delete_query,
                      None,
                      )

    @staticmethod
    def mock_myql_db_time(current_time: datetime):
        datetime_format = "%Y-%m-%d %H:%M:%S"
        mysql_format = "%Y-%m-%d %H:%i:%s"

        mock_now = f'STR_TO_DATE("{current_time.strftime(datetime_format)}","{mysql_format}")'
        queries.NON_CONFIDENTIAL_DDEX_DELIVERIES = \
            queries.NON_CONFIDENTIAL_DDEX_DELIVERIES.replace('now()', mock_now)

        queries.CONFIDENTIAL_DDEX_DELIVERIES = \
            queries.CONFIDENTIAL_DDEX_DELIVERIES.replace('now()', mock_now)

    @classmethod
    def setUpClass(cls):
        if not os.environ.get('RDS_PASSWORD'):
            # set config.RDS_PASSWORD
            role_arn = 'arn:aws:iam::437795906767:role/qa-ddex-ingester-sme-analytics-ingestion-flow-control-role'
            secret_id = 'qa/ddex-ingester-sme-analytics-ingestion-flow-control/DDEX-INGESTER-TEST-PASSWORD'

            client = boto3.client('sts', region_name='us-east-1')
            response = client.assume_role(
                RoleArn=role_arn,
                RoleSessionName='feed_ingestion')['Credentials']

            credentials = {
                'aws_access_key_id': response['AccessKeyId'],
                'aws_secret_access_key': response['SecretAccessKey'],
                'aws_session_token': response['SessionToken']
            }

            client = boto3.client('secretsmanager', region_name='us-east-1',
                                  **credentials)
            config.RDS_PASSWORD = client.get_secret_value(SecretId=secret_id)[
                'SecretString']

        if 'ddex_delivery_to_ingest_query_test' not in queries.NON_CONFIDENTIAL_DDEX_DELIVERIES:
            # mock target database table
            queries.NON_CONFIDENTIAL_DDEX_DELIVERIES = queries.NON_CONFIDENTIAL_DDEX_DELIVERIES.replace(
                'ddex_ingester.ddex_delivery_to_ingest',
                'ddex_ingester.ddex_delivery_to_ingest_query_test')

        if 'ddex_delivery_to_ingest_query_test' not in queries.CONFIDENTIAL_DDEX_DELIVERIES:
            # mock target database table
            queries.CONFIDENTIAL_DDEX_DELIVERIES = queries.CONFIDENTIAL_DDEX_DELIVERIES.replace(
                'ddex_ingester.ddex_delivery_to_ingest',
                'ddex_ingester.ddex_delivery_to_ingest_query_test')

        if 'ddex_delivery_to_ingest_query_test' not in queries.UPDATE_ROW_STATUS:
            queries.UPDATE_ROW_STATUS = queries.UPDATE_ROW_STATUS.replace(
                'ddex_ingester.ddex_delivery_to_ingest',
                'ddex_ingester.ddex_delivery_to_ingest_query_test')

        if 'ddex_delivery_to_ingest_query_test' not in queries.PURGED_DDEX_DELIVERIES:
            queries.PURGED_DDEX_DELIVERIES = queries.PURGED_DDEX_DELIVERIES.replace(
                'ddex_ingester.ddex_delivery_to_ingest',
                'ddex_ingester.ddex_delivery_to_ingest_query_test')

        cls.NON_CONFIDENTIAL_DDEX_DELIVERIES = queries.NON_CONFIDENTIAL_DDEX_DELIVERIES
        cls.CONFIDENTIAL_DDEX_DELIVERIES = queries.CONFIDENTIAL_DDEX_DELIVERIES
        cls.PURGED_DDEX_DELIVERIES = queries.PURGED_DDEX_DELIVERIES

    def setUp(self):
        self.cleanup_ddex_delivery_to_ingest_query_test()

    def tearDown(self):
        queries.NON_CONFIDENTIAL_DDEX_DELIVERIES = self.NON_CONFIDENTIAL_DDEX_DELIVERIES
        queries.CONFIDENTIAL_DDEX_DELIVERIES = self.CONFIDENTIAL_DDEX_DELIVERIES
        queries.PURGED_DDEX_DELIVERIES = self.PURGED_DDEX_DELIVERIES