/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Simple Factory Pattern 简单工厂模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/13 21:52
# User      :  geovindu
# Product   : GoLand
# Project   : sudydemo
# File      : jewelry.go
*/
package simplefactory

// Jewelry 珠宝接口，所有珠宝产品都要实现该接口
type Jewelry interface {
	ShowInfo()            // 展示珠宝信息
	MaterialCheck()       // 材质检测（业务流程）
	CustomEngrave(string) // 定制刻字（业务流程）
}

// 珠宝类型常量，工厂用来判断生产哪种珠宝
const (
	JewelryTypeRing     = "ring"     // 钻戒
	JewelryTypeNecklace = "necklace" // 项链
	JewelryTypeBracelet = "bracelet" // 手镯
)



/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Simple Factory Pattern 简单工厂模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/13 21:53
# User      :  geovindu
# Product   : GoLand
# Project   : sudydemo
# File      : ring.go
*/
package simplefactory

import "fmt"

// DiamondRing 钻戒（具体产品类）
type DiamondRing struct {
	Material string // 材质：铂金/18K金
	Carat    string // 钻石克拉
	Engrave  string // 刻字内容
}

// ShowInfo 展示钻戒信息
func (r *DiamondRing) ShowInfo() {
	fmt.Printf("【钻戒】材质：%s | 钻石克拉：%s | 刻字：%s\n", r.Material, r.Carat, r.Engrave)
}

// MaterialCheck 钻戒材质检测
func (r *DiamondRing) MaterialCheck() {
	fmt.Printf("✅ 钻戒材质检测完成：%s 材质合格，钻石无瑕疵\n", r.Material)
}

// CustomEngrave 钻戒定制刻字
func (r *DiamondRing) CustomEngrave(text string) {
	r.Engrave = text
	fmt.Printf("✍️ 钻戒刻字成功：%s\n", text)
}



/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Simple Factory Pattern 简单工厂模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/13 21:53
# User      :  geovindu
# Product   : GoLand
# Project   : sudydemo
# File      : necklace.go
*/
package simplefactory

import "fmt"

// Necklace 项链（具体产品类）
type Necklace struct {
	Material string // 材质：黄金/白金
	Length   string // 项链长度
	Engrave  string // 刻字内容
}

// ShowInfo 展示项链信息
func (n *Necklace) ShowInfo() {
	fmt.Printf("【项链】材质：%s | 长度：%s | 刻字：%s\n", n.Material, n.Length, n.Engrave)
}

// MaterialCheck 项链材质检测
func (n *Necklace) MaterialCheck() {
	fmt.Printf("✅ 项链材质检测完成：%s 材质纯度达标\n", n.Material)
}

// CustomEngrave 项链定制刻字
func (n *Necklace) CustomEngrave(text string) {
	n.Engrave = text
	fmt.Printf("✍️ 项链刻字成功：%s\n", text)
}



/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Simple Factory Pattern 简单工厂模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/13 21:54
# User      :  geovindu
# Product   : GoLand
# Project   : sudydemo
# File      : bracelet.go
*/
package simplefactory

import "fmt"

// Bracelet 手镯（具体产品类）
type Bracelet struct {
	Material string // 材质：银/翡翠
	Style    string // 款式：素圈/雕花
	Engrave  string // 刻字内容
}

// ShowInfo 展示手镯信息
func (b *Bracelet) ShowInfo() {
	fmt.Printf("【手镯】材质：%s | 款式：%s | 刻字：%s\n", b.Material, b.Style, b.Engrave)
}

// MaterialCheck 手镯材质检测
func (b *Bracelet) MaterialCheck() {
	fmt.Printf("✅ 手镯材质检测完成：%s 材质无裂纹\n", b.Material)
}

// CustomEngrave 手镯定制刻字
func (b *Bracelet) CustomEngrave(text string) {
	b.Engrave = text
	fmt.Printf("✍️ 手镯刻字成功：%s\n", text)
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Simple Factory Pattern 简单工厂模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/13 21:54
# User      :  geovindu
# Product   : GoLand
# Project   : sudydemo
# File      : factory.go
*/
package simplefactory

import "errors"

// JewelryFactory 珠宝加工厂（简单工厂类）
type JewelryFactory struct{}

// CreateJewelry 生产珠宝：传入珠宝类型，返回对应的珠宝产品
func (f *JewelryFactory) CreateJewelry(jewelryType string) (Jewelry, error) {
	switch jewelryType {
	case JewelryTypeRing:
		// 生产钻戒：默认配置
		return &DiamondRing{
			Material: "18K白金",
			Carat:    "1克拉",
		}, nil
	case JewelryTypeNecklace:
		// 生产项链：默认配置
		return &Necklace{
			Material: "足金",
			Length:   "45cm",
		}, nil
	case JewelryTypeBracelet:
		// 生产手镯：默认配置
		return &Bracelet{
			Material: "S999纯银",
			Style:    "素圈",
		}, nil
	default:
		return nil, errors.New("不支持生产该类型珠宝")
	}
}　

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： Simple Factory Pattern 简单工厂模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/13 21:55
# User      :  geovindu
# Product   : GoLand
# Project   : sudydemo
# File      : simplefactorybll.go
*/
package bll

import (
	"sudydemo/simplefactory"
)

// 显示示例
func SimpleFactoryMain() {
	// 1. 初始化珠宝加工厂（工厂实例）
	factory := &simplefactory.JewelryFactory{}
	println("========== 珠宝店下单流程 ==========\n")

	// ==================== 订单1：生产钻戒 ====================
	ring, err := factory.CreateJewelry(simplefactory.JewelryTypeRing)
	if err != nil {
		panic(err)
	}
	ring.MaterialCheck()       // 材质检测
	ring.CustomEngrave("永浴爱河") // 定制刻字
	ring.ShowInfo()            // 展示成品
	println()

	// ==================== 订单2：生产项链 ====================
	necklace, err := factory.CreateJewelry(simplefactory.JewelryTypeNecklace)
	if err != nil {
		panic(err)
	}
	necklace.MaterialCheck()
	necklace.CustomEngrave("平安喜乐")
	necklace.ShowInfo()
	println()

	// ==================== 订单3：生产手镯 ====================
	bracelet, err := factory.CreateJewelry(simplefactory.JewelryTypeBracelet)
	if err != nil {
		panic(err)
	}
	bracelet.MaterialCheck()
	bracelet.CustomEngrave("健康顺遂")
	bracelet.ShowInfo()
}

go mod init sudydemo

go get gorm.io/driver/sqlserver
go get gorm.io/driver/sqlite
go get gorm.io/driver/mysql

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/18 22:21
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : jewelry_config.go
*/
package config

// 珠宝默认配置，集中管理，便于扩展
var JewelryCfg = map[string]struct {
	Material string
}{
	"RING":     {Material: "18K白金"},
	"NECKLACE": {Material: "足金999"},
	"BRACELET": {Material: "S999纯银"},
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/18 22:21
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : jewelry.go
*/
package domain

// Jewelry 顶层抽象接口 【职责单一】
type Jewelry interface {
	MaterialCheck() error
	CustomEngrave(text string) error
	ShowInfo() string
}

// 珠宝类型常量
const (
	JewelryRing     = "RING"
	JewelryNecklace = "NECKLACE"
	JewelryBracelet = "BRACELET"
)

// BaseJewelry 基础模型
type BaseJewelry struct {
	Material   string
	EngraveStr string
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/18 22:22
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : jewelry_factory.go
*/
package factory

import (
	"errors"
	"godesginpattern/simplefactorone/config"
	"godesginpattern/simplefactorone/domain"
	"godesginpattern/simplefactorone/product"
)

// ===== 【修复核心】定义统一构造器签名 =====
type JewelryCreator func(material string) domain.Jewelry

// 产品构造器注册池（现在 100% 不报错）
var registerCreator = map[string]JewelryCreator{
	domain.JewelryRing: func(material string) domain.Jewelry {
		return product.NewDiamondRing(material)
	},
	domain.JewelryNecklace: func(material string) domain.Jewelry {
		return product.NewNecklace(material)
	},
	domain.JewelryBracelet: func(material string) domain.Jewelry {
		return product.NewBracelet(material)
	},
}

// JewelryFactory 简单工厂
type JewelryFactory struct{}

func NewJewelryFactory() *JewelryFactory {
	return &JewelryFactory{}
}

func (f *JewelryFactory) Create(jewelryType string) (domain.Jewelry, error) {
	creator, ok := registerCreator[jewelryType]
	if !ok {
		return nil, errors.New("不支持该珠宝类型：" + jewelryType)
	}
	cfg := config.JewelryCfg[jewelryType]
	return creator(cfg.Material), nil
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/18 22:22
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : ring.go
*/
package product

import (
	"errors"
	"godesginpattern/simplefactorone/domain"
)

type DiamondRing struct {
	domain.BaseJewelry
	Carat string
}

func NewDiamondRing(material string) *DiamondRing {
	return &DiamondRing{
		BaseJewelry: domain.BaseJewelry{
			Material: material,
		},
		Carat: "1克拉",
	}
}

func (d *DiamondRing) MaterialCheck() error {
	println("✅ 钻戒材质检测：", d.Material, "质检合格，钻石无瑕")
	return nil
}

func (d *DiamondRing) CustomEngrave(text string) error {
	if text == "" {
		return errors.New("刻字内容不能为空")
	}
	d.EngraveStr = text
	println("✍️ 钻戒定制刻字完成：", text)
	return nil
}

func (d *DiamondRing) ShowInfo() string {
	return "【钻戒】材质:" + d.Material + "  克拉:" + d.Carat + "  刻字:" + d.EngraveStr
}



/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/18 22:22
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : necklace.go
*/
package product

import (
	"errors"
	"godesginpattern/simplefactorone/domain"
)

type Necklace struct {
	domain.BaseJewelry
	Length string
}

func NewNecklace(material string) *Necklace {
	return &Necklace{
		BaseJewelry: domain.BaseJewelry{Material: material},
		Length:      "45cm",
	}
}

func (n *Necklace) MaterialCheck() error {
	println("✅ 项链材质检测：", n.Material, "纯度达标")
	return nil
}

func (n *Necklace) CustomEngrave(text string) error {
	if text == "" {
		return errors.New("刻字内容不能为空")
	}
	n.EngraveStr = text
	println("✍️ 项链定制刻字完成：", text)
	return nil
}

func (n *Necklace) ShowInfo() string {
	return "【项链】材质:" + n.Material + "  长度:" + n.Length + "  刻字:" + n.EngraveStr
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/18 22:22
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : bracelet.go
*/
package product

import (
	"errors"
	"godesginpattern/simplefactorone/domain"
)

type Bracelet struct {
	domain.BaseJewelry
	Style string
}

func NewBracelet(material string) *Bracelet {
	return &Bracelet{
		BaseJewelry: domain.BaseJewelry{Material: material},
		Style:       "古法素圈",
	}
}

func (b *Bracelet) MaterialCheck() error {
	println("✅ 手镯材质检测：", b.Material, "无裂纹瑕疵")
	return nil
}

func (b *Bracelet) CustomEngrave(text string) error {
	if text == "" {
		return errors.New("刻字内容不能为空")
	}
	b.EngraveStr = text
	println("✍️ 手镯定制刻字完成：", text)
	return nil
}

func (b *Bracelet) ShowInfo() string {
	return "【手镯】材质:" + b.Material + "  款式:" + b.Style + "  刻字:" + b.EngraveStr
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/18 22:23
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : jewelry_service.go
*/
package service

import "godesginpattern/simplefactorone/domain"
import "godesginpattern/simplefactorone/factory"

type JewelryService struct {
	fac *factory.JewelryFactory
}

func NewJewelryService(fac *factory.JewelryFactory) *JewelryService {
	return &JewelryService{fac: fac}
}

// Produce 完整业务链路：创建 -> 质检 -> 刻字
func (s *JewelryService) Produce(jewelryType, engStr string) (domain.Jewelry, error) {
	item, err := s.fac.Create(jewelryType)
	if err != nil {
		return nil, err
	}
	_ = item.MaterialCheck()
	_ = item.CustomEngrave(engStr)
	return item, nil
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： Simple Factory Pattern 简单工厂模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/13 21:55
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : simplefactorybll.go

simplefactory/
├── jewelry.go       # 珠宝产品接口（所有珠宝的公共规范）
├── ring.go          # 钻戒产品（具体实现）
├── necklace.go      # 项链产品（具体实现）
├── bracelet.go      # 手镯产品（具体实现）
├── factory.go       # 珠宝加工厂（简单工厂类）
└── main.go          # 珠宝店（客户端，调用入口）
2.
simplefactory/
├── go.mod
├── main.go                 // 入口 + 模式选择交互
├── controller/
│   └── design_pattern_ctrl.go  // 你的枚举 + ShowExample
├── bll/
│   └── simplefactory_bll.go    // 业务层入口 SimpleFactoryMain
├── internal/
│   ├── domain/
│   │   └── jewelry.go          // 珠宝领域接口、常量
│   ├── product/
│   │   ├── ring.go
│   │   ├── necklace.go
│   │   └── bracelet.go
│   ├── factory/
│   │   └── jewelry_factory.go  // 企业级可注册简单工厂
│   └── service/
│       └── jewelry_service.go  // 业务流程编排
└── config/

	└── jewelry_config.go       // 配置解耦、无硬编码
*/
package bll

import (
	"fmt"
	"godesginpattern/simplefactorone/domain"
	"godesginpattern/simplefactorone/factory"
	"godesginpattern/simplefactorone/service"
)

// 2  显示示例
func SimpleFactoryMain() {
	fac := factory.NewJewelryFactory()
	svc := service.NewJewelryService(fac)

	// 模拟门店下单
	ring, _ := svc.Produce(domain.JewelryRing, "一生一世")
	neck, _ := svc.Produce(domain.JewelryNecklace, "富贵平安")
	brac, _ := svc.Produce(domain.JewelryBracelet, "吉祥如意")

	fmt.Println(ring.ShowInfo())
	fmt.Println(neck.ShowInfo())
	fmt.Println(brac.ShowInfo())
}