"""Test get orders logic."""

from decimal import Decimal
from unittest.mock import Mock

import pytest
from owsresponse import response
from werkzeug.exceptions import NotFound

from vectororder.constants import error, fields
from vectororder.logic import orders


def test_get_order_success(mocker: Mock) -> None:
    """Test order data fetched from model layer successfully."""
    order_id = 100
    dynamo_response_msg = {"foo": "bar"}
    dynamo_response = response.Response(dynamo_response_msg)
    to_dict_return_value = {"foo": "buzz"}
    mock_get_order_from_dynamo = mocker.patch(
        "vectororder.models.orders.get_order_from_dynamo", return_value=dynamo_response
    )
    mock_vector_order_record_to_dict = mocker.patch(
        "vectororder.logic.orders.vector_order_record_to_dict",
        return_value=to_dict_return_value,
    )

    result = orders.get_order(order_id, False)

    assert result == to_dict_return_value
    assert mock_get_order_from_dynamo.call_count == 1
    assert mock_get_order_from_dynamo.called_with(order_id)
    assert mock_vector_order_record_to_dict.call_count == 1
    assert mock_vector_order_record_to_dict.called_with(dynamo_response_msg)


def test_get_order_failure(mocker: Mock) -> None:
    """Test order data fetched from model layer unsuccessfully."""
    order_id = 100
    mock_get_order_from_dynamo = mocker.patch(
        "vectororder.models.orders.get_order_from_dynamo",
        side_effect=NotFound(error.ERROR_MESSAGE_ORDER_NOT_FOUND),
    )

    with pytest.raises(NotFound) as exc:
        orders.get_order(order_id, False)

    assert str(exc.value) == "404 Not Found: " + error.ERROR_MESSAGE_ORDER_NOT_FOUND
    assert mock_get_order_from_dynamo.called_with(order_id)


def test_get_orders_success(mocker: Mock) -> None:
    """Test order data fetched from model layer successfully."""
    order_ids = [100, 200]
    dynamo_response_msg = [{"foo": "bar"}, {"foo": "buzz"}]
    to_dict_return_values = [{"foo": "spam"}, {"foo": "ham"}]
    dynamo_response = dynamo_response_msg
    expected_result = to_dict_return_values
    mock_get_orders_from_dynamo = mocker.patch(
        "vectororder.models.orders.get_orders_from_dynamodb",
        return_value=dynamo_response,
    )
    mock_vector_order_record_to_dict = mocker.patch(
        "vectororder.logic.orders.vector_order_record_to_dict",
        side_effect=to_dict_return_values,
    )

    result = orders.get_orders(order_ids, False)

    assert result == expected_result
    assert mock_get_orders_from_dynamo.call_count == 1
    assert mock_get_orders_from_dynamo.called_with(order_ids)
    assert mock_vector_order_record_to_dict.call_count == len(order_ids)
    assert mock_vector_order_record_to_dict.call_args_list == [
        ((m,),) for m in dynamo_response_msg
    ]


def test_get_orders_failure(mocker: Mock) -> None:
    """Test order data fetched from model layer unsuccessfully."""
    mock_get_order_from_dynamo = mocker.patch(
        "vectororder.models.orders.get_orders_from_dynamodb",
        return_value=[],
    )

    result = orders.get_orders([1, 2, 3], False)

    assert result == []
    assert mock_get_order_from_dynamo.called_with([1, 2, 3])


@pytest.mark.parametrize(
    "order, expected_result",
    (
        (
            {
                fields.DDB_ORDERS_TABLE_KEY: 1,
                fields.ORDER_ENCODER_ID: Decimal(123),
                fields.ORDER_CREATED_AT: "2017-08-28T15:11:52",
                fields.ORDER_PRIORITY: Decimal(1),
                fields.ORDER_METADATA_UPDATE: "N",
                fields.ORDER_USER_ID: Decimal(100),
                "extra_field": "foo",
            },
            {
                fields.DDB_ORDERS_TABLE_KEY: 1,
                fields.ORDER_ENCODER_ID: 123,
                fields.ORDER_CREATED_AT: "2017-08-28T15:11:52",
                fields.ORDER_PRIORITY: 1,
                fields.ORDER_METADATA_UPDATE: False,
                fields.ORDER_USER_ID: 100,
            },
        ),
        (
            {
                fields.DDB_ORDERS_TABLE_KEY: 2,
                fields.ORDER_ENCODER_ID: Decimal(1234),
                fields.ORDER_CREATED_AT: "2018-08-28T15:11:52",
                fields.ORDER_PRIORITY: Decimal(2),
                fields.ORDER_METADATA_UPDATE: "Y",
                fields.ORDER_USER_ID: Decimal(200),
                "extra_field": "foo",
            },
            {
                fields.DDB_ORDERS_TABLE_KEY: 2,
                fields.ORDER_ENCODER_ID: 1234,
                fields.ORDER_CREATED_AT: "2018-08-28T15:11:52",
                fields.ORDER_PRIORITY: 2,
                fields.ORDER_METADATA_UPDATE: True,
                fields.ORDER_USER_ID: 200,
            },
        ),
    ),
)
def test_vector_order_record_to_dict(
    order: dict[str, int | str], expected_result: dict[str, int | str]
) -> None:
    """Test Vector order to dict transformation."""
    assert orders.vector_order_record_to_dict(order) == expected_result