"""Integration API tests for ows-contracts."""

import pytest

from tests.integration.conftest import (
    find_product_split_by_upc,
    find_track_split_by_isrc,
    generate_product_split,
    generate_track_split,
    mechadmin_workstation_user,
    ows_contracts_api_client,
    regular_workstation_user,
    workstation_api_client,
)


@pytest.mark.parametrize(
    'user',
    [
        {'user': regular_workstation_user(), 'mech_admin': False},
        {'user': mechadmin_workstation_user(), 'mech_admin': True},
    ],
)
def test_contracts(user):
    """Test if contracts correctly determines user/vendor's mech-admin status."""
    result = workstation_api_client(user['user']).mechadmin_for_account()
    assert result.status_code == 200, 'Result of call was {}, expected 200.'.format(
        result.status_code
    )
    json_response = result.json()
    if user['mech_admin']:
        assert json_response['mechadmin_digital'], (
            'Expected user with vendor ID of {} to be identified as digital mech admin, but got {}'.format(
                user['user']['vendor_id'], json_response
            )
        )
        assert json_response['mechadmin_physical'], (
            'Expected user with vendor ID of {} to be identified as physical mech admin, but got {}'.format(
                user['user']['vendor_id'], json_response
            )
        )
    else:
        assert not json_response['mechadmin_digital'], (
            'Expected user with vendor ID of {} to NOT be identified as digital mech admin, but got {}'.format(
                user['user']['vendor_id'], json_response
            )
        )
        assert not json_response['mechadmin_physical'], (
            'Expected user with vendor ID of {} to NOT be identified as physical mech admin, but got {}'.format(
                user['user']['vendor_id'], json_response
            )
        )


def test_post_get_product_split(
    cleanup_product_splits, vendor_id, product_split_data, user_headers
):
    """Test ows-contracts POST and GET /product-split logic."""
    upc = product_split_data['upc']
    ows_contracts_client = ows_contracts_api_client(user_headers)

    split = generate_product_split(
        upc,
        0.7,
        product_split_data['oa_user_id'],
        product_split_data['vend_contract_id'],
        product_split_data['release_name'],
    )
    result_post = ows_contracts_client.post_product_splits(vendor_id, split)
    assert result_post.status_code == 200, (
        'Result of call was {}, expected 200.'.format(result_post.status_code)
    )
    result_get = ows_contracts_client.get_product_split(vendor_id)
    assert result_get.status_code == 200, 'Result of call was {}, expected 200.'.format(
        result_get.status_code
    )
    product_splits = result_get.json()
    assert find_product_split_by_upc(product_splits['items'], upc) is not None, (
        'Split was not found by UPC within GET /splits response'
    )
    assert (
        find_product_split_by_upc(split, upc)['product_split_rate']
        == find_product_split_by_upc(product_splits['items'], upc)['product_split']
    ), 'The split POSTed does not match the one is returned by GET endpoint'


def test_post_get_track_split(
    cleanup_track_splits, vendor_id, track_split_data, user_headers
):
    """Test ows-contracts POST and GET /track-split logic."""
    isrc = track_split_data['isrc']
    ows_contracts_client = ows_contracts_api_client(user_headers)

    split = generate_track_split(
        isrc,
        0.7,
        track_split_data['track_unique_id'],
        track_split_data['oa_user_id'],
        track_split_data['vend_contract_id'],
    )
    result_post = ows_contracts_client.post_track_splits(vendor_id, split)
    assert result_post.status_code == 200, (
        'Result of call was {}, expected 200.'.format(result_post.status_code)
    )
    result_get = ows_contracts_client.get_track_split(vendor_id)
    assert result_get.status_code == 200, 'Result of call was {}, expected 200.'.format(
        result_get.status_code
    )
    track_splits = result_get.json()
    assert find_track_split_by_isrc(track_splits['items'], isrc) is not None, (
        'Split was not found by UPC within GET /splits response'
    )
    assert (
        find_track_split_by_isrc(split, isrc)['track_split']
        == find_track_split_by_isrc(track_splits['items'], isrc)['track_split']
    ), 'The split POSTed does not match the one is returned by GET endpoint'


def test_put_product_split(
    cleanup_product_splits, vendor_id, product_split_data, user_headers
):
    """Test ows-contracts PUT /product-split logic."""
    upc = product_split_data['upc']
    ows_contracts_client = ows_contracts_api_client(user_headers)

    post_split = generate_product_split(
        upc,
        0.7,
        product_split_data['oa_user_id'],
        product_split_data['vend_contract_id'],
        product_split_data['release_name'],
    )
    result_post = ows_contracts_client.post_product_splits(vendor_id, post_split)
    assert result_post.status_code == 200, (
        'Result of call was {}, expected 200.'.format(result_post.status_code)
    )
    result_get = ows_contracts_client.get_product_split(vendor_id)
    assert result_get.status_code == 200, 'Result of call was {}, expected 200.'.format(
        result_get.status_code
    )
    product_splits = result_get.json()
    assert find_product_split_by_upc(product_splits['items'], upc) is not None, (
        'Split was not found by UPC within GET /splits response'
    )
    assert (
        find_product_split_by_upc(post_split, upc)['product_split_rate']
        == find_product_split_by_upc(product_splits['items'], upc)['product_split']
    ), 'The split POSTed does not match the one is returned by GET endpoint'

    put_split = generate_product_split(
        upc,
        0.1,
        product_split_data['oa_user_id'],
        product_split_data['vend_contract_id'],
        product_split_data['release_name'],
    )
    result_put = ows_contracts_client.put_product_splits(vendor_id, put_split)
    assert result_put.status_code == 200, 'Result of call was {}, expected 200.'.format(
        result_put.status_code
    )
    result_get = ows_contracts_client.get_product_split(vendor_id)
    product_splits = result_get.json()
    assert (
        find_product_split_by_upc(put_split, upc)['product_split_rate']
        == find_product_split_by_upc(product_splits['items'], upc)['product_split']
    ), 'The split used for PUT does not match the one is returned by GET endpoint'


def test_put_track_split(
    cleanup_track_splits, vendor_id, track_split_data, user_headers
):
    """Test ows-contracts PUT /track-split logic."""
    isrc = track_split_data['isrc']
    ows_contracts_client = ows_contracts_api_client(user_headers)
    post_split = generate_track_split(
        isrc,
        0.7,
        track_split_data['track_unique_id'],
        track_split_data['oa_user_id'],
        track_split_data['vend_contract_id'],
    )
    result_post = ows_contracts_client.post_track_splits(vendor_id, post_split)
    assert result_post.status_code == 200, (
        'Result of call was {}, expected 200.'.format(result_post.status_code)
    )
    result_get = ows_contracts_client.get_track_split(vendor_id)
    assert result_get.status_code == 200, 'Result of call was {}, expected 200.'.format(
        result_get.status_code
    )
    track_splits = result_get.json()
    assert find_track_split_by_isrc(track_splits['items'], isrc) is not None, (
        'Split was not found by UPC within GET /splits response'
    )
    assert (
        find_track_split_by_isrc(post_split, isrc)['track_split']
        == find_track_split_by_isrc(track_splits['items'], isrc)['track_split']
    ), 'The split POSTed does not match the one is returned by GET endpoint'

    put_split = generate_track_split(
        isrc,
        0.1,
        track_split_data['track_unique_id'],
        track_split_data['oa_user_id'],
        track_split_data['vend_contract_id'],
    )
    # extra field is added for the PUT call body, containing previous value
    put_split[0].update({'old_track_split': post_split[0]['track_split']})
    result_put = ows_contracts_client.put_track_splits(vendor_id, put_split)
    assert result_put.status_code == 200, 'Result of call was {}, expected 200.'.format(
        result_put.status_code
    )
    result_get = ows_contracts_client.get_track_split(vendor_id)
    track_splits = result_get.json()
    assert (
        find_track_split_by_isrc(put_split, isrc)['track_split']
        == find_track_split_by_isrc(track_splits['items'], isrc)['track_split']
    ), 'The split used for PUT does not match the one is returned by GET endpoint'


def test_delete_product_split(
    cleanup_product_splits, vendor_id, product_split_data, user_headers
):
    """Test ows-contracts DELETE /split logic."""
    upc = product_split_data['upc']
    ows_contracts_client = ows_contracts_api_client(user_headers)
    split = generate_product_split(
        upc,
        0.7,
        product_split_data['oa_user_id'],
        product_split_data['vend_contract_id'],
        product_split_data['release_name'],
    )
    result_post = ows_contracts_client.post_product_splits(vendor_id, split)
    assert result_post.status_code == 200, (
        'Result of call was {}, expected 200.'.format(result_post.status_code)
    )
    result_get = ows_contracts_client.get_product_split(vendor_id)
    assert result_get.status_code == 200, 'Result of call was {}, expected 200.'.format(
        result_get.status_code
    )
    product_splits = result_get.json()
    assert find_product_split_by_upc(product_splits['items'], upc) is not None, (
        'Split was not found by UPC within GET /splits response'
    )
    assert (
        find_product_split_by_upc(split, upc)['product_split_rate']
        == find_product_split_by_upc(product_splits['items'], upc)['product_split']
    ), 'The split POSTed does not match the one is returned by GET endpoint'

    result_delete = ows_contracts_client.delete_product_splits(
        upc,
        {
            'vend_contract_id': product_split_data['vend_contract_id'],
            'oa_user_id': product_split_data['oa_user_id'],
            'vendor_id': vendor_id,
        },
    )
    assert result_delete.status_code == 200, (
        'Result of call was {}, expected 200.'.format(result_delete.status_code)
    )
    result_get = ows_contracts_client.get_product_split(vendor_id)
    product_splits = result_get.json()
    assert find_product_split_by_upc(product_splits['items'], upc) is None, (
        'Split was not deleted.'
    )


def test_delete_track_split(
    cleanup_track_splits, vendor_id, track_split_data, user_headers
):
    """Test ows-contracts DELETE /split logic."""
    isrc = track_split_data['isrc']
    ows_contracts_client = ows_contracts_api_client(user_headers)
    split = generate_track_split(
        isrc,
        0.7,
        track_split_data['track_unique_id'],
        track_split_data['oa_user_id'],
        track_split_data['vend_contract_id'],
    )
    result_post = ows_contracts_client.post_track_splits(vendor_id, split)
    assert result_post.status_code == 200, (
        'Result of call was {}, expected 200.'.format(result_post.status_code)
    )
    result_get = ows_contracts_client.get_track_split(vendor_id)
    assert result_get.status_code == 200, 'Result of call was {}, expected 200.'.format(
        result_get.status_code
    )
    track_splits = result_get.json()
    assert find_track_split_by_isrc(track_splits['items'], isrc) is not None, (
        'Split was not found by UPC within GET /splits response'
    )
    assert (
        find_track_split_by_isrc(split, isrc)['track_split']
        == find_track_split_by_isrc(track_splits['items'], isrc)['track_split']
    ), 'The split POSTed does not match the one is returned by GET endpoint'

    result_delete = ows_contracts_client.delete_track_splits(
        vendor_id,
        {
            'isrc': isrc,
            'vend_contract_id': track_split_data['vend_contract_id'],
            'oa_user_id': track_split_data['oa_user_id'],
        },
    )
    assert result_delete.status_code == 200, (
        'Result of call was {}, expected 200.'.format(result_delete.status_code)
    )
    result_get = ows_contracts_client.get_track_split(vendor_id)
    track_splits = result_get.json()
    assert find_track_split_by_isrc(track_splits['items'], isrc) is None, (
        'Split was not deleted.'
    )


def test_product_splits_unauthorized(
    cleanup_product_splits, vendor_id, product_split_data, unauthorized_user_headers
):
    """Test ows-contracts product_splits logic."""
    upc = product_split_data['upc']
    ows_contracts_client = ows_contracts_api_client(unauthorized_user_headers)
    post_split = generate_product_split(
        upc,
        0.7,
        product_split_data['oa_user_id'],
        product_split_data['vend_contract_id'],
        product_split_data['release_name'],
    )
    put_split = generate_product_split(
        upc,
        0.1,
        product_split_data['oa_user_id'],
        product_split_data['vend_contract_id'],
        product_split_data['release_name'],
    )

    result_post = ows_contracts_client.post_product_splits(vendor_id, post_split)
    assert result_post.status_code == 403, (
        'Result of call was {}, expected 403.'.format(result_post.status_code)
    )
    result_get = ows_contracts_client.get_product_split(vendor_id)
    assert result_get.status_code == 403, 'Result of call was {}, expected 403.'.format(
        result_get.status_code
    )
    result_put = ows_contracts_client.put_product_splits(vendor_id, put_split)
    assert result_put.status_code == 403, 'Result of call was {}, expected 403.'.format(
        result_put.status_code
    )

    # waiting for implementation
    # result_delete = ows_contracts_client.delete_product_splits(upc)
    # assert result_delete.status_code == 403, 'Result of call was {}, expected 403.'.format(result_delete.status_code)


def test_track_splits_unauthorized(
    cleanup_track_splits, vendor_id, track_split_data, unauthorized_user_headers
):
    """Test ows-contracts track_splits logic."""
    isrc = track_split_data['isrc']
    ows_contracts_client = ows_contracts_api_client(unauthorized_user_headers)
    split = generate_track_split(
        isrc,
        0.7,
        track_split_data['track_unique_id'],
        track_split_data['oa_user_id'],
        track_split_data['vend_contract_id'],
    )

    result_post = ows_contracts_client.post_track_splits(vendor_id, split)
    assert result_post.status_code == 403, (
        'Result of call was {}, expected 403.'.format(result_post.status_code)
    )
    result_get = ows_contracts_client.get_track_split(vendor_id)
    assert result_get.status_code == 403, 'Result of call was {}, expected 403.'.format(
        result_get.status_code
    )
    result_put = ows_contracts_client.put_track_splits(vendor_id, split)
    assert result_put.status_code == 403, 'Result of call was {}, expected 403.'.format(
        result_put.status_code
    )


def test_post_get_product_territory_split(
    cleanup_product_territory_splits,
    vendor_id,
    territory_product_split_data,
    user_headers,
):
    """Test ows-contracts POST and GET /product_territory_split logic."""
    ows_contracts_client = ows_contracts_api_client(user_headers)
    result_post = ows_contracts_client.post_product_territory_split(
        vendor_id, territory_product_split_data
    )
    assert result_post.status_code == 200
    result_get = ows_contracts_client.get_product_territory_split(vendor_id)
    assert result_get.status_code == 200
    assert (
        result_get.json()['items'][0]['upc'] == territory_product_split_data[0]['upc']
    )
    assert (
        result_get.json()['items'][0]['product_territory_split']
        == territory_product_split_data[0]['split_rate']
    )
    assert result_get.json()['items'][0]['vendor_id'] == int(vendor_id)
    assert (
        result_get.json()['items'][0]['country_details']['id']
        == territory_product_split_data[0]['country_id']
    )
    assert 'items' in result_get.json()
    assert 'pagination' in result_get.json()


def test_put_product_territory_split(
    cleanup_product_territory_splits,
    vendor_id,
    territory_product_split_data,
    user_headers,
):
    """Test ows-contracts PUT /product_territory_split logic."""
    ows_contracts_client = ows_contracts_api_client(user_headers)
    result_post = ows_contracts_client.post_product_territory_split(
        vendor_id, territory_product_split_data
    )
    assert result_post.status_code == 200
    result_get = ows_contracts_client.get_product_territory_split(vendor_id)
    assert result_get.status_code == 200
    assert (
        result_get.json()['items'][0]['product_territory_split']
        == territory_product_split_data[0]['split_rate']
    )
    put_territory_split_body = territory_product_split_data
    old_split_value = territory_product_split_data[0]['split_rate']
    new_split_value = 0.42
    put_territory_split_body[0].update({'old_split_rate': old_split_value})
    put_territory_split_body[0].update({'split_rate': new_split_value})
    result_put = ows_contracts_client.put_product_territory_split(
        vendor_id, put_territory_split_body
    )
    assert result_put.status_code == 200
    result_get = ows_contracts_client.get_product_territory_split(vendor_id)
    assert result_get.status_code == 200
    assert result_get.json()['items'][0]['product_territory_split'] == new_split_value


def test_delete_product_territory_split(
    cleanup_product_territory_splits,
    vendor_id,
    territory_product_split_data,
    user_headers,
):
    """Test ows-contracts DELETE /product_territory_split logic."""
    ows_contracts_client = ows_contracts_api_client(user_headers)
    result_post = ows_contracts_client.post_product_territory_split(
        vendor_id, territory_product_split_data
    )
    assert result_post.status_code == 200
    result_get = ows_contracts_client.get_product_territory_split(vendor_id)
    assert result_get.status_code == 200
    assert len(result_get.json()['items']) > 0
    assert (
        result_get.json()['items'][0]['upc'] == territory_product_split_data[0]['upc']
    )
    body_to_delete = territory_product_split_data[0]
    del body_to_delete['split_rate']
    del body_to_delete['upc']
    result_delete = ows_contracts_client.delete_product_territory_split(
        result_get.json()['items'][0]['upc'], body_to_delete
    )
    assert result_delete.status_code == 200
    result_get = ows_contracts_client.get_product_territory_split(vendor_id)
    assert result_get.status_code == 200
    assert len(result_get.json()['items']) == 0


def test_product_territory_split_unauthorized(
    vendor_id, territory_product_split_data, unauthorized_user_headers
):
    """Test product_territory_splits unauthorized logic."""
    ows_contracts_client = ows_contracts_api_client(unauthorized_user_headers)
    result_post = ows_contracts_client.post_product_territory_split(
        vendor_id, territory_product_split_data
    )
    assert result_post.status_code == 403
    put_territory_split_body = territory_product_split_data
    old_split_value = territory_product_split_data[0]['split_rate']
    new_split_value = 0.42
    put_territory_split_body[0].update({'old_split_rate': old_split_value})
    put_territory_split_body[0].update({'split_rate': new_split_value})
    result_put = ows_contracts_client.put_product_territory_split(
        vendor_id, put_territory_split_body
    )
    assert result_put.status_code == 403
    result_get = ows_contracts_client.get_product_territory_split(vendor_id)
    assert result_get.status_code == 403