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

// 维修类型常量（严格定义业务等级）
const (
	RepairTypeSimple  = "简单维修" // 初级技师
	RepairTypeComplex = "复杂维修" // 高级技师
	RepairTypeMajor   = "重大维修" // 维修主管
)

// RepairRequest 维修请求实体（企业级标准：字段完整、不可变）
type RepairRequest struct {
	CustomerName string // 客户姓名
	RepairType   string // 维修类型
	Content      string // 维修详情
}

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

import "godesginpattern/chain/domain"

// RepairHandler 责任链核心接口（企业级标准：契约定义）
type RepairHandler interface {
	SetNext(handler RepairHandler) RepairHandler
	HandleRequest(req *domain.RepairRequest) bool
}

// BaseRepairHandler 基础处理者（封装Next指针，所有处理者继承）
type BaseRepairHandler struct {
	next RepairHandler
}

// SetNext 链式设置下一级处理者
func (b *BaseRepairHandler) SetNext(handler RepairHandler) RepairHandler {
	b.next = handler
	return handler
}

// nextHandle 公共方法：传递给下一级处理
func (b *BaseRepairHandler) nextHandle(req *domain.RepairRequest) bool {
	if b.next != nil {
		return b.next.HandleRequest(req)
	}
	return false
}



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

import (
	"fmt"
	"godesginpattern/chain/domain"
)

// JuniorTechnician 初级珠宝技师：仅处理简单维修
type JuniorTechnician struct {
	BaseRepairHandler
}

func (j *JuniorTechnician) HandleRequest(req *domain.RepairRequest) bool {
	if req.RepairType == domain.RepairTypeSimple {
		fmt.Printf("【初级技师】处理客户%s的请求：%s（维修内容：%s）✅\n",
			req.CustomerName, req.RepairType, req.Content)
		return true
	}
	// 无法处理，交给下一级
	return j.nextHandle(req)
}


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

import (
	"fmt"
	"godesginpattern/chain/domain"
)

// SeniorTechnician 高级珠宝技师：仅处理复杂维修
type SeniorTechnician struct {
	BaseRepairHandler
}

func (s *SeniorTechnician) HandleRequest(req *domain.RepairRequest) bool {
	if req.RepairType == domain.RepairTypeComplex {
		fmt.Printf("【高级技师】处理客户%s的请求：%s（维修内容：%s）✅\n",
			req.CustomerName, req.RepairType, req.Content)
		return true
	}
	return s.nextHandle(req)
}


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

import (
	"fmt"
	"godesginpattern/chain/domain"
)

// RepairSupervisor 维修主管：仅处理重大维修
type RepairSupervisor struct {
	BaseRepairHandler
}

func (r *RepairSupervisor) HandleRequest(req *domain.RepairRequest) bool {
	if req.RepairType == domain.RepairTypeMajor {
		fmt.Printf("【维修主管】处理客户%s的请求：%s（维修内容：%s）✅\n",
			req.CustomerName, req.RepairType, req.Content)
		return true
	}
	return r.nextHandle(req)
}

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

import (
	"fmt"
	"godesginpattern/chain/domain"
	"godesginpattern/chain/handler"
)

// RepairService 维修服务（企业级：对外唯一入口）
type RepairService struct {
	chainHandler handler.RepairHandler // 责任链入口
}

// NewRepairService 创建服务（初始化责任链）
func NewRepairService() *RepairService {
	// 1. 创建处理者
	junior := &handler.JuniorTechnician{}
	senior := &handler.SeniorTechnician{}
	supervisor := &handler.RepairSupervisor{}

	// 2. 构建标准责任链：初级 → 高级 → 主管
	junior.SetNext(senior).SetNext(supervisor)

	return &RepairService{
		chainHandler: junior,
	}
}

// SubmitRepair 提交维修请求（对外服务方法）
func (s *RepairService) SubmitRepair(req *domain.RepairRequest) {
	fmt.Println("===== 客户提交维修请求 =====")
	success := s.chainHandler.HandleRequest(req)
	if !success {
		fmt.Printf("❌ 无法处理客户%s的请求：%s（维修内容：%s）\n",
			req.CustomerName, req.RepairType, req.Content)
	}
	fmt.Println()
}　

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

Chain/
├── domain/          # 领域实体层（核心数据模型）
│   └── repair.go    # 维修请求实体、常量定义
├── handler/         # 责任链处理层（接口+实现）
│   ├── base.go      # 基础处理者（公共逻辑）
│   ├── junior.go    # 初级技师
│   ├── senior.go    # 高级技师
│   └── supervisor.go# 维修主管
├── service/         # 业务服务层（责任链构建+调度）
│   └── repair_service.go
├── go.mod           # Go 模块文件
└── main.go          # 程序入口（测试用例）
*/
package bll

import (
	"godesginpattern/chain/domain"
	"godesginpattern/chain/service"
)

func ChainMain() {
	// 初始化维修服务
	repairService := service.NewRepairService()

	// 测试1：简单维修
	req1 := &domain.RepairRequest{
		CustomerName: "张先生",
		RepairType:   domain.RepairTypeSimple,
		Content:      "戒指清洗+抛光",
	}
	repairService.SubmitRepair(req1)

	// 测试2：复杂维修
	req2 := &domain.RepairRequest{
		CustomerName: "李女士",
		RepairType:   domain.RepairTypeComplex,
		Content:      "项链宝石松动加固",
	}
	repairService.SubmitRepair(req2)

	// 测试3：重大维修
	req3 := &domain.RepairRequest{
		CustomerName: "王先生",
		RepairType:   domain.RepairTypeMajor,
		Content:      "钻戒主石更换+戒托重构",
	}
	repairService.SubmitRepair(req3)

	// 测试4：无法处理的请求
	req4 := &domain.RepairRequest{
		CustomerName: "陈女士",
		RepairType:   "古董珠宝修复",
		Content:      "百年翡翠手镯断裂拼接",
	}
	repairService.SubmitRepair(req4)
}