"""Logic for orders/{order_id}."""

from typing import Any

from vectororder.constants import fields
from vectororder.models import orders
from vectororder.models.schemas import OrderData, OrderStatus


def get_order(order_id: int, include_stores: bool) -> dict[str, Any]:
    """Get vector order data for orders/<order_id>.

    Args:
        order_id (int): Vector order ID
        include_stores (bool): include stores in result or not
    Returns:
        dict: subset of DynamoDB order data
    """
    if include_stores:
        # TODO: get stores from S3 and include in result.
        # This will be required for the "Create Vector Orders" project.
        pass
    return vector_order_record_to_dict(orders.get_order_from_dynamo(order_id))


def get_orders(order_ids: list[int], include_stores: bool) -> list[dict[str, Any]]:
    """Get vector order data for orders/<order_id>.

    Args:
        order_ids (list): Vector order IDs.
        include_stores (bool): include stores in result or not

    Returns:
        list: A subset of Vector order fields as dict
    """
    order_response = orders.get_orders_from_dynamodb(order_ids)
    vector_orders = []

    if order_response:
        for vector_order in order_response:
            vector_order_dict = vector_order_record_to_dict(vector_order)
            if include_stores:
                # TODO: get stores from S3 and include in result.
                # This will be required for the "Create Vector Orders" project.
                pass
            vector_orders.append(vector_order_dict)

    return vector_orders


def vector_order_record_to_dict(order: dict[str, Any]) -> dict[str, Any]:
    """Return Vector order DynamoDB record as dict.

    Args:
        order (dict): A DynamoDB dict with order data.

    Returns:
        dict: A DynamoDB dict with selected fields converted to easily
        serializable values.
    """
    return {
        fields.DDB_ORDERS_TABLE_KEY: order[fields.DDB_ORDERS_TABLE_KEY],
        fields.ORDER_CREATED_AT: order[fields.ORDER_CREATED_AT],
        fields.ORDER_ENCODER_ID: int(order[fields.ORDER_ENCODER_ID]),
        fields.ORDER_USER_ID: int(order[fields.ORDER_USER_ID]),
        fields.ORDER_PRIORITY: int(order[fields.ORDER_PRIORITY]),
        fields.ORDER_METADATA_UPDATE: (order[fields.ORDER_METADATA_UPDATE] == "Y"),
    }


def update_order(
    order_id: int, upcs: set[int], order_status: OrderStatus | None
) -> None:
    """Update vector order."""
    orders.update_order(order_id, upcs, order_status)


def create_order(order_data: OrderData) -> int:
    """Create vector order."""
    return orders.create_order(order_data)