"""Functional tests for bulk creating tracks.

Test endpoint:
    POST /product/<int:product_id>/tracks
"""

import json
from unittest.mock import MagicMock

from oto import status as response_code

from tests.testutils import db
from tests.testutils import mocks


def _do_track_bulk_create_request(
        client, mocker, client_headers, track_max_tuid,
        track_bulk_create_data, track_bulk_create_response):
    """Make create bulk track request."""
    mocks.head_response(mocker)

    first_track = track_bulk_create_response['items'][0]
    product_id = first_track['product_id']
    upc = first_track['upc']
    message = {'upc': upc, 'vendor_id': 100, 'product_id': product_id}
    get_response = MagicMock(status=200, message=message)

    mocker.patch('backend.models.ows_product._get_from_ows_product_service',
                 return_value=get_response)

    res = client.post(
        'product/{}/tracks'.format(product_id), headers=client_headers,
        data=json.dumps(track_bulk_create_data))

    return res


@db.test_schema
def test_bulk_create_track_new_product(
        client, mocker, client_headers, track_max_tuid,
        track_bulk_create_data, track_bulk_create_new_prod_logic_response):
    """Test create bulk track is successful with new product."""
    res = _do_track_bulk_create_request(
        client, mocker, client_headers, track_max_tuid,
        track_bulk_create_data, track_bulk_create_new_prod_logic_response)
    res_body = json.loads(res.data.decode())

    assert res.status_code == response_code.CREATED
    assert res_body == track_bulk_create_new_prod_logic_response


@db.test_schema
def test_bulk_create_track_existing_product(
        client, mocker, client_headers, track_max_tuid, track_bulk_create_data,
        track_bulk_create_existing_prod_logic_response):
    """Test create bulk track is successful with existing product."""
    res = _do_track_bulk_create_request(
        client, mocker, client_headers, track_max_tuid,
        track_bulk_create_data, track_bulk_create_existing_prod_logic_response)
    res_body = json.loads(res.data.decode())

    assert res.status_code == response_code.CREATED
    assert res_body == track_bulk_create_existing_prod_logic_response


@db.test_schema_no_seed
def test_bulk_create_track_with_volume(
        client, mocker, client_headers, track_factory):
    """Test create bulk track is successful with for_volume."""
    track = track_factory()
    db.merge_model_objects([track])

    request_data = [{'track_name': 'Test'}]
    query_string = {'for_volume': 2}

    mocks.ows_product_verify_product_ownership(mocker)
    mocks.ows_product_get_product_by_id(
        mocker, track.product_id, track.upc)

    res = client.post(
        'product/{}/tracks'.format(track.product_id), headers=client_headers,
        data=json.dumps(request_data), query_string=query_string)
    res_body = json.loads(res.data.decode())

    assert res.status_code == response_code.CREATED
    assert res_body['items'][0]['volume_number'] == 2


def test_bulk_create_track_with_volume_bad_value(
        client, mocker, client_headers):
    """Test create bulk track fails with bad value for_volume."""
    product_id = 1
    request_data = [{'track_name': 'Test'}]
    query_string = {'for_volume': 'Two'}

    res = client.post(
        'product/{}/tracks'.format(product_id), headers=client_headers,
        data=json.dumps(request_data), query_string=query_string)
    res_body = json.loads(res.data.decode())

    assert res.status_code == response_code.BAD_REQUEST
    assert res_body['code'] == 'validation_error'


@db.test_schema
def test_bulk_create_track_new_product_for_explicit(
        client, mocker, client_headers, track_max_tuid,
        track_bulk_create_data_for_explicit,
        track_bulk_create_new_prod_logic_response_for_explicit):
    """Test create bulk track is successful with new product.

    This is to test for attribute "explicit".
    """
    res = _do_track_bulk_create_request(
        client, mocker, client_headers, track_max_tuid,
        track_bulk_create_data_for_explicit,
        track_bulk_create_new_prod_logic_response_for_explicit)
    res_body = json.loads(res.data.decode())

    assert res.status_code == response_code.CREATED
    assert res_body == track_bulk_create_new_prod_logic_response_for_explicit


@db.test_schema
def test_bulk_create_track_existing_product_for_explicit(
        client, mocker, client_headers, track_max_tuid,
        track_bulk_create_data_for_explicit,
        track_bulk_create_existing_prod_logic_response_for_explicit):
    """Test create bulk track is successful with existing product.

    This is to test for attribute "explicit".
    """
    res = _do_track_bulk_create_request(
        client, mocker, client_headers, track_max_tuid,
        track_bulk_create_data_for_explicit,
        track_bulk_create_existing_prod_logic_response_for_explicit)
    res_body = json.loads(res.data.decode())

    assert res.status_code == response_code.CREATED
    assert res_body == \
        track_bulk_create_existing_prod_logic_response_for_explicit