from __future__ import annotations

import logging
from typing import Any

from .client import LazadaAPIClient, LazadaAPIError

logger = logging.getLogger(__name__)


class LazadaTools:
    def __init__(self, client: LazadaAPIClient):
        self._client = client

    async def query_order(self, order_id: str) -> dict[str, Any]:
        try:
            resp = await self._client.call(
                "/order/get",
                params={"order_id": order_id},
            )
            data = resp.get("data", {})
            return {
                "success": True,
                "order_id": order_id,
                "status": data.get("statuses", [""])[-1] if data.get("statuses") else "unknown",
                "items": data.get("order_items", []),
                "total": data.get("price", ""),
                "currency": data.get("currency", ""),
                "raw": data,
            }
        except LazadaAPIError as e:
            return {"success": False, "error": str(e), "error_code": e.code}

    async def query_product(self, item_id: str) -> dict[str, Any]:
        try:
            resp = await self._client.call(
                "/product/item/get",
                params={"item_id": item_id},
            )
            data = resp.get("data", {})
            return {
                "success": True,
                "item_id": item_id,
                "title": data.get("attributes", {}).get("name", ""),
                "price": data.get("skus", [{}])[0].get("price", "") if data.get("skus") else "",
                "stock": data.get("skus", [{}])[0].get("quantity", 0) if data.get("skus") else 0,
                "raw": data,
            }
        except LazadaAPIError as e:
            return {"success": False, "error": str(e), "error_code": e.code}

    async def query_logistics(self, order_id: str) -> dict[str, Any]:
        try:
            resp = await self._client.call(
                "/logistic/order/trace",
                params={"order_id": order_id},
            )
            data = resp.get("data", {})
            trace_list = data.get("trace_list", [])
            return {
                "success": True,
                "order_id": order_id,
                "tracking_number": data.get("tracking_number", ""),
                "status": data.get("status", "unknown"),
                "details": [
                    {
                        "time": t.get("time", ""),
                        "status": t.get("status", ""),
                        "location": t.get("location", ""),
                        "description": t.get("description", ""),
                    }
                    for t in trace_list
                ],
                "raw": data,
            }
        except LazadaAPIError as e:
            return {"success": False, "error": str(e), "error_code": e.code}

    async def get_session_list(self) -> list[dict[str, Any]]:
        try:
            resp = await self._client.call(
                "/im/session/list",
                params={"page_size": "20"},
            )
            return resp.get("data", {}).get("sessions", [])
        except LazadaAPIError:
            return []

    async def get_messages(
        self,
        session_id: str,
        last_message_id: str | None = None,
        start_time: str | None = None,
        page_size: int = 20,
    ) -> list[dict[str, Any]]:
        try:
            params = {
                "session_id": session_id,
                "page_size": str(page_size),
            }
            if last_message_id:
                params["last_message_id"] = last_message_id
            if start_time:
                params["start_time"] = start_time
            resp = await self._client.call(
                "/im/message/list",
                params=params,
            )
            return resp.get("data", {}).get("messages", [])
        except LazadaAPIError:
            return []

    async def query_orders(
        self,
        status: str | None = None,
        update_after: str | None = None,
        limit: int = 20,
    ) -> list[dict[str, Any]]:
        try:
            params: dict[str, str] = {"limit": str(limit)}
            if status:
                params["status"] = status
            if update_after:
                params["update_after"] = update_after

            resp = await self._client.call("/orders/get", params=params)
            orders = resp.get("data", {}).get("orders", [])
            return [
                {
                    "order_id": o.get("order_id", ""),
                    "status": o.get("statuses", [""])[-1] if o.get("statuses") else "unknown",
                    "price": o.get("price", ""),
                    "currency": o.get("currency", ""),
                    "item_count": o.get("items_count", 0),
                    "created_at": o.get("created_at", ""),
                    "raw": o,
                }
                for o in orders
            ]
        except LazadaAPIError:
            return []

    async def query_order_items(self, order_id: str) -> list[dict[str, Any]]:
        try:
            resp = await self._client.call(
                "/order/items/get",
                params={"order_id": order_id},
            )
            items = resp.get("data", [])
            return [
                {
                    "order_item_id": it.get("order_item_id", ""),
                    "item_id": it.get("item_id", ""),
                    "name": it.get("name", ""),
                    "sku": it.get("sku", ""),
                    "price": it.get("item_price", ""),
                    "quantity": it.get("quantity", 0),
                    "raw": it,
                }
                for it in items
            ]
        except LazadaAPIError:
            return []

    async def query_seller(self) -> dict[str, Any]:
        try:
            resp = await self._client.call("/seller/get")
            data = resp.get("data", {})
            return {
                "success": True,
                "seller_id": data.get("seller_id", ""),
                "name": data.get("name", ""),
                "status": data.get("status", ""),
                "email": data.get("email", ""),
                "raw": data,
            }
        except LazadaAPIError as e:
            return {"success": False, "error": str(e), "error_code": e.code}