"""
商品属性规范化和状态映射工具

用于统一两种不同格式的商品属性表示：
- 格式1 (raw_orders): "黑色_38" 或 "黑色SF_L[胸围约122cm]"
- 格式2 (order_sku_details): "颜色分类:黑色;尺码:38" 或 "颜色分类:黑色SF;尺码:L[胸围约122cm]"
"""

import re
from typing import Optional


def normalize_product_attributes(attr_str: Optional[str]) -> str:
    """
    规范化商品属性字符串，统一两种格式

    Args:
        attr_str: 商品属性字符串

    Returns:
        规范化后的属性字符串（统一为格式1）

    Examples:
        >>> normalize_product_attributes("颜色分类:黑色;尺码:38")
        '黑色_38'
        >>> normalize_product_attributes("颜色分类:黑色SF;尺码:L[胸围约122cm]")
        '黑色SF_L[胸围约122cm]'
        >>> normalize_product_attributes("黑色_38")
        '黑色_38'
        >>> normalize_product_attributes("颜色分类:黑色")
        '黑色'
        >>> normalize_product_attributes(None)
        ''
    """
    if not attr_str or not str(attr_str).strip():
        return ""

    attr_str = str(attr_str).strip()

    # 如果已经是格式1（不包含冒号），直接返回
    if ':' not in attr_str:
        return attr_str

    # 格式2转格式1：提取所有属性值
    # 示例：颜色分类:黑色;尺码:38 -> 黑色_38
    if ';' in attr_str:
        # 多个属性
        parts = attr_str.split(';')
        values = []
        for part in parts:
            if ':' in part:
                _, value = part.split(':', 1)
                values.append(value.strip())
        return '_'.join(values) if values else ""
    else:
        # 单个属性
        # 示例：颜色分类:黑色 -> 黑色
        if ':' in attr_str:
            _, value = attr_str.split(':', 1)
            return value.strip()

    return attr_str


def extract_attribute_values(attr_str: Optional[str]) -> dict:
    """
    从格式2的属性字符串中提取键值对

    Args:
        attr_str: 格式2的商品属性字符串

    Returns:
        属性键值对字典

    Examples:
        >>> extract_attribute_values("颜色分类:黑色;尺码:38")
        {'颜色分类': '黑色', '尺码': '38'}
        >>> extract_attribute_values("颜色分类:黑色")
        {'颜色分类': '黑色'}
    """
    if not attr_str:
        return {}

    result = {}
    attr_str = str(attr_str).strip()

    # 按分号分割多个属性
    parts = attr_str.split(';')
    for part in parts:
        if ':' in part:
            key, value = part.split(':', 1)
            result[key.strip()] = value.strip()

    return result


class OrderStatusMapper:
    """订单状态映射工具"""

    # 订单状态映射表 (ExportOrderList -> raw_orders)
    ORDER_STATUS_MAP = {
        "买家已付款,等待卖家发货": "已付款",
        "卖家已发货，等待买家确认": "已发货",
        "卖家已发货,等待买家确认": "已发货",  # 兼容不同标点
        "交易成功": "交易成功",
        "交易关闭": "交易关闭",
        "等待买家付款": "未付款",
        "买家已申请退款": "退款中",
    }

    # 退款状态映射表 (ExportOrderList -> raw_orders)
    REFUND_STATUS_MAP = {
        "没有申请退款": "正常",
        "无退款申请": "正常",
        "退款成功": "退款成功",
        "退款关闭": "正常",  # 退款关闭意味着退款取消，状态回归正常
        "卖家拒绝退款": "正常",  # 卖家拒绝，订单继续正常流程
        "买家已申请退款": "退款中",
        "退款中": "退款中",
    }

    @classmethod
    def map_order_status(cls, sku_status: Optional[str]) -> str:
        """
        将SKU详情中的订单状态映射为raw_orders中的交易状态

        Args:
            sku_status: SKU详情中的订单状态

        Returns:
            映射后的交易状态
        """
        if not sku_status:
            return "已付款"  # 默认状态

        status_str = str(sku_status).strip()
        return cls.ORDER_STATUS_MAP.get(status_str, status_str)

    @classmethod
    def map_refund_status(cls, sku_refund: Optional[str]) -> str:
        """
        将SKU详情中的退款状态映射为raw_orders中的退款状态

        Args:
            sku_refund: SKU详情中的退款状态

        Returns:
            映射后的退款状态
        """
        if not sku_refund:
            return "正常"  # 默认状态

        refund_str = str(sku_refund).strip()
        return cls.REFUND_STATUS_MAP.get(refund_str, refund_str)

    @classmethod
    def reverse_map_order_status(cls, raw_status: Optional[str]) -> str:
        """
        反向映射：将raw_orders的交易状态映射回ExportOrderList格式

        Args:
            raw_status: raw_orders中的交易状态

        Returns:
            ExportOrderList格式的订单状态
        """
        if not raw_status:
            return "买家已付款,等待卖家发货"

        # 构建反向映射
        reverse_map = {v: k for k, v in cls.ORDER_STATUS_MAP.items()}
        status_str = str(raw_status).strip()

        # 特殊处理：如果有多个源状态映射到同一目标，选择最常见的
        if status_str == "已付款":
            return "买家已付款,等待卖家发货"
        elif status_str == "已发货":
            return "卖家已发货，等待买家确认"

        return reverse_map.get(status_str, status_str)

    @classmethod
    def reverse_map_refund_status(cls, raw_refund: Optional[str]) -> str:
        """
        反向映射：将raw_orders的退款状态映射回ExportOrderList格式

        Args:
            raw_refund: raw_orders中的退款状态

        Returns:
            ExportOrderList格式的退款状态
        """
        if not raw_refund:
            return "没有申请退款"

        # 构建反向映射
        reverse_map = {v: k for k, v in cls.REFUND_STATUS_MAP.items()}
        refund_str = str(raw_refund).strip()

        # 特殊处理：如果有多个源状态映射到同一目标，选择最常见的
        if refund_str == "正常":
            return "没有申请退款"

        return reverse_map.get(refund_str, refund_str)


def create_match_key(order_id: str, normalized_attr: str) -> str:
    """
    创建用于匹配raw_orders和order_sku_details的复合键

    Args:
        order_id: 订单号
        normalized_attr: 规范化后的商品属性

    Returns:
        匹配键（订单号||规范化属性）

    Examples:
        >>> create_match_key("123456", "黑色_38")
        '123456||黑色_38'
    """
    return f"{order_id}||{normalized_attr}"


def parse_match_key(match_key: str) -> tuple[str, str]:
    """
    解析匹配键

    Args:
        match_key: 匹配键

    Returns:
        (订单号, 规范化属性)元组

    Examples:
        >>> parse_match_key("123456||黑色_38")
        ('123456', '黑色_38')
    """
    parts = match_key.split('||', 1)
    if len(parts) == 2:
        return parts[0], parts[1]
    return parts[0], ""