"""Tests for SqlAlchemy model orders."""

from ows_product_physical.connector.mysql import delivery_db_session
from ows_product_physical.models import order
from ows_product_physical.models.order import Order
from ows_product_physical.models.order_product import OrderProduct
from tests.utils import db


def test_create_order(delivery_db_fixture):
    """Test that create_order."""
    product_ids = [23245, 23246]
    delivery_store_id = 1705
    identity_id = '10436b38-5e11-472d-b6a4-bf1ee2b1b438'
    delivery_type = 'new'

    result = order.create_order(
        product_ids=product_ids,
        delivery_store_id=delivery_store_id,
        delivery_type=delivery_type,
        identity_id=identity_id)

    assert result.status == 201
    assert result.message
    payload = result.message

    assert payload['id'] is not None


def test_get_orders_no_filters(
    delivery_db_fixture, delivery_orders, delivery_order_products
):
    """Test get_orders without any filters."""
    db.populate_delivery_table(Order, delivery_orders)
    db.populate_delivery_table(OrderProduct, delivery_order_products)
    result = order.get_orders()
    assert result
    assert result.message['total'] == len(delivery_orders)
    assert len(result.message['items']) == len(delivery_orders)
    assert result.message['items'][0] == {
        'cmo_template_version': None,
        'created_at': delivery_orders[0]['created_date'].strftime(
            '%Y-%m-%dT%H:%M:%SZ'),
        'created_by': delivery_orders[0]['created_by'],
        'delivery_store_id': delivery_orders[0]['cmm_id'],
        'id': delivery_orders[0]['order_id'],
        'last_updated': delivery_orders[0]['last_updated'].strftime(
            '%Y-%m-%dT%H:%M:%SZ'),
        'last_updated_by': delivery_orders[0]['last_updated_by'],
        'output_file': None, 'status': delivery_orders[0]['status'],
        'type': delivery_orders[0]['delivery_type'],
        'products': [{
            'id': delivery_order_products[0]['order_product_id'],
            'product_id': delivery_order_products[0]['product_id'],
        }],
    }
    # check sequence of orders
    order_ids = [i['id'] for i in result.message['items']]
    assert order_ids == [1, 2, 3, 4, 5]


def test_get_orders_selected_ids(
    delivery_db_fixture, delivery_orders, delivery_order_products
):
    """Test get_orders with ids filter."""
    db.populate_delivery_table(Order, delivery_orders)
    db.populate_delivery_table(OrderProduct, delivery_order_products)
    ids = [3, 4]
    result = order.get_orders(ids=ids)
    assert result
    assert result.message['total'] == len(ids)
    assert len(result.message['items']) == len(ids)
    order_3 = delivery_orders[2]
    assert result.message['items'][0] == {
        'cmo_template_version': None,
        'created_at': order_3['created_date'].strftime('%Y-%m-%dT%H:%M:%SZ'),
        'created_by': order_3['created_by'],
        'delivery_store_id': order_3['cmm_id'],
        'id': order_3['order_id'],
        'last_updated': order_3['last_updated'].strftime('%Y-%m-%dT%H:%M:%SZ'),
        'last_updated_by': order_3['last_updated_by'],
        'output_file': None,
        'status': order_3['status'],
        'type': order_3['delivery_type'],
        'products': [{
            'id': delivery_order_products[3]['order_product_id'],
            'product_id': delivery_order_products[3]['product_id'],
        }],
    }
    # check sequence of orders
    order_ids = [i['id'] for i in result.message['items']]
    assert order_ids == ids


def test_get_orders_selected_stores(
    delivery_db_fixture, delivery_orders, delivery_order_products
):
    """Test get_orders with delivery_store_ids filter."""
    db.populate_delivery_table(Order, delivery_orders)
    db.populate_delivery_table(OrderProduct, delivery_order_products)
    store_ids = [1610]
    result = order.get_orders(delivery_store_ids=store_ids)
    assert result
    assert result.message['total'] == len(store_ids)
    assert len(result.message['items']) == len(store_ids)
    order_1 = delivery_orders[0]
    assert result.message['items'][0] == {
        'cmo_template_version': None,
        'created_at': order_1['created_date'].strftime('%Y-%m-%dT%H:%M:%SZ'),
        'created_by': order_1['created_by'],
        'delivery_store_id': order_1['cmm_id'],
        'id': order_1['order_id'],
        'last_updated': order_1['last_updated'].strftime('%Y-%m-%dT%H:%M:%SZ'),
        'last_updated_by': order_1['last_updated_by'],
        'output_file': None,
        'status': order_1['status'],
        'type': order_1['delivery_type'],
        'products': [{
            'id': delivery_order_products[0]['order_product_id'],
            'product_id': delivery_order_products[0]['product_id'],
        }],
    }
    # check sequence of orders
    ids = [i['id'] for i in result.message['items']]
    assert ids == [1]


def test_get_orders_delivery_types(
    delivery_db_fixture, delivery_orders, delivery_order_products
):
    """Test get_orders with delivery_types filter."""
    db.populate_delivery_table(Order, delivery_orders)
    db.populate_delivery_table(OrderProduct, delivery_order_products)
    delivery_types = ['takedown']
    result = order.get_orders(delivery_types=delivery_types)
    assert result
    assert result.message['total'] == 1
    assert len(result.message['items']) == 1
    order_4 = delivery_orders[3]
    assert result.message['items'][0] == {
        'cmo_template_version': None,
        'created_at': order_4['created_date'].strftime('%Y-%m-%dT%H:%M:%SZ'),
        'created_by': order_4['created_by'],
        'delivery_store_id': order_4['cmm_id'],
        'id': order_4['order_id'],
        'last_updated': order_4['last_updated'].strftime('%Y-%m-%dT%H:%M:%SZ'),
        'last_updated_by': order_4['last_updated_by'],
        'output_file': order_4['output_file'],
        'status': order_4['status'],
        'type': order_4['delivery_type'],
        'products': [
            {
                'id': delivery_order_products[4]['order_product_id'],
                'product_id': delivery_order_products[4]['product_id'],
            }, {
                'id': delivery_order_products[5]['order_product_id'],
                'product_id': delivery_order_products[5]['product_id'],
            }, {
                'id': delivery_order_products[6]['order_product_id'],
                'product_id': delivery_order_products[6]['product_id'],
            },
        ],
    }
    # check sequence of orders
    ids = [i['id'] for i in result.message['items']]
    assert ids == [4]


def test_get_orders_delivery_statuses(
    delivery_db_fixture, delivery_orders, delivery_order_products
):
    """Test get_orders with statuses filter."""
    db.populate_delivery_table(Order, delivery_orders)
    db.populate_delivery_table(OrderProduct, delivery_order_products)
    statuses = ['complete', 'cancelled']
    result = order.get_orders(delivery_statuses=statuses)
    assert result
    assert result.message['total'] == 3
    assert len(result.message['items']) == 3
    order_2 = delivery_orders[1]
    assert result.message['items'][0] == {
        'cmo_template_version': None,
        'created_at': order_2['created_date'].strftime('%Y-%m-%dT%H:%M:%SZ'),
        'created_by': order_2['created_by'],
        'delivery_store_id': order_2['cmm_id'],
        'id': order_2['order_id'],
        'last_updated': order_2['last_updated'].strftime('%Y-%m-%dT%H:%M:%SZ'),
        'last_updated_by': order_2['last_updated_by'],
        'output_file': None,
        'status': order_2['status'],
        'type': order_2['delivery_type'],
        'products': [
            {
                'id': delivery_order_products[1]['order_product_id'],
                'product_id': delivery_order_products[1]['product_id'],
            }, {
                'id': delivery_order_products[2]['order_product_id'],
                'product_id': delivery_order_products[2]['product_id'],
            },
        ],
    }
    # check sequence of orders
    ids = [i['id'] for i in result.message['items']]
    assert ids == [2, 4, 5]


def test_get_orders_limit_offset(
    delivery_db_fixture, delivery_orders, delivery_order_products
):
    """Test get_orders with limit and offset."""
    db.populate_delivery_table(Order, delivery_orders)
    db.populate_delivery_table(OrderProduct, delivery_order_products)
    result = order.get_orders(limit=2, offset=1)
    assert result
    assert result.message['total'] == len(delivery_orders)
    assert len(result.message['items']) == 2
    # check sequence of orders
    ids = [i['id'] for i in result.message['items']]
    assert ids == [2, 3]


def test_get_orders_order(
    delivery_db_fixture, delivery_orders, delivery_order_products
):
    """Test get_orders with order_by."""
    db.populate_delivery_table(Order, delivery_orders)
    db.populate_delivery_table(OrderProduct, delivery_order_products)
    result = order.get_orders(order_by='last_updated', order_dir='desc')
    assert result
    assert result.message['total'] == len(delivery_orders)
    assert len(result.message['items']) == 5
    # check sequence of orders
    ids = [i['id'] for i in result.message['items']]
    assert ids == [5, 4, 3, 1, 2]


def test_get_orders_order_store(
    delivery_db_fixture, delivery_orders, delivery_order_products
):
    """Test get_orders with order_by and delivery_store_ids."""
    db.populate_delivery_table(Order, delivery_orders)
    db.populate_delivery_table(OrderProduct, delivery_order_products)
    result = order.get_orders(
        order_by='last_updated', delivery_store_ids=['1705'])
    assert result
    assert result.message['total'] == 3
    assert len(result.message['items']) == 3
    # check sequence of orders
    ids = [i['id'] for i in result.message['items']]
    assert ids == [2, 3, 4]


def test_get_order_by_order_id(
    delivery_db_fixture, delivery_orders, delivery_order_products
):
    """Test get_order_by_order_id."""
    db.populate_delivery_table(Order, delivery_orders)
    db.populate_delivery_table(OrderProduct, delivery_order_products)
    order_id = delivery_orders[4]['order_id']
    with (delivery_db_session() as session):
        result = order.get_order_by_order_id(order_id, session)
        assert result == session.query(Order) \
            .filter(Order.order_id == order_id) \
            .one()


def test_update_orders(
    delivery_db_fixture,
    delivery_orders,
    delivery_order_products,
    db_fixture
):
    """Test update_orders."""
    order_id = 1

    db.populate_delivery_table(Order, delivery_orders)
    db.populate_delivery_table(OrderProduct, delivery_order_products)

    with delivery_db_session() as session:
        result = order.update_orders(
            identity_id='10436b38-5e11-472d-b6a4-bf1ee2b1b438',
            orders=[
                {'order_id': order_id, 'status': 'completed'}
            ],
            session=session
        )

        assert result.status == 200
        assert result.message == {'items': [{'id': order_id}]}