// 处理者接口声明了一个创建处理者链的方法。还声明了一个执行请求的方法。
interface ComponentWithContextualHelp is
    method showHelp()


// 简单组件的基础类。
abstract class Component implements ComponentWithContextualHelp is
    field tooltipText: string

    // 组件容器在处理者链中作为“下一个”链接。
    protected field container: Container

    // 如果组件设定了帮助文字，那它将会显示提示信息。如果组件没有帮助文字
    // 且其容器存在，那它会将调用传递给容器。
    method showHelp() is
        if (tooltipText != null)
            // 显示提示信息。
        else
            container.showHelp()


// 容器可以将简单组件和其他容器作为其子项目。链关系将在这里建立。该类将从
// 其父类处继承 showHelp（显示帮助）的行为。
abstract class Container extends Component is
    protected field children: array of Component

    method add(child) is
        children.add(child)
        child.container = this


// 客户端代码。
class Application is
    // 每个程序都能以不同方式对链进行配置。
    method createUI() is
        dialog = new Dialog("预算报告")
        dialog.wikiPageURL = "http://..."
        panel = new Panel(0, 0, 400, 800)
        panel.modalHelpText = "本面板用于..."
        ok = new Button(250, 760, 50, 20, "确认")
        ok.tooltipText = "这是一个确认按钮..."
        cancel = new Button(320, 760, 50, 20, "取消")
        // ...
        panel.add(ok)
        panel.add(cancel)
        dialog.add(panel)

    // 想象这里会发生什么。
    method onF1KeyPress() is
        component = this.getComponentAtMouseCoords()
        component.showHelp()

package main

import (
	"fmt"
)

//数据类
type Context struct {
	data map[string]string
}

func (c *Context) Get(str string) string {
	k, ok := c.data[str]
	if ok {
		return k
	}
	return ""
}

func (c *Context) Set(key string, value string) {
	c.data[key] = value
}

//处理者统一实现的接口
type HandlerInterface interface {
	Handle(c Context)
	SetNext(HandlerInterface)
}

//处理者1
type Reception struct {
	nextHandler HandlerInterface
}

func (r *Reception) SetNext(h HandlerInterface) {
	r.nextHandler = h
}
func (r *Reception) Handle(c Context) {
	//数据处理
	fmt.Println("data is", c.Get("need"))
	c.Set("need", "Doctor")
	fmt.Println("Reception has handle over")
	r.SetNext(&Doctor{})
	if r.nextHandler != nil {
		r.nextHandler.Handle(c)
	} else {
		fmt.Print("over")
	}

}

//处理者2
type Doctor struct {
	nextHandler HandlerInterface
}

func (r *Doctor) Handle(c Context) {

	//数据处理
	fmt.Println("data is", c.Get("need"))
	c.Set("need", "Medical")
	fmt.Println("Reception has handle over")
	r.SetNext(&Medical{})
	if r.nextHandler != nil {
		r.nextHandler.Handle(c)
	} else {
		fmt.Print("over")
	}

}
func (r *Doctor) SetNext(h HandlerInterface) {
	r.nextHandler = h
}

//处理者3
type Medical struct {
	nextHandler HandlerInterface
}

func (r *Medical) Handle(c Context) {
	//数据处理
	fmt.Println("data is", c.Get("need"))
	c.Set("need", "CheckoutCounter")
	fmt.Println("Reception has handle over")
	r.SetNext(&CheckoutCounter{})
	if r.nextHandler != nil {
		r.nextHandler.Handle(c)
	} else {
		fmt.Print("over")
	}

}
func (r *Medical) SetNext(h HandlerInterface) {
	r.nextHandler = h
}

//处理者4
type CheckoutCounter struct {
	nextHandler HandlerInterface
}

func (r *CheckoutCounter) Handle(c Context) {
	//数据处理
	fmt.Println("data is", c.Get("need"))
	c.Set("need", "CheckoutCounter")
	fmt.Println("Reception has handle over")
	if r.nextHandler != nil {
		r.nextHandler.Handle(c)
	} else {
		fmt.Print("over")
	}

}

func (r *CheckoutCounter) SetNext(h HandlerInterface) {
	r.nextHandler = h
}

func main() {
	c := Context{
		make(map[string]string),
	}
	//need -挂号看病 seeDoctor  need -复诊FollowUp  need -缴费 PayFee
	c.data["need"] = "seeDoctor"

	r := Reception{}
	r.Handle(c)

}

package main

import "fmt"

//数据
type patient struct {
	name              string
	registrationDone  bool
	doctorCheckUpDone bool
	medicineDone      bool
	paymentDone       bool
}

//接口
type department interface {
	execute(*patient)
	setNext(department)
}

//处理者1
type reception struct {
	next department
}

func (r *reception) execute(p *patient) {
	if p.registrationDone {
		fmt.Println("Patient registration already done")
		r.next.execute(p)
		return
	}
	fmt.Println("Reception registering patient")
	p.registrationDone = true
	r.next.execute(p)
}

func (r *reception) setNext(next department) {
	r.next = next
}

//处理者2
type doctor struct {
	next department
}

func (d *doctor) execute(p *patient) {
	if p.doctorCheckUpDone {
		fmt.Println("Doctor checkup already done")
		d.next.execute(p)
		return
	}
	fmt.Println("Doctor checking patient")
	p.doctorCheckUpDone = true
	d.next.execute(p)
}

func (d *doctor) setNext(next department) {
	d.next = next
}

//处理者3
type medical struct {
	next department
}

func (m *medical) execute(p *patient) {
	if p.medicineDone {
		fmt.Println("Medicine already given to patient")
		m.next.execute(p)
		return
	}
	fmt.Println("Medical giving medicine to patient")
	p.medicineDone = true
	m.next.execute(p)
}

func (m *medical) setNext(next department) {
	m.next = next
}

//处理者4
type cashier struct {
	next department
}

func (c *cashier) execute(p *patient) {
	if p.paymentDone {
		fmt.Println("Payment Done")
	}
	fmt.Println("Cashier getting money from patient patient")
}

func (c *cashier) setNext(next department) {
	c.next = next
}

func main() {

	cashier := &cashier{}

	//Set next for medical department
	medical := &medical{}
	medical.setNext(cashier)

	//Set next for doctor department
	doctor := &doctor{}
	doctor.setNext(medical)

	//Set next for reception department
	reception := &reception{}
	reception.setNext(doctor)

	patient := &patient{name: "abc"}
	//Patient visiting
	reception.execute(patient)
}