# -*- coding: utf-8 -*-
"""
@author: shaoxyz
@file: convert_format.py
@time: 2020-07-20 11:09
@desc:
"""
from typing import List
industry_list = [
    {"parent_ind": "女装", "name": "连衣裙"},
    {"name": "女装"},
    {"parent_ind": "女装", "name": "半身裙"},
    {"parent_ind": "女装", "name": "A字裙"},
    {"parent_ind": "数码", "name": "电脑配件"},
    {"parent_ind": "电脑配件", "name": "内存"},
    {"name": "数码"},
]

expect_output = {
    "数码": {
        "电脑配件": {
            "内存": {}
        }
    }, 
    "女装": {
        "连衣裙": {}, 
        "半身裙": {}, 
        "A字裙": {}
    }
}


def convert_format(data: List[dict]) -> dict:
    """
    将包含父子关系值的列表 转换为 嵌套字典
    """

    data_dict = {i.get("name"): {} for i in data}
    has_parent = set()

    for i in data:
        parent_ind = i.get("parent_ind")
        name = i.get("name")
        if parent_ind:
            has_parent.add(name)
        if parent_ind in data_dict:
            data_dict[parent_ind][name] = data_dict[name]  # KEY

    # Filter
    res = {key: val for key, val in data_dict.items() if key not in has_parent}

    return res


def test_convert_format():
    res = convert_format(industry_list)
    assert res == expect_output
    print("well done")

# -*- coding: utf-8 -*-
"""
@version: python3.7
@author: shaoxyz
@file: strategy.py
@time: 2020-07-01 18:54
@desc: 操练策略模式
"""
import re
import textwrap
import threading
from decimal import Decimal
from abc import ABC, abstractmethod
from functools import wraps
from typing import Dict

"""
菜品属性说明
item = {
    _id: <INCR>,        # 自增id
    name: str,          # 菜品名
    price: int,         # 单价，单位:分
    is_half_price: bool # 是否半价
}
"""
data = {
    "ITEM0001": {"_id": 1, "name": "黄焖鸡", "price": 1800, "is_half_price": True},
    "ITEM0002": {"_id": 2, "name": "蛋炒饭", "price": 1500, "is_half_price": False},
    "ITEM0003": {"_id": 3, "name": "牛肉面", "price": 2200, "is_half_price": True},
    "ITEM0004": {"_id": 4, "name": "东北饺子", "price": 1800, "is_half_price": False},
    "ITEM0013": {"_id": 13, "name": "肉夹馍", "price": 600, "is_half_price": True},
    "ITEM0022": {"_id": 22, "name": "凉皮", "price": 800, "is_half_price": True},
    "ITEM0023": {
        "_id": 23,
        "name": "超级无敌海鲜霸王担担面之超级无敌海鲜霸王担担面",
        "price": 3000,
        "is_half_price": True,
    },
}

## Exception


class ObjectDoesNotExist(Exception):
    """The requested object does not exist"""

    pass


class InvalidParams(Exception):
    """Invalid parameters"""

    pass


class EmptyInput(Exception):
    """Invalid parameters"""

    pass


## Obj


class Item:
    def __init__(self, item_id, count):
        self.item_info = data.get(item_id)
        if self.item_info is None:
            raise ObjectDoesNotExist(f"不存在菜品: {item_id}")
        self.count = count

    def __repr__(self):
        return self.name

    @property
    def price(self) -> int:
        return self.item_info.get("price")

    @property
    def name(self) -> str:
        return self.item_info.get("name")

    @property
    def is_half_price(self) -> bool:
        return self.item_info.get("is_half_price", False)

    @property
    def total(self) -> int:
        return self.price * self.count


class Order:
    _lock = threading.RLock()  # 无论类有多少个实例，都用一个锁

    def __init__(self, promotion=None):
        self.basket = []
        self.promotion = promotion
        self.half_price_items = set()

        self._final_promotion = None
        self._discount = 0
        self._finished = False

    def add_to_basket(self, *items):
        with Order._lock:
            self._finished = False
            for item in items:
                self.basket.append(item)

    @property
    def final_promotion(self) -> str:
        if not self._finished:
            self.charge()
        return self._final_promotion

    @property
    def discount(self) -> int:
        if not self._finished:
            self.charge()
        return self._discount

    @property
    def total(self) -> int:
        total = 0
        for item in self.basket:
            total += item.total
        return total

    def charge(self):
        if not self.promotion:
            discount = 0
        else:
            with Order._lock:
                discount = self.promotion.discount(self)
                self._finished = True

        return self.total - discount


## Promotion
PROMOS = set()


def add_to_promos(func):
    """注册到优惠机制集合"""

    PROMOS.add(func)

    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)

    return wrapper


class Promotion(ABC):
    """优惠策略抽象基类"""

    @abstractmethod
    def discount(self, order):
        pass


@add_to_promos
class FullReductionPromo(Promotion):
    """满30减6元"""

    def discount(self, order):
        return 600 if order.total > 3000 else 0


@add_to_promos
class HalfPricePromo(Promotion):
    """指定菜品半价"""

    def discount(self, order):
        discount = 0
        for item in order.basket:
            if item.is_half_price:
                order.half_price_items.add(item.name)
                discount += item.total / 2
        return discount


class BestPromo(Promotion):
    """最佳优惠"""

    def discount(self, order):

        # 使用装饰器注册代替
        # all_promotion = [
        #     globals()[name]
        #     for name in globals()
        #     if name.endswith("Promo") and name != "BestPromo"
        # ]

        for promo in PROMOS:
            discount = promo().discount(order)
            if discount != 0 and discount > order._discount:
                order._discount = discount
                order._final_promotion = promo().__doc__

        return order._discount


## utils


def format_output(order):
    """
    :return:
    ============= 订餐明细 =============
    黄焖鸡 x 1 = 18元
    肉夹馍 x 2 = 12元
    凉皮 x 1 = 8元
    -----------------------------------
    使用优惠:
    指定菜品半价(黄焖鸡，凉皮)，省13元
    -----------------------------------
    总计：25元
    ===================================
    """
    head = "============= 订餐明细 =============\n"
    divide = "\n-----------------------------------\n"
    bottom = "==================================="

    items_output = "\n".join(
        [
            "\n".join(
                textwrap.wrap(f"{i.name} x {i.count} = {Decimal(i.total / 100)}元", 20)
            )
            for i in order.basket
        ]
    )
    output = head + items_output + divide
    charge_output = f"总计：{Decimal(order.charge() / 100)}元\n"

    best_promo = order.final_promotion
    if best_promo == "指定菜品半价":
        lines = "\n".join(
            textwrap.wrap(
                f"{best_promo}({','.join(order.half_price_items)}), 省{Decimal(order.discount/100)}元",
                20,
            )
        )
        promotion_output = f"使用优惠: \n{lines}"
        output += promotion_output + divide
    elif best_promo == "满30减6元":
        promotion_output = f"使用优惠: \n{best_promo}, 省{Decimal(order.discount/100)}元"
        output += promotion_output + divide

    output += charge_output + bottom

    return output


def verify_input_format(input_item: str) -> None:
    pattern = re.compile(r"^ITEM\d+( x ){1}[1-9]+")
    if not pattern.match(input_item):
        raise InvalidParams("输入格式有误")


def parse_input(input_items: list) -> Dict[str, int]:
    if not input_items:
        raise EmptyInput("未挑选菜品")

    items_map = {}
    for i in input_items:
        verify_input_format(i)
        item_id, count = i.split(" x ")
        if item_id in items_map:
            items_map[item_id] += int(count)
        else:
            items_map[item_id] = int(count)

    return items_map


## main


def bestCharge(input_items: list) -> str:
    items_map = parse_input(input_items)

    order = Order(promotion=BestPromo())

    order.add_to_basket(
        *[Item(item_id, items_map[item_id]) for item_id in items_map.keys()]
    )

    return format_output(order)


if __name__ == "__main__":
    input_demo3 = ["ITEM0001 x 1", "ITEM0001 x 1", "ITEM0013 x 4", "ITEM0013 x 4"]

    print(bestCharge(input_demo3))

from collections import Counte...

def count(s):
    res = {}
    for i in s:
        if i not in res:
            res[i] = 1
        else:
            res[i] += 1
    print(res)

def count(s):
    res = {}
    for i in s:
        if i not in res: # 第一次查res
            res[i] = 1
        else:
            res[i] += 1 # 等价于`res[i] = res[i] + 1` 第二次查res
    print(res)

def count(s):
    res = {}
    for i in s:
        res[i] = res.get(i, 0) + 1 # 只查了一次res
    print(res)

from collections import defaultdict
def count2(s):
    res = defaultdict(int)
    for i in s:
        res[i] += 1 # 只查了一次res
    print(res)