"""Test for ows_track model."""
from unittest.mock import MagicMock
from unittest.mock import NonCallableMagicMock

from flask import g
from flexmock import flexmock
from owsrequest import request
import pytest

from product_digital import api
from product_digital.constants import header
from product_digital.constants import services
from product_digital.exceptions import RequestError
from product_digital.models import ows_track


def test_validate_tracks_correct_call(
        mocker, valid_headers, product_id, test_request_context):
    """Test expected call made to tracks validate endpoint."""
    mock_validation_response = MagicMock(status_code=200)
    mock_validation_response.json = MagicMock(return_value={})
    mocker.patch.object(request, 'get', return_value=mock_validation_response)

    with api.app.test_request_context():
        g.request_context = NonCallableMagicMock(
            profile_type=None, profile_id=None, identity_id=None)
        ows_track.validate_tracks(product_id)

    request.get.assert_called_with(
        services.OWS_TRACK,
        '/product/{}/tracks/validate'.format(product_id),
        headers={},
        params={'validation_context': 'pre_submission'},
    )


def test_validate_tracks_correct_call_with_profile(
        mocker, valid_headers, product_id, test_request_context):
    """Test expected call with profile made to tracks validate endpoint."""
    mock_validation_response = MagicMock(status_code=200)
    mock_validation_response.json = MagicMock(return_value={})
    mocker.patch.object(request, 'get', return_value=mock_validation_response)

    with api.app.test_request_context():
        g.request_context = NonCallableMagicMock(
            profile_type='CoolProfile', profile_id=321, identity_id=None)
        ows_track.validate_tracks(product_id)

    request.get.assert_called_with(
        services.OWS_TRACK,
        '/product/{}/tracks/validate'.format(product_id),
        headers={
            'Orchard-Profile-Type': 'CoolProfile',
            'Orchard-Profile-Id': '321',
        },
        params={'validation_context': 'pre_submission'},
    )


def test_validate_tracks_context_specified(
        mocker, valid_headers, product_id):
    """Test expected call made to tracks validate endpoint."""
    mock_validation_response = MagicMock(status_code=200)
    mock_validation_response.json = MagicMock(return_value={})
    mocker.patch.object(request, 'get', return_value=mock_validation_response)

    with api.app.test_request_context():
        g.validation_context = 'some_context'
        g.request_context = NonCallableMagicMock(
            profile_type='CoolProfile',
            profile_id=321,
            identity_id=None,
        )

        ows_track.validate_tracks(product_id)

    request.get.assert_called_with(
        services.OWS_TRACK,
        '/product/{}/tracks/validate'.format(product_id),
        headers={
            'Orchard-Profile-Type': 'CoolProfile',
            'Orchard-Profile-Id': '321',
        },
        params={'validation_context': 'some_context'},
    )


def test_validate_tracks_success_return(
        valid_ows_tracks_message, mocker, valid_headers, product_id):
    """Test expected message returned from tracks validate endpoint."""
    mock_validation_response = MagicMock(status_code=200)
    mock_validation_response.json = MagicMock(
        return_value=valid_ows_tracks_message)
    mocker.patch.object(request, 'get', return_value=mock_validation_response)

    with api.app.test_request_context():
        g.validation_context = 'pre_submission'
        g.request_context = NonCallableMagicMock()

        result = ows_track.validate_tracks(product_id)
    assert result.status == 200
    assert result.message == valid_ows_tracks_message


def test_validate_tracks_success_return_no_correlation_id(
        valid_ows_tracks_message, mocker, valid_headers, product_id):
    """Test expected message returned from tracks validate endpoint."""
    mock_validation_response = MagicMock(status_code=200)
    mock_validation_response.json = MagicMock(
        return_value=valid_ows_tracks_message)
    mocker.patch.object(request, 'get', return_value=mock_validation_response)

    with api.app.test_request_context():
        g.validation_context = 'pre_submission'
        g.request_context = NonCallableMagicMock()

        result = ows_track.validate_tracks(product_id)

    assert result.status == 200
    assert result.message == valid_ows_tracks_message


def test_validate_tracks_error_return(mocker, valid_headers, product_id):
    """Test error message returned from tracks validate endpoint."""
    error_payload = {
        'code': 'ows_product_error', 'message': 'User is forbidden'}
    mock_validation_response = MagicMock(status_code=403)
    mock_validation_response.json = MagicMock(return_value=error_payload)
    mocker.patch.object(request, 'get', return_value=mock_validation_response)

    with api.app.test_request_context():
        g.validation_context = 'pre_submission'
        g.request_context = NonCallableMagicMock()

        result = ows_track.validate_tracks(product_id)

    assert result.status == 403
    assert result.errors.get('code') == error_payload.get('code')
    assert result.errors.get('message') == error_payload.get('message')


def test_validate_tracks_publishing_obligation_correct_call(
        mocker, valid_headers, product_id):
    """Test expected call made to tracks validate endpoint."""
    mock_validation_response = MagicMock(status_code=200)
    mock_validation_response.json = MagicMock(return_value={})
    mocker.patch.object(request, 'get', return_value=mock_validation_response)
    account_type = 'vendor'
    account_id = 25824

    params = {
        'account_type': account_type,
        'account_id': account_id}
    with api.app.test_request_context():
        g.request_context = NonCallableMagicMock(
            profile_type=None,
            profile_id=None,
        )
        ows_track.validate_publishing_obligation(
            product_id, account_type, account_id)

    request.get.assert_called_with(
        services.OWS_TRACK,
        '/product/{product_id}/tracks/validate/publishing-obligation'.format(
            product_id=product_id),
        params=params,
        headers={},
    )


def test_validate_tracks_publishing_obligation_correct_call_with_profile(
        mocker, valid_headers, product_id, test_request_context):
    """Test expected call made to tracks validate with profile endpoint."""
    mock_validation_response = MagicMock(status_code=200)
    mock_validation_response.json = MagicMock(return_value={})
    mocker.patch.object(request, 'get', return_value=mock_validation_response)
    account_type = 'vendor'
    account_id = 25824

    params = {
        'account_type': account_type,
        'account_id': account_id}

    with api.app.test_request_context():
        g.request_context = NonCallableMagicMock(
            profile_type='CoolProfile',
            profile_id=321,
        )
        ows_track.validate_publishing_obligation(
            product_id, account_type, account_id)

    request.get.assert_called_with(
        services.OWS_TRACK,
        '/product/{product_id}/tracks/validate/publishing-obligation'.format(
            product_id=product_id),
        params=params,
        headers={
            'Orchard-Profile-Type': 'CoolProfile',
            'Orchard-Profile-Id': '321',
        },
    )


def test_validate_publishing_obligation_success_return_no_correlation_id(
        valid_ows_tracks_message, mocker, valid_headers, product_id):
    """Test expected message returned from tracks validate endpoint."""
    mock_validation_response = MagicMock(status_code=200)
    mock_validation_response.json = MagicMock(
        return_value=valid_ows_tracks_message)
    mocker.patch.object(request, 'get', return_value=mock_validation_response)

    account_type = 'vendor'
    account_id = 25824
    with api.app.test_request_context():
        g.request_context = NonCallableMagicMock(
            profile_type=None,
            profile_id=None,
        )
        result = ows_track.validate_publishing_obligation(
            product_id, account_type, account_id)

    assert result.status == 200
    assert result.message == valid_ows_tracks_message


def test_validate_publishing_obligation_error_return(
        mocker, valid_headers, product_id):
    """Test error message returned from tracks validate endpoint."""
    error_payload = {
        'code': 'ows_track_error', 'message': 'User is forbidden'}
    mock_validation_response = MagicMock(status_code=403)
    mock_validation_response.json = MagicMock(return_value=error_payload)
    mocker.patch.object(request, 'get', return_value=mock_validation_response)

    account_type = 'vendor'
    account_id = 25824
    with api.app.test_request_context():
        g.request_context = NonCallableMagicMock(
            profile_type=None,
            profile_id=None,
        )
        result = ows_track.validate_publishing_obligation(
            product_id, account_type, account_id)

    assert result.status == 403
    assert result.errors.get('code') == error_payload.get('code')
    assert result.errors.get('message') == error_payload.get('message')


def test_get_track_by_track_id_correct_call():
    """Test correct call made to ows-track."""
    mock_response = MagicMock(status_code=200)
    mock_response.json = MagicMock(return_value={'track_name': 'My Track'})

    (flexmock(request).should_receive('get').with_args(
        services.OWS_TRACK,
        '/track/123',
    ).and_return(mock_response))

    ows_track.get_track_by_track_id(123)


def test_get_track_by_track_id_expected_return():
    """Test expected response body returned."""
    track_payload = {'track_name': 'My Track'}
    mock_response = MagicMock(status_code=200)
    mock_response.json = MagicMock(return_value=track_payload)

    (flexmock(request).should_receive('get').with_args(
        services.OWS_TRACK,
        '/track/123',
    ).and_return(mock_response))

    result = ows_track.get_track_by_track_id(123)

    assert result.status == 200
    assert result.message == track_payload


def test_get_track_by_track_id_error_returned():
    """Test error result when error."""
    mock_response = MagicMock(status_code=403)

    (flexmock(request).should_receive('get').with_args(
        services.OWS_TRACK,
        '/track/123',
    ).and_return(mock_response))

    result = ows_track.get_track_by_track_id(123)

    assert result.status == 403


def test_get_instant_grats_by_product_id_correct_call():
    """Test correct call made to ows-track."""
    product_id = 123
    mock_response = MagicMock(status_code=200)
    mock_response.json = MagicMock(return_value={'items': [{'tuid': '1'}]})

    (flexmock(request).should_receive('get').with_args(
        services.OWS_TRACK,
        '/product/{}/tracks/grats'.format(
            product_id)).and_return(mock_response))

    ows_track.get_instant_grats_by_product_id(product_id)


def test_get_instant_grats_by_product_id_expected_return():
    """Test expected response body returned."""
    product_id = 123
    track_payload = {'items': [{'tuid': '1'}]}
    mock_response = MagicMock(status_code=200)
    mock_response.json = MagicMock(return_value=track_payload)

    (flexmock(request).should_receive('get').with_args(
        services.OWS_TRACK,
        '/product/{}/tracks/grats'.format(
            product_id)).and_return(mock_response))

    result = ows_track.get_instant_grats_by_product_id(product_id)

    assert result.status == 200
    assert result.message == track_payload


def test_get_instant_grats_by_product_id_error_returned():
    """Test error result when error."""
    product_id = 123
    mock_response = MagicMock(status_code=403)

    (flexmock(request).should_receive('get').with_args(
        services.OWS_TRACK,
        '/product/{}/tracks/grats'.format(
            product_id)).and_return(mock_response))

    result = ows_track.get_instant_grats_by_product_id(product_id)
    assert result.status == 403


def test_post_change_genre_expected_return(orchard_user_id, test_request_context):
    """Test expected result when request returns success."""
    product_id = 123
    request_data = {
        'genre_id': 12,
        'subgenere_id': 324
    }
    mock_response = MagicMock(status_code=200)

    (flexmock(request).should_receive('post').with_args(
        services.OWS_TRACK,
        '/product/{}/tracks/change_genre'.format(product_id),
        json=request_data,
        headers={header.ORCHARD_USER_ID: orchard_user_id})
        .and_return(mock_response))

    with api.app.test_request_context():
        g.request_context = None
        result = ows_track.change_genre(product_id, request_data, orchard_user_id)
        assert result.status == 200


def test_post_change_genre_error_returned(orchard_user_id):
    """Test error result when error."""
    product_id = 123
    request_data = {
        'genre_id': 12,
        'subgenere_id': 324
    }
    mock_response = MagicMock(status_code=500)

    (flexmock(request).should_receive('post').with_args(
        services.OWS_TRACK,
        '/product/{}/tracks/change_genre'.format(product_id),
        json=request_data,
        headers={header.ORCHARD_USER_ID: orchard_user_id})
        .and_return(mock_response))

    with api.app.test_request_context():
        g.request_context = None
        result = ows_track.change_genre(product_id, request_data, orchard_user_id)
        assert result.status == 500


def test_post_change_genre_no_content_in_response(orchard_user_id):
    """Test error result when no content in response."""
    product_id = 123
    request_data = {
        'genre_id': 12,
        'subgenere_id': 324
    }
    mock_response = MagicMock(status_code=204)

    (flexmock(request).should_receive('post').with_args(
        services.OWS_TRACK,
        '/product/{}/tracks/change_genre'.format(product_id),
        json=request_data,
        headers={header.ORCHARD_USER_ID: orchard_user_id})
        .and_return(mock_response))

    with api.app.test_request_context():
        g.request_context = None
        result = ows_track.change_genre(product_id, request_data, orchard_user_id)
        assert result.status == 204


def test_delete_tracks_by_product_id(
        empty_ows_tracks_message, mocker, product_id):
    """Test expected message returned from tracks delete endpoint."""
    mock_validation_response = MagicMock(status_code=200)
    mocker.patch.object(request, 'delete', return_value=mock_validation_response)

    with api.app.test_request_context():
        g.validation_context = 'pre_submission'
        g.request_context = NonCallableMagicMock()

        result = ows_track.delete_tracks_by_product_id(product_id, '1,2,3')

    assert result.status == 200


def test_delete_tracks_by_product_id_failure(
        empty_ows_tracks_message, mocker, product_id):
    """Test error result when some failure."""
    mock_validation_response = MagicMock(status_code=400)
    mock_validation_response.json = MagicMock(
        return_value={'code': 'error', 'message': 'Some error'})
    mocker.patch.object(request, 'delete', return_value=mock_validation_response)

    with api.app.test_request_context():
        g.validation_context = 'pre_submission'
        g.request_context = NonCallableMagicMock()

        result = ows_track.delete_tracks_by_product_id(product_id, '1,2,3')

    assert result.status == 400


def test_get_tracks_by_product_id_correct_call(request_engine, test_request_context):
    """Test correct call made to ows-track."""
    product_id = 123

    request_engine[services.OWS_TRACK].add_spec(
        'GET', '/product/{}/tracks'.format(product_id), {'items': [{'tuid': '1'}]}
    )

    ows_track.get_tracks_by_product_id(product_id)


def test_get_tracks_by_product_id_expected_return(request_engine, test_request_context):
    """Test expected response returned."""
    product_id = 123
    track_payload = {'items': [{'tuid': '1'}]}

    request_engine[services.OWS_TRACK].add_spec(
        'GET', '/product/{}/tracks'.format(product_id), track_payload)

    result = ows_track.get_tracks_by_product_id(product_id)
    assert result.status == 200
    assert result.message == track_payload


def test_get_tracks_by_product_id_error_returned(request_engine, test_request_context):
    """Test error result when error."""
    product_id = 123

    request_engine[services.OWS_TRACK].add_spec(
        'GET', '/product/{}/tracks'.format(product_id),
        status=500
    )

    with pytest.raises(RequestError) as excinfo:
        ows_track.get_tracks_by_product_id(product_id)

    assert str(excinfo.value) == 'Error retrieving tracks from ows-track'
    assert excinfo.type == RequestError


def test_post_change_genre_with_profile_headers(orchard_user_id, test_request_context, valid_profile_headers):
    """Test expected result when request returns success."""
    product_id = 123
    request_data = {
        'genre_id': 12,
        'subgenere_id': 324
    }
    mock_response = MagicMock(status_code=200)

    (flexmock(request).should_receive('post').with_args(
        services.OWS_TRACK,
        '/product/{}/tracks/change_genre'.format(product_id),
        json=request_data,
        headers=valid_profile_headers)
        .and_return(mock_response))

    with api.app.test_request_context():
        g.request_context.identity_id = 'identity'
        result = ows_track.change_genre(product_id, request_data, orchard_user_id)
        assert result.status == 200