import base64
import json
import uuid

from flexmock import flexmock
import pytest

from ytownership import config
from ytownership.connectors import mysql
from ytownership.connectors import sqs
from ytownership.logic import message as message_module
from ytownership.logic import patch_ownership as patch_ownership_module
from ytownership.utils.response import Response


TEST_INVALID_BODY = {
    'content_owner_id': 'owner',
    'territories': ['US', 'CA']
}

TEST_VALID_BODY = {
    'content_owner_id': 'owner',
    'territories': ['US', 'CA'],
    'isrc': config.TEST_ISRCS[0]
}


@pytest.fixture
def mock_invalid_message():
    message_body = json.dumps(TEST_INVALID_BODY)
    message_body = base64.b64encode(
        message_body.encode('utf-8')).decode('utf-8')
    message_attributes = {'Correlation-Id': {'StringValue': str(uuid.uuid4())}}
    mock_message = flexmock(
        body=message_body,
        message_attributes=message_attributes)
    return sqs.JSONMessageExt(mock_message)


@pytest.fixture
def mock_valid_message():
    message_body = json.dumps(TEST_VALID_BODY)
    message_body = base64.b64encode(
        message_body.encode('utf-8')).decode('utf-8')
    message_attributes = {'Correlation-Id': {'StringValue': str(uuid.uuid4())}}
    mock_message = flexmock(
        body=message_body,
        message_attributes=message_attributes)
    return sqs.JSONMessageExt(mock_message)


@pytest.fixture(params=[500, 401])
def mock_error_response(request):
    resp = Response(message='Error received.', status=request.param)
    return resp


@pytest.fixture(params=[400, 403, 404])
def mock_failure_response(request):
    resp = Response(message='Error received.', status=request.param)
    return resp


@pytest.fixture
def mock_success_response():
    resp = Response(message='Successful patched.', status=200)
    return resp


def test_process_message_validation_failed(mock_invalid_message):
    """Test process_message returns FAILURE in case of invalid message.
    """

    result = message_module.process_message(mock_invalid_message)
    assert result == message_module.MessageProcessingResult.FAILURE


def test_process_message_youtube_error(
        mock_valid_message, mock_error_response, db_fixture):
    """Test process_message returns ERROR in case of YouTube error 500.

    Also, validating that the results are being stored to DB.
    """

    (flexmock(patch_ownership_module)
        .should_receive('patch_ownership').and_return(mock_error_response))
    (flexmock(message_module)
        .should_call('save_result')
        .with_args(mock_valid_message, mock_error_response)
        .once())
    result = message_module.process_message(mock_valid_message)
    assert result == message_module.MessageProcessingResult.ERROR


def test_process_message_youtube_failed(
        mock_valid_message, mock_failure_response, db_fixture):
    """Test process_message returns SUCCESS in case of YouTube error 404.

    Also, validating that the results are being stored to DB.
    """

    (flexmock(patch_ownership_module)
        .should_receive('patch_ownership').and_return(mock_failure_response))
    (flexmock(message_module)
        .should_call('save_result')
        .with_args(mock_valid_message, mock_failure_response)
        .once())
    result = message_module.process_message(mock_valid_message)
    assert result == message_module.MessageProcessingResult.FAILURE


def test_process_message_success_save_results(
        mock_valid_message, mock_success_response, db_fixture):
    """Test process_message returns SUCCESS in case of YouTube error 200.

    Also, validating that the results are being stored to DB if we have this
    option enabled in config.
    """

    flexmock(config).should_receive('TRACK_SUCCESSFUL_API_CALLS').and_return(1)
    (flexmock(patch_ownership_module)
        .should_receive('patch_ownership').and_return(mock_success_response))
    (flexmock(message_module)
        .should_call('save_result')
        .with_args(mock_valid_message, mock_success_response)
        .once())
    result = message_module.process_message(mock_valid_message)
    assert result == message_module.MessageProcessingResult.SUCCESS


def test_process_message_success_dont_save_results(
        mock_valid_message, mock_success_response, db_fixture):
    """Test process_message returns SUCCESS in case of YouTube error 200.

    Also, validating that the results are not being stored to DB if we have
    this option disabled in config.
    """

    flexmock(config).should_receive('TRACK_SUCCESSFUL_API_CALLS').and_return(0)
    (flexmock(patch_ownership_module)
        .should_receive('patch_ownership').and_return(mock_success_response))
    (flexmock(mysql)
        .should_call('session_scope')
        .times(0))
    result = message_module.process_message(mock_valid_message)
    assert result == message_module.MessageProcessingResult.SUCCESS