"""
Orders Tools - Tools for order management
"""
from typing import Any, Dict, List
from app.tools.base import ReadOnlyTool, WriteTool, ToolParameter, ToolResult, ParameterType
from app.tools.registry import register_tool


@register_tool
class GetOrdersTool(ReadOnlyTool):
    """Get list of orders"""

    @property
    def name(self) -> str:
        return "get_orders"

    @property
    def description(self) -> str:
        return "Get a list of orders with optional filtering by status, date, or customer"

    @property
    def parameters(self) -> List[ToolParameter]:
        return [
            ToolParameter(
                name="status",
                type=ParameterType.STRING,
                description="Filter by order status",
                required=False,
                enum=["pending", "processing", "shipped", "delivered", "cancelled", "refunded", "all"]
            ),
            ToolParameter(
                name="period",
                type=ParameterType.STRING,
                description="Time period for orders",
                required=False,
                default="this_week",
                enum=["today", "yesterday", "this_week", "this_month", "custom"]
            ),
            ToolParameter(
                name="customer_id",
                type=ParameterType.STRING,
                description="Filter by specific customer ID",
                required=False
            ),
            ToolParameter(
                name="limit",
                type=ParameterType.INTEGER,
                description="Maximum number of orders to return",
                required=False,
                default=20
            ),
        ]

    @property
    def category(self) -> str:
        return "orders"

    @property
    def agent_types(self) -> List[str]:
        return ["ecommerce", "pos", "general"]

    async def execute(
        self,
        connector: Any,
        params: Dict[str, Any],
        context: Dict[str, Any]
    ) -> ToolResult:
        try:
            orders = await connector.get_orders(
                status=params.get("status"),
                period=params.get("period", "this_week"),
                customer_id=params.get("customer_id"),
                limit=params.get("limit", 20)
            )

            return ToolResult.success_result(
                data=orders,
                message=f"Retrieved {len(orders.get('orders', []))} orders"
            )
        except Exception as e:
            return ToolResult.error_result(str(e))


@register_tool
class GetOrderDetailsTool(ReadOnlyTool):
    """Get details of a specific order"""

    @property
    def name(self) -> str:
        return "get_order_details"

    @property
    def description(self) -> str:
        return "Get full details of a specific order including items, customer info, shipping, and payment"

    @property
    def parameters(self) -> List[ToolParameter]:
        return [
            ToolParameter(
                name="order_id",
                type=ParameterType.STRING,
                description="The order ID or order number",
                required=True
            ),
        ]

    @property
    def category(self) -> str:
        return "orders"

    @property
    def agent_types(self) -> List[str]:
        return ["ecommerce", "pos", "general"]

    async def execute(
        self,
        connector: Any,
        params: Dict[str, Any],
        context: Dict[str, Any]
    ) -> ToolResult:
        try:
            order_id = params["order_id"]
            order = await connector.get_order_details(order_id=order_id)

            if not order:
                return ToolResult.error_result(f"Order {order_id} not found")

            return ToolResult.success_result(
                data=order,
                message=f"Order {order_id} details retrieved"
            )
        except Exception as e:
            return ToolResult.error_result(str(e))


@register_tool
class GetOrderStatusTool(ReadOnlyTool):
    """Get the current status of an order"""

    @property
    def name(self) -> str:
        return "get_order_status"

    @property
    def description(self) -> str:
        return "Get the current status and tracking information for an order"

    @property
    def parameters(self) -> List[ToolParameter]:
        return [
            ToolParameter(
                name="order_id",
                type=ParameterType.STRING,
                description="The order ID or order number",
                required=True
            ),
        ]

    @property
    def category(self) -> str:
        return "orders"

    @property
    def agent_types(self) -> List[str]:
        return ["ecommerce", "pos", "general"]

    async def execute(
        self,
        connector: Any,
        params: Dict[str, Any],
        context: Dict[str, Any]
    ) -> ToolResult:
        try:
            order_id = params["order_id"]
            status = await connector.get_order_status(order_id=order_id)

            if not status:
                return ToolResult.error_result(f"Order {order_id} not found")

            return ToolResult.success_result(
                data=status,
                message=f"Order {order_id} status: {status.get('status', 'Unknown')}"
            )
        except Exception as e:
            return ToolResult.error_result(str(e))


@register_tool
class CreateRefundTool(WriteTool):
    """Create a refund for an order"""

    @property
    def name(self) -> str:
        return "create_refund"

    @property
    def description(self) -> str:
        return "Process a refund for an order. Can be full or partial refund."

    @property
    def parameters(self) -> List[ToolParameter]:
        return [
            ToolParameter(
                name="order_id",
                type=ParameterType.STRING,
                description="The order ID to refund",
                required=True
            ),
            ToolParameter(
                name="amount",
                type=ParameterType.FLOAT,
                description="Refund amount. Leave empty for full refund.",
                required=False
            ),
            ToolParameter(
                name="reason",
                type=ParameterType.STRING,
                description="Reason for the refund",
                required=True
            ),
            ToolParameter(
                name="restock",
                type=ParameterType.BOOLEAN,
                description="Whether to restock the items",
                required=False,
                default=True
            ),
        ]

    @property
    def category(self) -> str:
        return "orders"

    @property
    def agent_types(self) -> List[str]:
        return ["ecommerce", "pos"]

    @property
    def requires_confirmation(self) -> bool:
        return True  # Always require confirmation for refunds

    async def execute(
        self,
        connector: Any,
        params: Dict[str, Any],
        context: Dict[str, Any]
    ) -> ToolResult:
        try:
            order_id = params["order_id"]
            amount = params.get("amount")
            reason = params["reason"]
            restock = params.get("restock", True)

            refund = await connector.create_refund(
                order_id=order_id,
                amount=amount,
                reason=reason,
                restock=restock
            )

            return ToolResult.success_result(
                data=refund,
                message=f"Refund processed for order {order_id}"
            )
        except Exception as e:
            return ToolResult.error_result(str(e))


@register_tool
class UpdateOrderStatusTool(WriteTool):
    """Update the status of an order"""

    @property
    def name(self) -> str:
        return "update_order_status"

    @property
    def description(self) -> str:
        return "Update the status of an order (e.g., mark as shipped, delivered)"

    @property
    def parameters(self) -> List[ToolParameter]:
        return [
            ToolParameter(
                name="order_id",
                type=ParameterType.STRING,
                description="The order ID to update",
                required=True
            ),
            ToolParameter(
                name="status",
                type=ParameterType.STRING,
                description="New status for the order",
                required=True,
                enum=["processing", "shipped", "delivered", "cancelled"]
            ),
            ToolParameter(
                name="tracking_number",
                type=ParameterType.STRING,
                description="Tracking number (required when marking as shipped)",
                required=False
            ),
            ToolParameter(
                name="note",
                type=ParameterType.STRING,
                description="Optional note about the status change",
                required=False
            ),
        ]

    @property
    def category(self) -> str:
        return "orders"

    @property
    def agent_types(self) -> List[str]:
        return ["ecommerce", "pos"]

    async def execute(
        self,
        connector: Any,
        params: Dict[str, Any],
        context: Dict[str, Any]
    ) -> ToolResult:
        try:
            order_id = params["order_id"]
            status = params["status"]
            tracking_number = params.get("tracking_number")
            note = params.get("note")

            result = await connector.update_order_status(
                order_id=order_id,
                status=status,
                tracking_number=tracking_number,
                note=note
            )

            return ToolResult.success_result(
                data=result,
                message=f"Order {order_id} status updated to {status}"
            )
        except Exception as e:
            return ToolResult.error_result(str(e))