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


@register_tool
class GetCustomersTool(ReadOnlyTool):
    """Get list of customers"""

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

    @property
    def description(self) -> str:
        return "Get a list of customers with optional filtering"

    @property
    def parameters(self) -> List[ToolParameter]:
        return [
            ToolParameter(
                name="status",
                type=ParameterType.STRING,
                description="Filter by customer status",
                required=False,
                enum=["active", "inactive", "all"]
            ),
            ToolParameter(
                name="created_after",
                type=ParameterType.DATE,
                description="Filter customers created after this date",
                required=False
            ),
            ToolParameter(
                name="has_orders",
                type=ParameterType.BOOLEAN,
                description="Filter to customers who have placed orders",
                required=False
            ),
            ToolParameter(
                name="limit",
                type=ParameterType.INTEGER,
                description="Maximum number of customers to return",
                required=False,
                default=20
            ),
        ]

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

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

    async def execute(
        self,
        connector: Any,
        params: Dict[str, Any],
        context: Dict[str, Any]
    ) -> ToolResult:
        try:
            customers = await connector.get_customers(
                status=params.get("status"),
                created_after=params.get("created_after"),
                has_orders=params.get("has_orders"),
                limit=params.get("limit", 20)
            )

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


@register_tool
class GetCustomerDetailsTool(ReadOnlyTool):
    """Get details of a specific customer"""

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

    @property
    def description(self) -> str:
        return "Get full details of a specific customer including order history and lifetime value"

    @property
    def parameters(self) -> List[ToolParameter]:
        return [
            ToolParameter(
                name="customer_id",
                type=ParameterType.STRING,
                description="The customer ID",
                required=False
            ),
            ToolParameter(
                name="email",
                type=ParameterType.STRING,
                description="Customer email address",
                required=False
            ),
            ToolParameter(
                name="phone",
                type=ParameterType.STRING,
                description="Customer phone number",
                required=False
            ),
        ]

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

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

    async def execute(
        self,
        connector: Any,
        params: Dict[str, Any],
        context: Dict[str, Any]
    ) -> ToolResult:
        try:
            customer_id = params.get("customer_id")
            email = params.get("email")
            phone = params.get("phone")

            if not any([customer_id, email, phone]):
                return ToolResult.error_result("Must provide customer_id, email, or phone")

            customer = await connector.get_customer_details(
                customer_id=customer_id,
                email=email,
                phone=phone
            )

            if not customer:
                return ToolResult.error_result("Customer not found")

            return ToolResult.success_result(
                data=customer,
                message=f"Customer details for {customer.get('name', 'Unknown')}"
            )
        except Exception as e:
            return ToolResult.error_result(str(e))


@register_tool
class GetTopCustomersTool(ReadOnlyTool):
    """Get top customers by revenue or order count"""

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

    @property
    def description(self) -> str:
        return "Get the top customers by revenue or number of orders"

    @property
    def parameters(self) -> List[ToolParameter]:
        return [
            ToolParameter(
                name="period",
                type=ParameterType.STRING,
                description="Time period for analysis",
                required=False,
                default="all_time",
                enum=["this_month", "this_quarter", "this_year", "all_time"]
            ),
            ToolParameter(
                name="sort_by",
                type=ParameterType.STRING,
                description="Sort customers by revenue or order count",
                required=False,
                default="revenue",
                enum=["revenue", "order_count"]
            ),
            ToolParameter(
                name="limit",
                type=ParameterType.INTEGER,
                description="Number of customers to return",
                required=False,
                default=10
            ),
        ]

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

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

    async def execute(
        self,
        connector: Any,
        params: Dict[str, Any],
        context: Dict[str, Any]
    ) -> ToolResult:
        try:
            period = params.get("period", "all_time")
            sort_by = params.get("sort_by", "revenue")
            limit = params.get("limit", 10)

            customers = await connector.get_top_customers(
                period=period,
                sort_by=sort_by,
                limit=limit
            )

            return ToolResult.success_result(
                data=customers,
                message=f"Top {limit} customers by {sort_by}"
            )
        except Exception as e:
            return ToolResult.error_result(str(e))


@register_tool
class SearchCustomersTool(ReadOnlyTool):
    """Search for customers"""

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

    @property
    def description(self) -> str:
        return "Search for customers by name, email, phone, or other attributes"

    @property
    def parameters(self) -> List[ToolParameter]:
        return [
            ToolParameter(
                name="query",
                type=ParameterType.STRING,
                description="Search query (name, email, phone)",
                required=True
            ),
            ToolParameter(
                name="limit",
                type=ParameterType.INTEGER,
                description="Maximum number of results",
                required=False,
                default=10
            ),
        ]

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

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

    async def execute(
        self,
        connector: Any,
        params: Dict[str, Any],
        context: Dict[str, Any]
    ) -> ToolResult:
        try:
            query = params["query"]
            limit = params.get("limit", 10)

            results = await connector.search_customers(
                query=query,
                limit=limit
            )

            return ToolResult.success_result(
                data=results,
                message=f"Found {len(results.get('customers', []))} customers matching '{query}'"
            )
        except Exception as e:
            return ToolResult.error_result(str(e))