"""Functional test for update product."""
import json

from oto import response
import pytest

from ows_product_physical.constant import field
from ows_product_physical.models import persister


@pytest.mark.parametrize('manufacturing_obligation', [True, False])
def test_update_product_happy_path(
        client, db_release_id, valid_put_header, valid_put_product_data,
        setup_put_product, db_with_data,
        manufacturing_obligation):
    """Test that product update can update a sampling of fields."""
    setup_put_product({
        'manufacturing_obligation': manufacturing_obligation
    })

    valid_put_product_data.update(
        {field.ARTIST_ID: 1234})

    client_response = client.put(
        '/product/{}'.format(db_release_id),
        headers=valid_put_header,
        data=json.dumps(valid_put_product_data)
    )

    assert client_response.status_code == 200
    response_data = json.loads(client_response.data.decode('utf-8'))
    updated_data_fields = {k: response_data[k]
                           for k in valid_put_product_data.keys()}
    assert updated_data_fields == valid_put_product_data


def test_update_product_with_blank_upc_and_display_upc_enabled(
        client, valid_post_header, db_release_id, db_releases,
        ows_request_mocker, db_with_data, setup_put_product):
    """Test update product upc to blank."""
    setup_put_product({})

    client_response = client.put(
        '/product/{}'.format(db_release_id),
        headers=valid_post_header,
        data=json.dumps({'display_upc': None})
    )

    assert client_response.status_code == 200
    response_data = json.loads(client_response.data.decode('utf-8'))
    assert response_data['upc'] == db_releases[0]['upc']
    assert response_data['display_upc'] is None


def test_update_product_with_no_upc_and_display_upc_enabled(
        client, valid_post_header, db_release_id,
        ows_request_mocker, db_with_data, setup_put_product, db_releases):
    """Test update product upc to blank."""
    setup_put_product({'display_upc': True})

    client_response = client.put(
        '/product/{}'.format(db_release_id),
        headers=valid_post_header,
        data=json.dumps({'product_name': 'Hello'})
    )

    assert client_response.status_code == 200
    response_data = json.loads(client_response.data.decode('utf-8'))
    assert response_data['upc'] == db_releases[0]['upc']
    assert response_data['display_upc'] == db_releases[0]['display_upc']


@pytest.mark.parametrize(
    ('expected_display_upc', 'expected_upc', 'assign_display_upc'), [
        ('565685854679', 20000000000042, True),
        (None, 20000000000042, False)
    ])
def test_update_product_with_upc_assignment_happy_path(
        client, valid_post_header, db_release_id_without_display_upc,
        expected_display_upc, expected_upc, assign_display_upc, db_with_data,
        setup_put_product, db_releases, mocker):
    """Test update product upc to blank."""
    mocker.patch.object(
        persister,
        'get_provisioned_upc',
        return_value=response.Response(message=expected_display_upc)
    )
    setup_put_product({}, db_release_id_without_display_upc)

    client_response = client.put(
        '/product/{}'.format(db_release_id_without_display_upc),
        headers=valid_post_header,
        data=json.dumps({
            'product_name': 'Hello', 'assign_display_upc': assign_display_upc})
    )

    assert client_response.status_code == 200
    response_data = json.loads(client_response.data.decode('utf-8'))
    assert response_data['upc'] == expected_upc
    assert response_data['display_upc'] == expected_display_upc