# encoding: utf-8 
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：工厂方法模式（Factory Method Pattern）
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 23:00 
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : Jewelry.py


# --------------------------- 第一步：定义珠宝产品层（属性+业务流程） ---------------------------
class Jewelry:
    """
    珠宝抽象产品基类：定义通用属性和业务流程接口
    """
    def __init__(self, material: str, weight: float, gemstone: str = None):
        """

        :param material:
        :param weight:
        :param gemstone:
        """
        # 通用实体属性
        self.material = material  # 材质（黄金/铂金/18K金）
        self.weight = weight      # 克重（g）
        self.gemstone = gemstone  # 镶嵌宝石（钻石/红宝石/无）
        self.price = 0.0          # 最终定价

    # 业务流程接口（强制子类实现）
    def design(self):
        """

        :return:
        """
        raise NotImplementedError("子类必须实现设计方法")

    def produce(self):
        """

        :return:
        """
        raise NotImplementedError("子类必须实现制作方法")

    def quality_check(self):
        """
        通用质检逻辑（所有珠宝共用）
        :return:
        """
        qualified = self.weight > 0 and self.material in ["黄金", "铂金", "18K金"]
        print(f"【{self.__class__.__name__}】质检：{'合格' if qualified else '不合格'}")
        return qualified

    def pricing(self):
        """

        :return:
        """
        raise NotImplementedError("子类必须实现定价方法")

    def complete_process(self):
        """
        封装完整业务流程：设计→制作→质检→定价
        :return:
        """
        print("\n===== 开始珠宝生产流程 =====")
        self.design()
        self.produce()
        if self.quality_check():
            self.pricing()
            print(f"【{self.__class__.__name__}】最终定价：{self.price:.2f} 元")
        else:
            print(f"【{self.__class__.__name__}】质检不合格，流程终止")
        print("===== 珠宝生产流程结束 =====\n")


# encoding: utf-8 
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：工厂方法模式（Factory Method Pattern）
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 23:02 
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : Bracelet.py
from Model.FactoryMethod.Jewelry import Jewelry

# --------------------------- 第一步：定义珠宝产品层（属性+业务流程） ---------------------------
# 具体珠宝产品：手镯（新增专属属性+实现业务接口）
class Bracelet(Jewelry):
    """
    手镯：专属属性-内径，实现个性化业务逻辑
    """
    def __init__(self, material: str, weight: float, gemstone: str = None, inner_diameter: float = 5.8):
        """

        :param material:
        :param weight:
        :param gemstone:
        :param inner_diameter:
        """
        super().__init__(material, weight, gemstone)#super () 是用来解决多重继承问题的
        self.inner_diameter = inner_diameter  # 手镯专属属性：内径（cm）

    def design(self):
        """

        :return:
        """
        print(f"手镯设计：内径{self.inner_diameter}cm，{self.material}材质，{'雕花镶嵌'+self.gemstone if self.gemstone else '素圈'}")

    def produce(self):
        """

        :return:
        """
        print(f"手镯制作：锻打成型→{self.material}磨砂→{'宝石雕花镶嵌' if self.gemstone else '素圈打磨'}")

    def pricing(self):
        """

        :return:
        """
        base = self.weight * 600
        gem_add = 6000 if self.gemstone == "钻石" else 3500 if self.gemstone == "红宝石" else 0
        self.price = base + gem_add


# encoding: utf-8 
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：工厂方法模式（Factory Method Pattern）
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 23:01 
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : Necklace.py
from Model.FactoryMethod.Jewelry import Jewelry
# --------------------------- 第一步：定义珠宝产品层（属性+业务流程） ---------------------------
# 具体珠宝产品：项链（新增专属属性+实现业务接口）
class Necklace(Jewelry):
    """
    项链：专属属性-链长，实现个性化业务逻辑"
    """
    def __init__(self, material: str, weight: float, gemstone: str = None, chain_length: float = 45):
        """

        :param material:
        :param weight:
        :param gemstone:
        :param chain_length:
        """
        super().__init__(material, weight, gemstone)#super () 是用来解决多重继承问题的
        self.chain_length = chain_length  # 项链专属属性：链长（cm）

    def design(self):
        """

        :return:
        """
        print(f"项链设计：链长{self.chain_length}cm，{self.material}材质，{'吊坠镶嵌'+self.gemstone if self.gemstone else '无吊坠'}")

    def produce(self):
        """

        :return:
        """
        print(f"项链制作：编织链身→{self.material}焊接→{'吊坠宝石镶嵌' if self.gemstone else '素链成型'}")

    def pricing(self):
        """

        :return:
        """
        base = self.weight * 600
        gem_add = 8000 if self.gemstone == "钻石" else 4000 if self.gemstone == "红宝石" else 0
        self.price = base + gem_add


# encoding: utf-8 
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：工厂方法模式（Factory Method Pattern）
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 23:00 
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : Ring.py
from Model.FactoryMethod.Jewelry import Jewelry

# --------------------------- 第一步：定义珠宝产品层（属性+业务流程） ---------------------------
# 具体珠宝产品：戒指（新增专属属性+实现业务接口）
class Ring(Jewelry):
    """
    戒指：专属属性-圈口，实现个性化业务逻辑
    """
    def __init__(self, material: str, weight: float, gemstone: str = None, ring_size: int = 18):
        """

        :param material:
        :param weight:
        :param gemstone:
        :param ring_size:
        """
        super().__init__(material, weight, gemstone) #super () 是用来解决多重继承问题的
        self.ring_size = ring_size  # 戒指专属属性：圈口

    def design(self):
        """

        :return:
        """
        print(f"戒指设计：圈口{self.ring_size}号，{self.material}材质，{'镶嵌'+self.gemstone if self.gemstone else '无镶嵌'}")

    def produce(self):
        """

        :return:
        """
        print(f"戒指制作：打磨圈口→{self.material}抛光→{'宝石镶嵌' if self.gemstone else '素圈成型'}")

    def pricing(self):
        """
        定价规则：基础金价(600元/g)*克重 + 宝石溢价
        :return:
        """
        base = self.weight * 600
        gem_add = 5000 if self.gemstone == "钻石" else 3000 if self.gemstone == "红宝石" else 0
        self.price = base + gem_add

# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：工厂方法模式（Factory Method Pattern）
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 23:03 
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : JewelryFactory.py
from Model.FactoryMethod.Jewelry import Jewelry


# --------------------------- 第二步：定义工厂层（抽象工厂+具体工厂） ---------------------------
class JewelryFactory:
    """
    珠宝抽象工厂基类：定义创建珠宝的接口（工厂方法）
    """
    def create_jewelry(self, **kwargs) -> Jewelry:
        """
        工厂方法：子类必须实现，返回具体珠宝对象
        :param kwargs:
        :return:
        """
        raise NotImplementedError("子类必须实现创建珠宝的方法")


# encoding: utf-8 
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：工厂方法模式（Factory Method Pattern）
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 23:05 
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : BraceletFactory.py
from Interface.FactoryMethod.JewelryFactory import JewelryFactory
from Model.FactoryMethod.Bracelet import Bracelet

# --------------------------- 第二步：定义工厂层（抽象工厂+具体工厂） ---------------------------

class BraceletFactory(JewelryFactory):
    """
    具体工厂：手镯工厂（仅生产手镯）
    """
    def create_jewelry(self, **kwargs) -> Bracelet:
        """

        :param kwargs:
        :return:
        """
        if "inner_diameter" not in kwargs:
            kwargs["inner_diameter"] = 5.8  # 默认内径
        return Bracelet(** kwargs)

# encoding: utf-8 
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：工厂方法模式（Factory Method Pattern）
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 23:05 
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : NecklaceFactory.py
from Interface.FactoryMethod.JewelryFactory import JewelryFactory
from Model.FactoryMethod.Necklace import Necklace
# --------------------------- 第二步：定义工厂层（抽象工厂+具体工厂） ---------------------------

class NecklaceFactory(JewelryFactory):
    """
    具体工厂：项链工厂（仅生产项链）
    """
    def create_jewelry(self, **kwargs) -> Necklace:
        """

        :param kwargs:
        :return:
        """
        if "chain_length" not in kwargs:
            kwargs["chain_length"] = 45  # 默认链长
        return Necklace(** kwargs)




# encoding: utf-8 
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：工厂方法模式（Factory Method Pattern）
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 23:03 
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : RingFactory.py
from Interface.FactoryMethod.JewelryFactory import JewelryFactory
from Model.FactoryMethod.Ring import Ring

# --------------------------- 第二步：定义工厂层（抽象工厂+具体工厂） ---------------------------

class RingFactory(JewelryFactory):
    """
    具体工厂：戒指工厂（仅生产戒指）
    """
    def create_jewelry(self, **kwargs) -> Ring:
        """

        :param kwargs:
        :return:
        """
        # 校验戒指专属属性，保证创建的合法性
        if "ring_size" not in kwargs:
            kwargs["ring_size"] = 18  # 默认圈口
        return Ring(** kwargs)

# encoding: utf-8 
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：工厂方法模式（Factory Method Pattern）
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 23:07 
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : FactoryMethodBll.py
from Interface.FactoryMethod.RingFactory import RingFactory
from Interface.FactoryMethod.BraceletFactory import BraceletFactory
from Interface.FactoryMethod.NecklaceFactory import NecklaceFactory


# --------------------------- 第三步：业务调用示例 ---------------------------

class FactoryMethodBll(object):
    """

    """
    def demo(self):
        """


        :return:
        """
        # 1. 生产钻石戒指：调用戒指工厂
        ring_factory = RingFactory()
        diamond_ring = ring_factory.create_jewelry(
            material="铂金",
            weight=5.2,
            gemstone="钻石",
            ring_size=19
        )
        diamond_ring.complete_process()

        # 2. 生产红宝石项链：调用项链工厂
        necklace_factory = NecklaceFactory()
        ruby_necklace = necklace_factory.create_jewelry(
            material="18K金",
            weight=8.5,
            gemstone="红宝石",
            chain_length=42
        )
        ruby_necklace.complete_process()

        # 3. 生产素圈黄金手镯：调用手镯工厂
        bracelet_factory = BraceletFactory()
        gold_bracelet = bracelet_factory.create_jewelry(
            material="黄金",
            weight=20.8,
            inner_diameter=6.0
        )
        gold_bracelet.complete_process()

# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： 设计模式 Design Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2023.1 python 3.11
# OS        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  oracle 21c Neo4j
# Datetime  : 2026/2/18 20:58
# User      : geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : main.py
# explain   : 学习

import Controller.CheckPatterns


def select_design_pattern() -> tuple[int, Controller.CheckPatterns.DesignPattern | None]:
    """
    返回 (序列号, 选中的枚举对象)，退出则返回 (0, None)
    :return:
    """
    print("\n=== 方式3：用户选择展示 ===")
    print("可选设计模式（输入0或q退出）：")
    for idx, pattern in enumerate(Controller.CheckPatterns.DesignPattern, 1):
        print(f"{idx}. {pattern._name_to_cn(pattern.name)}（{pattern.name}）")
    print("0. 退出")

    while True:
        user_input = input("\n请输入序号选择要展示的设计模式（输入0/q退出）：").strip()
        if user_input in ("0", "q", "Q"):
            print("👋 退出选择流程")
            return (0, None)

        try:
            choice = int(user_input)
            if 1 <= choice <= len(Controller.CheckPatterns.DesignPattern):
                selected_pattern = list(Controller.CheckPatterns.DesignPattern)[choice - 1]
                print(f"✅ 你选择了序号：{choice}（对应{selected_pattern._name_to_cn(selected_pattern.name)}）")
                return (choice, selected_pattern)  # 返回(序列号, 枚举对象)
            else:
                print(f"❌ 输入无效！请输入1-{len(Controller.CheckPatterns.DesignPattern)}之间的数字，或0/q退出")
        except ValueError:
            print("❌ 输入无效！请输入数字序号，或0/q退出")

def ask_continue() -> bool:
    """
    询问用户是否继续选择，返回True（继续）/False（退出）
    """
    while True:
        user_choice = input("\n是否继续选择其他设计模式？(y/n)：").strip().lower()
        if user_choice == "y":
            return True
        elif user_choice == "n":
            print("👋 感谢使用，程序结束！")
            return False
        else:
            print("❌ 输入无效！请输入 y（继续）或 n（退出）")


if __name__ == '__main__':

    # 方式1：用户输入选择展示（交互版）
    '''
    print("\n=== 方式1：用户选择展示 ===")
    print("可选设计模式：")
    for idx, pattern in enumerate( bll.CheckPatterns.DesignPattern, 1):
        print(f"{idx}. {pattern._name_to_cn(pattern.name)}（{pattern.name}）")

    try:
        choice = int(input("\n请输入序号选择要展示的设计模式："))
        selected_pattern = list( bll.CheckPatterns.DesignPattern)[choice - 1]
        selected_pattern.show_example()
    except (ValueError, IndexError):
        print("❌ 输入无效，请输入正确的序号！")
    '''
    # 2

    print("🎉 设计模式示例展示程序")
    while True:
        # 1. 选择设计模式
        selected_num, selected_pattern = select_design_pattern()

        # 2. 判断是否直接退出（输入0/q）
        if selected_num == 0:
            print("👋 程序结束！")
            break

        # 3. 执行选中的示例
        selected_pattern.show_example()
        print(f"\n📌 本次选择的序列号是：{selected_num}")

        # 4. 询问是否继续
        if not ask_continue():
            break  # 用户选择不继续，终止循环

    print('hi,welcome geovindu.')