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

import "fmt"

// Jeweler 珠宝工匠（接收者）：职责单一，只实现首饰加工逻辑
type Jeweler struct {
	name string
}

func NewJeweler(name string) *Jeweler {
	return &Jeweler{name: name}
}

// ========== 具体业务操作 ==========
func (j *Jeweler) PolishRing() error {
	fmt.Printf("[%s] 执行：戒指抛光完成 ✨\n", j.name)
	return nil
}

func (j *Jeweler) InlayDiamond() error {
	fmt.Printf("[%s] 执行：钻石镶嵌完成 💎\n", j.name)
	return nil
}

func (j *Jeweler) CleanNecklace() error {
	fmt.Printf("[%s] 执行：项链清洗完成 🧼\n", j.name)
	return nil
}

// ========== 撤销操作 ==========
func (j *Jeweler) UndoPolishRing() error {
	fmt.Printf("[%s] 撤销：戒指抛光已回滚 ❌\n", j.name)
	return nil
}

func (j *Jeweler) UndoInlayDiamond() error {
	fmt.Printf("[%s] 撤销：钻石镶嵌已回滚 ❌\n", j.name)
	return nil
}

func (j *Jeweler) UndoCleanNecklace() error {
	fmt.Printf("[%s] 撤销：项链清洗已回滚 ❌\n", j.name)
	return nil
}

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

import (
	"errors"
	"godesginpattern/command/command"
)

// Workbench 工作台（调用者）：职责单一，仅负责执行/撤销/记录命令
type Workbench struct {
	commandHistory []command.Command // 命令历史（可扩展存入DB）
}

func NewWorkbench() *Workbench {
	return &Workbench{
		commandHistory: make([]command.Command, 0),
	}
}

// ExecuteCommand 执行命令
func (w *Workbench) ExecuteCommand(cmd command.Command) error {
	if cmd == nil {
		return errors.New("命令不能为空")
	}

	// 执行命令
	if err := cmd.Execute(); err != nil {
		return err
	}

	// 记录历史
	w.commandHistory = append(w.commandHistory, cmd)
	return nil
}

// UndoLastCommand 撤销上一个命令
func (w *Workbench) UndoLastCommand() error {
	if len(w.commandHistory) == 0 {
		return errors.New("无操作可撤销")
	}

	// 取出最后一条命令
	lastIdx := len(w.commandHistory) - 1
	lastCmd := w.commandHistory[lastIdx]

	// 撤销
	if err := lastCmd.Undo(); err != nil {
		return err
	}

	// 移除历史
	w.commandHistory = w.commandHistory[:lastIdx]
	return nil
}

// GetHistory 获取命令历史（用于日志、审计）
func (w *Workbench) GetHistory() []command.Command {
	return w.commandHistory
}

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

import "godesginpattern/command/receiver"

type CleanNecklaceCommand struct {
	jeweler *receiver.Jeweler
}

func NewCleanNecklaceCommand(j *receiver.Jeweler) *CleanNecklaceCommand {
	return &CleanNecklaceCommand{jeweler: j}
}

func (c *CleanNecklaceCommand) Execute() error {
	return c.jeweler.CleanNecklace()
}

func (c *CleanNecklaceCommand) Undo() error {
	return c.jeweler.UndoCleanNecklace()
}

func (c *CleanNecklaceCommand) Name() string {
	return "CleanNecklaceCommand"
}


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

// Command 命令接口（抽象层）：企业级必须定义标准契约
type Command interface {
	Execute() error
	Undo() error
	Name() string // 用于日志、追踪、可观测性
}


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

import "godesginpattern/command/receiver"

type InlayDiamondCommand struct {
	jeweler *receiver.Jeweler
}

func NewInlayDiamondCommand(j *receiver.Jeweler) *InlayDiamondCommand {
	return &InlayDiamondCommand{jeweler: j}
}

func (i *InlayDiamondCommand) Execute() error {
	return i.jeweler.InlayDiamond()
}

func (i *InlayDiamondCommand) Undo() error {
	return i.jeweler.UndoInlayDiamond()
}

func (i *InlayDiamondCommand) Name() string {
	return "InlayDiamondCommand"
}


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

import "godesginpattern/command/receiver"

// PolishRingCommand 抛光戒指命令
type PolishRingCommand struct {
	jeweler *receiver.Jeweler
}

func NewPolishRingCommand(j *receiver.Jeweler) *PolishRingCommand {
	return &PolishRingCommand{jeweler: j}
}

func (p *PolishRingCommand) Execute() error {
	return p.jeweler.PolishRing()
}

func (p *PolishRingCommand) Undo() error {
	return p.jeweler.UndoPolishRing()
}

func (p *PolishRingCommand) Name() string {
	return "PolishRingCommand"
}

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

import (
	"fmt"
	"godesginpattern/command/command"
	"godesginpattern/command/invoker"
)

// JewelryService 业务服务：职责单一，编排业务流程
type JewelryService struct {
	workbench *invoker.Workbench
	polishCmd command.Command
	inlayCmd  command.Command
	cleanCmd  command.Command
}

func NewJewelryService(
	workbench *invoker.Workbench,
	polishCmd command.Command,
	inlayCmd command.Command,
	cleanCmd command.Command,
) *JewelryService {
	return &JewelryService{
		workbench: workbench,
		polishCmd: polishCmd,
		inlayCmd:  inlayCmd,
		cleanCmd:  cleanCmd,
	}
}

// RunBusinessFlow 执行完整业务流程
func (s *JewelryService) RunBusinessFlow() {
	fmt.Println("========== 企业级珠宝加工系统启动 ==========\n")

	// 执行命令
	_ = s.workbench.ExecuteCommand(s.polishCmd)
	_ = s.workbench.ExecuteCommand(s.inlayCmd)
	_ = s.workbench.ExecuteCommand(s.cleanCmd)

	fmt.Println("\n========== 开始撤销操作 ==========")
	_ = s.workbench.UndoLastCommand()
	_ = s.workbench.UndoLastCommand()
	_ = s.workbench.UndoLastCommand()
	_ = s.workbench.UndoLastCommand()
}

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

Command/
├── cmd/                  # 启动入口
│   └── main.go           # 程序主入口
├── internal/             # 内部业务包（对外不可暴露）
│   ├── receiver/         # 接收者：真正执行业务（工匠）
│   │   └── jeweler.go
│   ├── command/          # 命令层：抽象命令 + 具体命令
│   │   ├── command.go    # 命令接口
│   │   ├── polish.go     # 抛光命令
│   │   ├── inlay.go      # 镶嵌命令
│   │   └── clean.go      # 清洗命令
│   ├── invoker/          # 调用者：工作台/命令执行器
│   │   └── workbench.go
│   └── service/          # 业务服务层（可选，复杂业务使用）
│       └── jewelry_service.go
├── go.mod                # Go 模块
└── go.sum
*/
package bll

import (
	"godesginpattern/command/command"
	"godesginpattern/command/invoker"
	"godesginpattern/command/receiver"
	"godesginpattern/command/service"
)

func CommandMain() {
	// 1. 创建接收者（工匠）
	jeweler := receiver.NewJeweler("首席工匠 - 张师傅")

	// 2. 创建命令（依赖注入接收者）
	polishCmd := command.NewPolishRingCommand(jeweler)
	inlayCmd := command.NewInlayDiamondCommand(jeweler)
	cleanCmd := command.NewCleanNecklaceCommand(jeweler)

	// 3. 创建调用者（工作台）
	workbench := invoker.NewWorkbench()

	// 4. 创建业务服务（组装依赖）
	appService := service.NewJewelryService(workbench, polishCmd, inlayCmd, cleanCmd)

	// 5. 执行业务流程
	appService.RunBusinessFlow()
}