"""Functional tests around release correction."""
import json
from unittest.mock import MagicMock

from flexmock import flexmock
from owsrequest import request

from product_workflow.constants import services
from tests.factories import release_approval_queue \
    as release_approval_queue_factory
from tests.factories import release_correction as release_correction_factory
from tests.factories import release_correction_detail as \
    release_correction_detail_factory
from tests.testutils import db


@db.test_schema
def test_get_last_release_correction_success(
        client,
        valid_headers,
        product_id):
    """Test result when getting the last release correction."""
    release_corrections = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(2, release_id=product_id)
    release_correction_details = release_correction_detail_factory \
        .ReleaseCorrectionDetailFactory.build_batch(2, release_correction_id=1)

    db.seed_models(release_correction_details)
    db.seed_models(release_corrections)
    result = client.get(
        '/product/{}/correction'.format(product_id),
        headers=valid_headers)

    response_json = json.loads(result.data.decode('utf-8'))
    expected_body = {
        'release_correction_id': 1,
        'release_id': product_id,
        'status': 'active',
        'items': [
            {
                'release_correction_detail_id': 0,
                'table_name': 'track',
                'field_name': 'featuring',
                'key_id': 5,
                'key_value': 'Something'
            },
            {
                'release_correction_detail_id': 1,
                'table_name': 'track',
                'field_name': 'featuring',
                'key_id': 5,
                'key_value': 'Something'
            }]
    }

    assert result.status_code == 200
    assert response_json == expected_body


@db.test_schema
def test_get_last_release_approval_not_found(
        client, valid_headers, product_id):
    """Test result when getting the last release_approval."""
    release_corrections = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(2)
    db.seed_models(release_corrections)
    result = client.get(
        '/product/{}/correction'.format(product_id),
        headers=valid_headers)

    assert result.status_code == 404


def test_get_last_release_correction_error(
        client, valid_headers, product_id):
    """Test result when release correction table does not exist.

    Internal Server Error
    """
    result = client.get(
        '/product/{}/correction'.format(product_id),
        headers=valid_headers)

    assert result.status_code == 500


@db.test_schema
def test_get_release_correction_success(
        client,
        valid_headers):
    """Test result when getting the a release correction."""
    release_corrections = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, release_id=123)
    release_correction_id = release_corrections[0].release_correction_id
    release_correction_details = release_correction_detail_factory \
        .ReleaseCorrectionDetailFactory \
        .build_batch(2, release_correction_id=release_correction_id)

    db.seed_models(release_correction_details)
    db.seed_models(release_corrections)
    result = client.get(
        '/correction/{}'.format(release_correction_id),
        headers=valid_headers)

    response_json = json.loads(result.data.decode('utf-8'))
    expected_body = {
        'release_correction_id': release_correction_id,
        'release_id': 123,
        'status': 'active',
        'items': [
            {
                'release_correction_detail_id': 2,
                'table_name': 'track',
                'field_name': 'featuring',
                'key_id': 5,
                'key_value': 'Something'
            },
            {
                'release_correction_detail_id': 3,
                'table_name': 'track',
                'field_name': 'featuring',
                'key_id': 5,
                'key_value': 'Something'
            }]
    }

    assert result.status_code == 200
    assert response_json == expected_body


@db.test_schema
def test_get_release_correction_not_found(
        client, valid_headers):
    """Test result when getting a release correction is not found."""
    result = client.get(
        '/correction/1',
        headers=valid_headers)

    assert result.status_code == 404


def test_get_release_correction_error(
        client, valid_headers):
    """Test result when release correction table does not exist.

    Internal Server Error
    """
    result = client.get(
        '/correction/2',
        headers=valid_headers)

    assert result.status_code == 500


@db.test_schema
def test_post_release_correction_success(
        client, release_correction_payload, valid_headers, product_id):
    """Test result when creating a new release_correction."""
    result = client.post(
        '/product/{}/correction'.format(product_id),
        headers=valid_headers, data=json.dumps(release_correction_payload))

    response_json = json.loads(result.data.decode('utf-8'))
    expected_body = {
        'release_correction_id': 1,
        'release_id': product_id,
        'status': 'active',
        'items': []
    }

    assert result.status_code == 201
    assert response_json == expected_body


def test_post_release_correction_error(
        client, release_correction_payload, valid_headers, product_id):
    """Test result when creating a new release_correction and failure."""
    result = client.post(
        '/product/{}/correction'.format(product_id),
        headers=valid_headers, data=json.dumps(release_correction_payload))

    assert result.status_code == 500


@db.test_schema
def test_put_release_correction_success(
        client, release_correction_update_payload, valid_headers, product_id):
    """Test result when updating release_correction."""
    release_correction = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, release_id=product_id)
    db.seed_models(release_correction)

    result = client.put(
        '/correction/{}'.format(release_correction[0].release_correction_id),
        headers=valid_headers,
        data=json.dumps(release_correction_update_payload))

    response_json = json.loads(result.data.decode('utf-8'))
    expected_body = {
        'release_correction_id': release_correction[0].release_correction_id,
        'release_id': product_id,
        'status': 'submitted',
        'items': []
    }

    assert result.status_code == 200
    assert response_json == expected_body


def test_put_release_correction_error(
        client, release_correction_update_payload, valid_headers, product_id):
    """Test result when creating a new release_correction and failure."""
    result = client.put(
        '/correction/{}'.format(1),
        headers=valid_headers,
        data=json.dumps(release_correction_update_payload))

    assert result.status_code == 500


@db.test_schema
def test_delete_release_correction_status_active(
        client, valid_headers):
    """Test result when deleting a release_correction."""
    release_corrections = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, status='active')
    db.seed_models(release_corrections)

    result = client.delete(
        '/correction/{}'.format(release_corrections[0].release_correction_id),
        headers=valid_headers
    )

    response_json = json.loads(result.data.decode('utf-8'))
    expected_body = {
        'message': 'release correction deleted',
    }

    assert result.status_code == 202
    assert response_json == expected_body


@db.test_schema
def test_delete_release_correction_status_active_with_rejected_approval(
        client, valid_headers):
    """Test result when deleting a release_correction."""
    release_correction = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, status='active')[0]
    release_approval_queue = \
        release_approval_queue_factory.ReleaseApprovalQueueFactory.build_batch(
            1,
            status='rejected',
            release_correction_id=release_correction.release_correction_id)[0]
    db.seed_models([release_correction, release_approval_queue])

    result = client.delete(
        '/correction/{}'.format(release_correction.release_correction_id),
        headers=valid_headers
    )

    response_json = json.loads(result.data.decode('utf-8'))
    expected_body = {
        'message': 'release correction deleted',
    }

    assert result.status_code == 202
    assert response_json == expected_body


@db.test_schema
def test_delete_release_correction_status_not_active(client, valid_headers):
    """Test when deleting a release_correction without an active status."""
    release_corrections = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, status='submitted')
    db.seed_models(release_corrections)

    result = client.delete(
        '/correction/{}'.format(release_corrections[0].release_correction_id),
        headers=valid_headers
    )

    response_json = json.loads(result.data.decode('utf-8'))
    expected_body = {
        'code': 'bad_request',
        'message': "Can't delete a release correction with a "
                   'submitted status',
    }

    assert result.status_code == 400
    assert response_json == expected_body


@db.test_schema
def test_delete_release_correction_status_active_with_checked_in_approval(
        client, valid_headers):
    """Test result when deleting a release_correction."""
    release_correction = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, status='active')[0]
    release_approval_queue = \
        release_approval_queue_factory.ReleaseApprovalQueueFactory.build_batch(
            1,
            status='checked_in',
            release_correction_id=release_correction.release_correction_id)[0]
    db.seed_models([release_correction, release_approval_queue])

    result = client.delete(
        '/correction/{}'.format(release_correction.release_correction_id),
        headers=valid_headers
    )

    response_json = json.loads(result.data.decode('utf-8'))
    expected_body = {
        'code': 'bad_request',
        'message': "Can't delete a release correction with a non rejected"
                   + ' approval'
    }

    assert result.status_code == 400
    assert response_json == expected_body


@db.test_schema
def test_delete_release_correction_not_found(
        client, valid_headers):
    """Test when deleting a release correction that doesnt exist."""
    release_corrections = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, status='active')
    db.seed_models(release_corrections)
    result = client.delete(
        '/correction/{}'.format(333),
        headers=valid_headers)

    assert result.status_code == 404


def test_delete_release_correction_error(
        client, valid_headers):
    """Test when deleting a release correction with a database error."""
    result = client.delete(
        '/correction/{}'.format(333),
        headers=valid_headers)

    assert result.status_code == 500


@db.test_schema
def test_approve_release_success(
        client, product_id, track_id, get_ows_lyrics_message):
    """Test approve release to apply correction track lyrics values."""
    release_corrections = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, release_id=product_id, status='submitted')
    release_correction_id = release_corrections[0].release_correction_id
    release_correction_details = release_correction_detail_factory \
        .ReleaseCorrectionDetailFactory.build_batch(
            2,
            release_correction_id=release_correction_id,
            table_name='track',
            field_name='lyrics',
            key_id=track_id,
            key_value='Something')

    db.seed_models(release_corrections + release_correction_details)

    mock_response = MagicMock(status_code=200)
    mock_response.json = MagicMock(return_value=get_ows_lyrics_message)

    data = {'lyrics': 'Something'}

    (flexmock(request).should_receive(
        'put').with_args(
        services.OWS_LYRICS,
        '/tracks/{}/lyrics'.format(track_id),
        json=data).and_return(
        mock_response))

    approve_release_response = client.post(
        '/product/{}/approve'.format(product_id))

    assert approve_release_response.status_code == 200


@db.test_schema
def test_approve_release_failure(
        client, product_id, track_id, generic_error_payload):
    """Test approve release when any error occurred."""
    release_corrections = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, release_id=product_id, status='submitted')
    release_correction_id = release_corrections[0].release_correction_id
    release_correction_details = release_correction_detail_factory \
        .ReleaseCorrectionDetailFactory.build_batch(
            2,
            release_correction_id=release_correction_id,
            table_name='track',
            field_name='lyrics',
            key_id=track_id,
            key_value='Something')

    db.seed_models(release_corrections + release_correction_details)

    mock_response = MagicMock(status_code=400)
    mock_response.json = MagicMock(
        return_value=generic_error_payload)

    data = {'lyrics': 'Something'}

    (flexmock(request).should_receive(
        'put').with_args(
        services.OWS_LYRICS,
        '/tracks/{}/lyrics'.format(track_id),
        json=data).and_return(
        mock_response))

    approve_release_response = client.post(
        '/product/{}/approve'.format(product_id))

    assert approve_release_response.status_code == 400


@db.test_schema
def test_approve_release_with_server_error(
        client, product_id, track_id, generic_error_payload):
    """Test approve release when any error occurred."""
    release_corrections = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, release_id=product_id, status='submitted')
    release_correction_id = release_corrections[0].release_correction_id
    release_correction_details = release_correction_detail_factory \
        .ReleaseCorrectionDetailFactory.build_batch(
            2,
            release_correction_id=release_correction_id,
            table_name='track',
            field_name='lyrics',
            key_id=track_id,
            key_value='Something')

    db.seed_models(release_corrections + release_correction_details)

    mock_response = MagicMock(status_code=500)
    mock_response.json = MagicMock(
        return_value=generic_error_payload)

    data = {'lyrics': 'Something'}

    (flexmock(request).should_receive(
        'put').with_args(
        services.OWS_LYRICS,
        '/tracks/{}/lyrics',
        json=data).and_return(
        mock_response))

    approve_release_response = client.post(
        '/product/{}/approve'.format(product_id))

    assert approve_release_response.status_code == 500


@db.test_schema
def test_get_track_lyrics_for_product_success(
        client, product_id, get_tracks_by_product_id_response,
        get_lyrics_by_track_ids_response, get_lyrics_by_product_id_response):
    """Test result when getting the track lyrics for product."""
    correction = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, status='submitted', release_id=product_id)[0]

    correction_id = correction.release_correction_id

    factory = release_correction_detail_factory.ReleaseCorrectionDetailFactory
    correction_detail = factory.build_batch(
        1,
        release_correction_id=correction_id,
        table_name='track',
        field_name='lyrics',
        key_id=1,
        key_value='lyrics text',
        last_updated_by=1,
        last_updated_type='vendor')[0]

    db.seed_models(correction)
    db.seed_models(correction_detail)

    mock_response = MagicMock(status_code=200)
    mock_response.json = MagicMock(
        return_value=get_tracks_by_product_id_response)

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

    mock_response = MagicMock(status_code=200)
    mock_response.json = MagicMock(
        return_value=get_lyrics_by_track_ids_response)

    (flexmock(request).should_receive(
        'get').with_args(
        services.OWS_LYRICS,
        '/tracks/lyrics?tuids=2,3')
        .and_return(mock_response))

    result = client.get(
        '/product/{}/lyrics'.format(product_id))

    response_json = json.loads(result.data.decode('utf-8'))
    expected_body = get_lyrics_by_product_id_response

    assert result.status_code == 200
    assert response_json == expected_body


def test_get_track_lyrics_for_product_error(client, product_id):
    """Test result when release correction table does not exist.

    Internal Server Error
    """
    result = client.get(
        '/product/{}/lyrics'.format(product_id))
    response_json = json.loads(result.data.decode('utf-8'))

    expected_body = {
        'code': 'internal_error',
        'message': None
    }

    assert result.status_code == 500
    assert response_json == expected_body


@db.test_schema
def test_get_track_lyrics_for_product_ows_track_error(client, product_id):
    """Test result when ows-track fails."""
    correction = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, status='submitted', release_id=product_id)[0]
    db.seed_models(correction)

    mock_response = MagicMock(status_code=500)
    mock_response.json = MagicMock(
        return_value=None)

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

    result = client.get(
        '/product/{}/lyrics'.format(product_id))

    response_json = json.loads(result.data.decode('utf-8'))
    expected_body = {
        'code': 'internal_error',
        'message': 'Error while fetching tracks by product id'
    }

    assert result.status_code == 500
    assert response_json == expected_body


@db.test_schema
def test_get_track_lyrics_for_product_ows_lyrics_error(
        client, product_id, get_tracks_by_product_id_response):
    """Test result when ows-lyrics fails."""
    correction = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, status='submitted', release_id=product_id)[0]
    db.seed_models(correction)

    mock_response = MagicMock(status_code=200)
    mock_response.json = MagicMock(
        return_value=get_tracks_by_product_id_response)

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

    mock_response = MagicMock(status_code=500)
    mock_response.json = MagicMock(
        return_value=None)

    (flexmock(request).should_receive(
        'get').with_args(
        services.OWS_LYRICS,
        '/tracks/lyrics?tuids=1,2,3')
        .and_return(mock_response))

    result = client.get(
        '/product/{}/lyrics'.format(product_id))

    response_json = json.loads(result.data.decode('utf-8'))
    expected_body = {
        'code': 'internal_error',
        'message': 'Error while fetching lyrics by track ids'
    }

    assert result.status_code == 500
    assert response_json == expected_body


@db.test_schema
def test_get_track_lyrics_for_product_not_found(
        client, product_id,
        get_tracks_by_product_id_no_tracks_response,
        get_lyrics_by_product_id_not_found_response):
    """Test result when there are no tracks and no lyrics data for product."""
    correction = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, status='submitted', release_id=product_id)[0]
    db.seed_models(correction)

    mock_response = MagicMock(status_code=200)
    mock_response.json = MagicMock(
        return_value=get_tracks_by_product_id_no_tracks_response)

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

    result = client.get(
        '/product/{}/lyrics'.format(product_id))

    response_json = json.loads(result.data.decode('utf-8'))

    assert result.status_code == 404
    assert response_json == get_lyrics_by_product_id_not_found_response


@db.test_schema
def test_get_lyrics_for_track_correction_success(
        client, product_id, track_id, get_lyrics_by_track_id_response):
    """Test result when getting the track lyrics for track from correction."""
    correction = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, status='submitted', release_id=product_id)[0]

    correction_id = correction.release_correction_id

    factory = release_correction_detail_factory.ReleaseCorrectionDetailFactory
    correction_detail = factory.build_batch(
        1,
        release_correction_id=correction_id,
        table_name='track',
        field_name='lyrics',
        key_id=track_id,
        key_value='Lyrics Text',
        last_updated_by=1,
        last_updated_type='vendor')[0]

    db.seed_models(correction)
    db.seed_models(correction_detail)

    result = client.get(
        '/product/{product_id}/lyrics/{track_id}'.format(
            product_id=product_id, track_id=track_id))

    response_json = json.loads(result.data.decode('utf-8'))
    expected_body = get_lyrics_by_track_id_response

    assert result.status_code == 200
    assert response_json == expected_body


@db.test_schema
def test_get_lyrics_for_track_ows_lyrics_success(
        client, product_id, track_id, get_lyrics_by_track_id_response,
        get_lyrics_by_track_ids_response_for_single_track):
    """Test result when getting the track lyrics for track from correction."""
    correction = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, status='submitted', release_id=product_id)[0]
    db.seed_models(correction)

    mock_response = MagicMock(status_code=200)
    mock_response.json = MagicMock(
        return_value=get_lyrics_by_track_ids_response_for_single_track)

    (flexmock(request).should_receive(
        'get').with_args(
        services.OWS_LYRICS,
        '/tracks/lyrics?tuids=' + str(track_id))
        .and_return(mock_response))

    result = client.get(
        '/product/{product_id}/lyrics/{track_id}'.format(
            product_id=product_id, track_id=track_id))

    response_json = json.loads(result.data.decode('utf-8'))
    expected_body = get_lyrics_by_track_id_response

    assert result.status_code == 200
    assert response_json == expected_body


def test_get_lyrics_for_track_error(client, product_id, track_id):
    """Test result when release correction table does not exist.

    Internal Server Error
    """
    result = client.get(
        '/product/{product_id}/lyrics/{track_id}'.format(
            product_id=product_id, track_id=track_id))
    response_json = json.loads(result.data.decode('utf-8'))

    expected_body = {
        'code': 'internal_error',
        'message': None
    }

    assert result.status_code == 500
    assert response_json == expected_body


@db.test_schema
def test_get_lyrics_for_track_ows_lyrics_error(client, product_id, track_id):
    """Test result when ows-lyrics fails."""
    correction = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, status='submitted', release_id=product_id)[0]
    db.seed_models(correction)

    mock_response = MagicMock(status_code=500)
    mock_response.json = MagicMock(
        return_value=None)

    (flexmock(request).should_receive(
        'get').with_args(
        services.OWS_LYRICS,
        '/tracks/lyrics?tuids=' + str(track_id))
        .and_return(mock_response))

    result = client.get(
        '/product/{product_id}/lyrics/{track_id}'.format(
            product_id=product_id, track_id=track_id))
    response_json = json.loads(result.data.decode('utf-8'))
    expected_body = {
        'code': 'internal_error',
        'message': 'Error while fetching lyrics by track ids'
    }

    assert result.status_code == 500
    assert response_json == expected_body


@db.test_schema
def test_get_lyrics_for_track_not_found(
        client, product_id, track_id, generic_error_payload,
        get_lyrics_by_track_id_not_found_response):
    """Test result when there are no tracks and no lyrics data for product."""
    correction = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, status='submitted', release_id=product_id)[0]
    db.seed_models(correction)

    mock_response = MagicMock(status_code=404)
    mock_response.json = MagicMock(
        return_value=generic_error_payload)

    (flexmock(request).should_receive(
        'get').with_args(
        services.OWS_LYRICS,
        '/tracks/lyrics?tuids=' + str(track_id))
        .and_return(mock_response))

    result = client.get(
        '/product/{product_id}/lyrics/{track_id}'.format(
            product_id=product_id, track_id=track_id))

    response_json = json.loads(result.data.decode('utf-8'))

    assert result.status_code == 404
    assert response_json == get_lyrics_by_track_id_not_found_response