/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Abstract 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/16 21:57
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : product.go
*/
package product

// JewelryBase 所有珠宝的基础属性
type JewelryBase struct {
	Material string  // 材质
	Weight   float64 // 重量(克)
	Purity   float64 // 纯度(%)
}

// Ring 戒指产品接口
type Ring interface {
	Produce() string
	CalculateCost() float64
	QualityCheck() string
	GetInfo() JewelryBase
}

// Necklace 项链产品接口
type Necklace interface {
	Produce() string
	CalculateCost() float64
	QualityCheck() string
	GetInfo() JewelryBase
}

// Earring 耳环产品接口
type Earring interface {
	Produce() string
	CalculateCost() float64
	QualityCheck() string
	GetInfo() JewelryBase
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Abstract 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/16 21:58
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : cartier_jewelry.go
*/
package product

// CartierRing 卡地亚戒指
type CartierRing struct {
	base JewelryBase
}

func NewCartierRing() Ring {
	return &CartierRing{
		base: JewelryBase{Material: "18K金+钻石", Weight: 8, Purity: 0.75},
	}
}

func (c *CartierRing) Produce() string {
	return "18K金底座+钻石镶嵌工艺"
}
func (c *CartierRing) CalculateCost() float64 {
	return c.base.Weight*500*c.base.Purity + 2000
}
func (c *CartierRing) QualityCheck() string {
	return "18K金纯度≥75%，钻石无瑕疵，合格"
}
func (c *CartierRing) GetInfo() JewelryBase {
	return c.base
}

// CartierNecklace 卡地亚项链
type CartierNecklace struct {
	base JewelryBase
}

func NewCartierNecklace() Necklace {
	return &CartierNecklace{
		base: JewelryBase{Material: "18K金+钻石", Weight: 15, Purity: 0.75},
	}
}

func (c *CartierNecklace) Produce() string {
	return "18K金链条+钻石吊坠工艺"
}
func (c *CartierNecklace) CalculateCost() float64 {
	return c.base.Weight*500*c.base.Purity + 3000
}
func (c *CartierNecklace) QualityCheck() string {
	return "链条无变形，钻石镶嵌牢固，合格"
}
func (c *CartierNecklace) GetInfo() JewelryBase {
	return c.base
}

// CartierEarring 卡地亚耳环
type CartierEarring struct {
	base JewelryBase
}

func NewCartierEarring() Earring {
	return &CartierEarring{
		base: JewelryBase{Material: "18K金+钻石", Weight: 5, Purity: 0.75},
	}
}

func (c *CartierEarring) Produce() string {
	return "18K金耳针+钻石装饰工艺"
}
func (c *CartierEarring) CalculateCost() float64 {
	return c.base.Weight*500*c.base.Purity + 1500
}
func (c *CartierEarring) QualityCheck() string {
	return "佩戴舒适，钻石无脱落风险，合格"
}
func (c *CartierEarring) GetInfo() JewelryBase {
	return c.base
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Abstract 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/16 21:58
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : tiffany_jewelry.go
*/
package product

// TiffanyRing 蒂芙尼戒指
type TiffanyRing struct {
	base JewelryBase
}

func NewTiffanyRing() Ring {
	return &TiffanyRing{
		base: JewelryBase{Material: "铂金+蓝宝石", Weight: 7, Purity: 0.95},
	}
}

func (t *TiffanyRing) Produce() string {
	return "铂金底座+蓝宝石镶嵌工艺"
}
func (t *TiffanyRing) CalculateCost() float64 {
	return t.base.Weight*800*t.base.Purity + 2500
}
func (t *TiffanyRing) QualityCheck() string {
	return "铂金纯度≥95%，蓝宝石无裂纹，合格"
}
func (t *TiffanyRing) GetInfo() JewelryBase {
	return t.base
}

// TiffanyNecklace 蒂芙尼项链
type TiffanyNecklace struct {
	base JewelryBase
}

func NewTiffanyNecklace() Necklace {
	return &TiffanyNecklace{
		base: JewelryBase{Material: "铂金+蓝宝石", Weight: 14, Purity: 0.95},
	}
}

func (t *TiffanyNecklace) Produce() string {
	return "铂金链条+蓝宝石吊坠工艺"
}
func (t *TiffanyNecklace) CalculateCost() float64 {
	return t.base.Weight*800*t.base.Purity + 3500
}
func (t *TiffanyNecklace) QualityCheck() string {
	return "抛光达标，蓝宝石颜色均匀，合格"
}
func (t *TiffanyNecklace) GetInfo() JewelryBase {
	return t.base
}

// TiffanyEarring 蒂芙尼耳环
type TiffanyEarring struct {
	base JewelryBase
}

func NewTiffanyEarring() Earring {
	return &TiffanyEarring{
		base: JewelryBase{Material: "铂金+蓝宝石", Weight: 4, Purity: 0.95},
	}
}

func (t *TiffanyEarring) Produce() string {
	return "铂金耳针+蓝宝石装饰工艺"
}
func (t *TiffanyEarring) CalculateCost() float64 {
	return t.base.Weight*800*t.base.Purity + 1800
}
func (t *TiffanyEarring) QualityCheck() string {
	return "材质无过敏，镶嵌工艺达标，合格"
}
func (t *TiffanyEarring) GetInfo() JewelryBase {
	return t.base
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Abstract 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/16 21:57
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : factory.go
*/
package factory

import "godesginpattern/abstractfactory/product"

// JewelryFactory 抽象工厂：品牌生产线标准
type JewelryFactory interface {
	CreateRing() product.Ring
	CreateNecklace() product.Necklace
	CreateEarring() product.Earring
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Abstract 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/16 21:57
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : cartier.go
*/
package factory

import "godesginpattern/abstractfactory/product"

// CartierFactory 卡地亚具体工厂
type CartierFactory struct{}

func (c *CartierFactory) CreateRing() product.Ring {
	return product.NewCartierRing()
}

func (c *CartierFactory) CreateNecklace() product.Necklace {
	return product.NewCartierNecklace()
}

func (c *CartierFactory) CreateEarring() product.Earring {
	return product.NewCartierEarring()
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Abstract 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/16 21:57
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : tiffany.go
*/
package factory

import "godesginpattern/abstractfactory/product"

// TiffanyFactory 蒂芙尼具体工厂
type TiffanyFactory struct{}

func (t *TiffanyFactory) CreateRing() product.Ring {
	return product.NewTiffanyRing()
}

func (t *TiffanyFactory) CreateNecklace() product.Necklace {
	return product.NewTiffanyNecklace()
}

func (t *TiffanyFactory) CreateEarring() product.Earring {
	return product.NewTiffanyEarring()
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：  Abstract 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/16 21:58
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : production.go
*/
package service

import (
	"fmt"
	"godesginpattern/abstractfactory/factory"
)

// JewelryProductionLine 统一生产线：生产 → 算成本 → 质检
func JewelryProductionLine(f factory.JewelryFactory, brandName string) {
	fmt.Printf("========== %s 珠宝生产线 ==========\n", brandName)

	// 戒指
	ring := f.CreateRing()
	fmt.Printf("\n【%s戒指】\n生产：%s\n成本：%.2f 元\n质检：%s\n",
		brandName, ring.Produce(), ring.CalculateCost(), ring.QualityCheck())

	// 项链
	necklace := f.CreateNecklace()
	fmt.Printf("\n【%s项链】\n生产：%s\n成本：%.2f 元\n质检：%s\n",
		brandName, necklace.Produce(), necklace.CalculateCost(), necklace.QualityCheck())

	// 耳环
	earring := f.CreateEarring()
	fmt.Printf("\n【%s耳环】\n生产：%s\n成本：%.2f 元\n质检：%s\n",
		brandName, earring.Produce(), earring.CalculateCost(), earring.QualityCheck())

	fmt.Println("====================================\n")
}

/*
# 版权所有  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/16 22:04
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : abstractfactorybll.go
*/
package bll

import (
	"godesginpattern/abstractfactory/factory"
	"godesginpattern/abstractfactory/service"
)

// 显示示例
func AbstractFactoryMain() {
	// 卡地亚生产线
	cartierFactory := &factory.CartierFactory{}
	service.JewelryProductionLine(cartierFactory, "卡地亚")

	// 蒂芙尼生产线
	tiffanyFactory := &factory.TiffanyFactory{}
	service.JewelryProductionLine(tiffanyFactory, "蒂芙尼")
}