"""
Manufacturing Agent Specialized Tools

Tools specific to manufacturing operations:
- Production orders
- Machine status and monitoring
- Quality control
- Work orders
"""
from typing import Any, Dict
from app.tools.base import ReadOnlyTool, WriteTool, ToolParameter, ParameterType, ToolResult
from app.tools.registry import register_tool


@register_tool
class GetProductionOrdersTool(ReadOnlyTool):
    """Get production orders"""

    name = "get_production_orders"
    description = "Get list of production orders with status and progress"
    category = "manufacturing"
    agent_types = ["manufacturing", "factory", "production"]

    parameters = [
        ToolParameter(
            name="status",
            type=ParameterType.STRING,
            description="Filter by status: planned, in_progress, completed, on_hold",
            required=False
        ),
        ToolParameter(
            name="priority",
            type=ParameterType.STRING,
            description="Filter by priority: low, normal, high, urgent",
            required=False
        ),
        ToolParameter(
            name="date_from",
            type=ParameterType.STRING,
            description="Filter orders from date",
            required=False
        ),
        ToolParameter(
            name="date_to",
            type=ParameterType.STRING,
            description="Filter orders to date",
            required=False
        ),
        ToolParameter(
            name="product_id",
            type=ParameterType.STRING,
            description="Filter by product ID",
            required=False
        ),
    ]

    async def execute(self, connector, params: Dict[str, Any], context: Dict[str, Any]) -> ToolResult:
        try:
            data = await connector.get_production_orders(**params)
            return ToolResult.success_result(data, "Production orders retrieved")
        except Exception as e:
            return ToolResult.error_result(f"Failed to get production orders: {str(e)}")


@register_tool
class GetProductionOrderDetailsTool(ReadOnlyTool):
    """Get detailed production order info"""

    name = "get_production_order_details"
    description = "Get detailed information about a production order including BOM and progress"
    category = "manufacturing"
    agent_types = ["manufacturing", "factory", "production"]

    parameters = [
        ToolParameter(
            name="order_id",
            type=ParameterType.STRING,
            description="Production order ID",
            required=True
        ),
    ]

    async def execute(self, connector, params: Dict[str, Any], context: Dict[str, Any]) -> ToolResult:
        try:
            data = await connector.get_production_order_details(**params)
            return ToolResult.success_result(data, "Production order details retrieved")
        except Exception as e:
            return ToolResult.error_result(f"Failed to get order details: {str(e)}")


@register_tool
class GetMachineStatusTool(ReadOnlyTool):
    """Get machine/equipment status"""

    name = "get_machine_status"
    description = "Get status of manufacturing machines and equipment"
    category = "manufacturing"
    agent_types = ["manufacturing", "factory", "production"]

    parameters = [
        ToolParameter(
            name="machine_id",
            type=ParameterType.STRING,
            description="Specific machine ID (optional)",
            required=False
        ),
        ToolParameter(
            name="status",
            type=ParameterType.STRING,
            description="Filter by status: running, idle, maintenance, offline, error",
            required=False
        ),
        ToolParameter(
            name="line",
            type=ParameterType.STRING,
            description="Filter by production line",
            required=False
        ),
    ]

    async def execute(self, connector, params: Dict[str, Any], context: Dict[str, Any]) -> ToolResult:
        try:
            data = await connector.get_machine_status(**params)
            return ToolResult.success_result(data, "Machine status retrieved")
        except Exception as e:
            return ToolResult.error_result(f"Failed to get machine status: {str(e)}")


@register_tool
class GetQualityReportsTool(ReadOnlyTool):
    """Get quality control reports"""

    name = "get_quality_reports"
    description = "Get quality control inspection reports and metrics"
    category = "manufacturing"
    agent_types = ["manufacturing", "factory", "production", "quality"]

    parameters = [
        ToolParameter(
            name="date_from",
            type=ParameterType.STRING,
            description="Start date for reports",
            required=False
        ),
        ToolParameter(
            name="date_to",
            type=ParameterType.STRING,
            description="End date for reports",
            required=False
        ),
        ToolParameter(
            name="product_id",
            type=ParameterType.STRING,
            description="Filter by product ID",
            required=False
        ),
        ToolParameter(
            name="result",
            type=ParameterType.STRING,
            description="Filter by result: pass, fail, pending",
            required=False
        ),
    ]

    async def execute(self, connector, params: Dict[str, Any], context: Dict[str, Any]) -> ToolResult:
        try:
            data = await connector.get_quality_reports(**params)
            return ToolResult.success_result(data, "Quality reports retrieved")
        except Exception as e:
            return ToolResult.error_result(f"Failed to get quality reports: {str(e)}")


@register_tool
class GetWorkOrdersTool(ReadOnlyTool):
    """Get work orders for operators"""

    name = "get_work_orders"
    description = "Get work orders assigned to operators or workstations"
    category = "manufacturing"
    agent_types = ["manufacturing", "factory", "production"]

    parameters = [
        ToolParameter(
            name="workstation_id",
            type=ParameterType.STRING,
            description="Filter by workstation ID",
            required=False
        ),
        ToolParameter(
            name="operator_id",
            type=ParameterType.STRING,
            description="Filter by operator ID",
            required=False
        ),
        ToolParameter(
            name="status",
            type=ParameterType.STRING,
            description="Filter by status: pending, in_progress, completed",
            required=False
        ),
        ToolParameter(
            name="shift",
            type=ParameterType.STRING,
            description="Filter by shift: morning, afternoon, night",
            required=False
        ),
    ]

    async def execute(self, connector, params: Dict[str, Any], context: Dict[str, Any]) -> ToolResult:
        try:
            data = await connector.get_work_orders(**params)
            return ToolResult.success_result(data, "Work orders retrieved")
        except Exception as e:
            return ToolResult.error_result(f"Failed to get work orders: {str(e)}")


@register_tool
class UpdateProductionOrderStatusTool(WriteTool):
    """Update production order status"""

    name = "update_production_order_status"
    description = "Update status or progress of a production order"
    category = "manufacturing"
    agent_types = ["manufacturing", "factory", "production"]
    requires_confirmation = True

    parameters = [
        ToolParameter(
            name="order_id",
            type=ParameterType.STRING,
            description="Production order ID",
            required=True
        ),
        ToolParameter(
            name="status",
            type=ParameterType.STRING,
            description="New status: in_progress, on_hold, completed, cancelled",
            required=False
        ),
        ToolParameter(
            name="completed_quantity",
            type=ParameterType.INTEGER,
            description="Number of units completed",
            required=False
        ),
        ToolParameter(
            name="notes",
            type=ParameterType.STRING,
            description="Status update notes",
            required=False
        ),
    ]

    async def execute(self, connector, params: Dict[str, Any], context: Dict[str, Any]) -> ToolResult:
        try:
            data = await connector.update_production_order_status(**params)
            return ToolResult.success_result(data, "Production order updated")
        except Exception as e:
            return ToolResult.error_result(f"Failed to update order: {str(e)}")


@register_tool
class ReportMachineIssueTool(WriteTool):
    """Report machine issue or downtime"""

    name = "report_machine_issue"
    description = "Report a machine issue, breakdown, or maintenance requirement"
    category = "manufacturing"
    agent_types = ["manufacturing", "factory", "production", "maintenance"]
    requires_confirmation = True

    parameters = [
        ToolParameter(
            name="machine_id",
            type=ParameterType.STRING,
            description="Machine ID",
            required=True
        ),
        ToolParameter(
            name="issue_type",
            type=ParameterType.STRING,
            description="Type: breakdown, maintenance_required, performance_issue, safety",
            required=True
        ),
        ToolParameter(
            name="description",
            type=ParameterType.STRING,
            description="Description of the issue",
            required=True
        ),
        ToolParameter(
            name="priority",
            type=ParameterType.STRING,
            description="Priority: low, normal, high, critical",
            required=True
        ),
    ]

    async def execute(self, connector, params: Dict[str, Any], context: Dict[str, Any]) -> ToolResult:
        try:
            data = await connector.report_machine_issue(**params)
            return ToolResult.success_result(data, "Machine issue reported")
        except Exception as e:
            return ToolResult.error_result(f"Failed to report issue: {str(e)}")