import os
from unittest import mock

import smart_open

from slz_gdpr_email_downloader.entities import SNSMessage
from slz_gdpr_email_downloader.services.email_service import EmailService
from slz_gdpr_email_downloader.services.s3_repo import S3Repository
from slz_gdpr_email_downloader.services.validation import EmailValidationService
from slz_gdpr_email_downloader.worker import Worker
from . import FIXTURES_PATH


def test_process_contexts_ok(config_test, payload_test, s3_client):
    with smart_open.open(os.path.join(FIXTURES_PATH, '08fbkert')) as file_:
        email_content = file_.read()
    s3_client.put_object(
        Body=email_content,
        Bucket=config_test.bucket_source,
        Key='appreciationengine/request_to_forget/08fbkert',
    )
    schema = os.path.join(FIXTURES_PATH, 'validation', '2021-04-01.json')
    with smart_open.open(schema) as file_:
        s3_client.put_object(
            Body=file_.read(),
            Bucket=config_test.config_bucket,
            Key='schemas/appreciationengine/request_to_forget/v1/2021-04-01.json',
        )
    pg_service = mock.Mock()
    pg_service.cs_filter_out_already_processed.return_value = ['08fbkert']
    logger = mock.Mock()
    sns_service = mock.Mock()
    s3_repo = S3Repository(logger, config_test, payload_test, s3_client)
    email_service = EmailService(logger, config_test, payload_test, s3_repo)
    validation_service = EmailValidationService(
        logger=logger, config=config_test, payload=payload_test, s3_client=s3_client
    )
    worker = Worker(logger, pg_service, email_service, validation_service, sns_service)
    processing_result = worker.process()
    response = s3_client.get_object(
        Bucket=config_test.bucket_destination,
        Key='appreciationengine/request_to_forget/'
        'SM_FanDeleteRequest_20210401_08fbkert.csv'
    )['Body'].read()
    assert response == b'Email_Address\r\n"test1@gmail.com"\r\n"test2@gmail.com"'
    assert processing_result == {'08fbkert': True}

    pg_service.cs_start_processing.assert_called_once()
    pg_service.cs_save_success.assert_called_once()
    sns_service.push.assert_not_called()


def test_process_contexts_no_attach(config_test, payload_test, s3_client):
    with smart_open.open(os.path.join(FIXTURES_PATH, '08fbkert_no_attach')) as file_:
        email_content = file_.read()
    s3_client.put_object(
        Body=email_content,
        Bucket=config_test.bucket_source,
        Key='appreciationengine/request_to_forget/08fbkert_no_attach',
    )
    schema = os.path.join(FIXTURES_PATH, 'validation', '2021-04-01.json')
    with smart_open.open(schema) as file_:
        s3_client.put_object(
            Body=file_.read(),
            Bucket=config_test.config_bucket,
            Key='schemas/appreciationengine/request_to_forget/v1/2021-04-01.json',
        )
    pg_service = mock.Mock()
    pg_service.cs_filter_out_already_processed.return_value = ['08fbkert_no_attach']
    logger = mock.Mock()
    sns_service = mock.Mock()
    s3_repo = S3Repository(logger, config_test, payload_test, s3_client)
    email_service = EmailService(logger, config_test, payload_test, s3_repo)
    validation_service = EmailValidationService(
        logger=logger, config=config_test, payload=payload_test, s3_client=s3_client
    )
    worker = Worker(logger, pg_service, email_service, validation_service, sns_service)
    processing_result = worker.process()

    assert processing_result == {'08fbkert_no_attach': False}

    pg_service.cs_start_processing.assert_called_once()
    pg_service.cs_save_cancelled.assert_called_once()
    sns_service.push.assert_called_once_with(
        SNSMessage(
            type='ERROR', description='No attachment found in email', context='08fbkert_no_attach'
        )
    )


def test_process_contexts_broken_attach(config_test, payload_test, s3_client):
    with smart_open.open(os.path.join(FIXTURES_PATH, '37sure_broken_attach')) as file_:
        email_content = file_.read()
    s3_client.put_object(
        Body=email_content,
        Bucket=config_test.bucket_source,
        Key='appreciationengine/request_to_forget/37sure_broken_attach',
    )
    schema = os.path.join(FIXTURES_PATH, 'validation', '2021-04-01.json')
    with smart_open.open(schema) as file_:
        s3_client.put_object(
            Body=file_.read(),
            Bucket=config_test.config_bucket,
            Key='schemas/appreciationengine/request_to_forget/v1/2021-04-01.json',
        )
    pg_service = mock.Mock()
    pg_service.cs_filter_out_already_processed.return_value = ['37sure_broken_attach']
    logger = mock.Mock()
    sns_service = mock.Mock()
    s3_repo = S3Repository(logger, config_test, payload_test, s3_client)
    email_service = EmailService(logger, config_test, payload_test, s3_repo)
    validation_service = EmailValidationService(
        logger=logger, config=config_test, payload=payload_test, s3_client=s3_client
    )
    worker = Worker(logger, pg_service, email_service, validation_service, sns_service)
    processing_result = worker.process()

    assert processing_result == {'37sure_broken_attach': False}

    pg_service.cs_start_processing.assert_called_once()
    pg_service.cs_save_cancelled.assert_called_once()
    sns_service.push.assert_called_once_with(
        SNSMessage(
            type='ERROR',
            description='Email address "mfelten" is not valid',
            context='37sure_broken_attach'
        )
    )


def test_process_contexts_attach_incorrect_structure(config_test, payload_test, s3_client):
    with smart_open.open(os.path.join(FIXTURES_PATH, '37sure_attach_incorrect_structure')) as file_:
        email_content = file_.read()
    s3_client.put_object(
        Body=email_content,
        Bucket=config_test.bucket_source,
        Key='appreciationengine/request_to_forget/37sure_attach_incorrect_structure',
    )
    schema = os.path.join(FIXTURES_PATH, 'validation', '2021-04-01.json')
    with smart_open.open(schema) as file_:
        s3_client.put_object(
            Body=file_.read(),
            Bucket=config_test.config_bucket,
            Key='schemas/appreciationengine/request_to_forget/v1/2021-04-01.json',
        )
    pg_service = mock.Mock()
    pg_service.cs_filter_out_already_processed.return_value = ['37sure_attach_incorrect_structure']
    logger = mock.Mock()
    sns_service = mock.Mock()
    s3_repo = S3Repository(logger, config_test, payload_test, s3_client)
    email_service = EmailService(logger, config_test, payload_test, s3_repo)
    validation_service = EmailValidationService(
        logger=logger, config=config_test, payload=payload_test, s3_client=s3_client
    )
    worker = Worker(logger, pg_service, email_service, validation_service, sns_service)
    processing_result = worker.process()

    assert processing_result == {'37sure_attach_incorrect_structure': False}

    pg_service.cs_start_processing.assert_called_once()
    pg_service.cs_save_cancelled.assert_called_once()
    sns_service.push.assert_called_once_with(
        SNSMessage(
            type='ERROR',
            description='File content has incorrect structure',
            context='37sure_attach_incorrect_structure'
        )
    )


def test_process_contexts_unexpected_exception(config_test, payload_test, s3_client):
    with smart_open.open(os.path.join(FIXTURES_PATH, '08fbkert')) as file_:
        email_content = file_.read()
    s3_client.put_object(
        Body=email_content,
        Bucket=config_test.bucket_source,
        Key='appreciationengine/request_to_forget/08fbkert',
    )
    schema = os.path.join(FIXTURES_PATH, 'validation', '2021-04-01.json')
    with smart_open.open(schema) as file_:
        s3_client.put_object(
            Body=file_.read(),
            Bucket=config_test.config_bucket,
            Key='schemas/appreciationengine/request_to_forget/v1/2021-04-01.json',
        )
    pg_service = mock.Mock()
    pg_service.cs_filter_out_already_processed.return_value = ['08fbkert']
    logger = mock.Mock()
    sns_service = mock.Mock()
    s3_repo = S3Repository(logger, config_test, payload_test, s3_client)
    email_service = EmailService(logger, config_test, payload_test, s3_repo)
    validation_service = EmailValidationService(
        logger=logger, config=config_test, payload=payload_test, s3_client=s3_client
    )
    pg_service.cs_save_success.side_effect = mock.Mock(side_effect=KeyError('foo'))
    worker = Worker(logger, pg_service, email_service, validation_service, sns_service)
    processing_result = worker.process()

    assert processing_result == {'08fbkert': False}
    # fail record instead of cancelling
    pg_service.cs_save_failed.assert_called_once()
    sns_service.push.assert_not_called()


def test_process_contexts_no_email(config_test, payload_test, s3_client):
    pg_service = mock.Mock()
    logger = mock.Mock()
    validation_service = mock.Mock()
    sns_service = mock.Mock()
    s3_repo = S3Repository(logger, config_test, payload_test, s3_client)
    email_service = EmailService(logger, config_test, payload_test, s3_repo)

    worker = Worker(logger, pg_service, email_service, validation_service, sns_service)
    processing_result = worker.process()

    assert processing_result == {}

    pg_service.cs_start_processing.assert_not_called()