// 假如现在有如下条件
if FirstCondition {
    // 条件一
} else if SecondCondition {
    // 条件二
}

// 策略模式
func main() {
	a := 1
	b := 2
	c := 3
	var (
		conditionOne   bool = func() bool { return a == 1 }()
		conditionTwo   bool = func() bool { return b == 2 }()
		conditionThree bool = func() bool { return c == 3 }()
	)

	if conditionOne {
		fmt.Println("满足条件 1 后执行")
		if conditionTwo {
			fmt.Println("满足条件 2 后执行")
		}
	} else if conditionThree {
		fmt.Println("满足条件 3 后执行")
	} else {
		fmt.Println("都不满足后执行")
	}

	// 使用设计模式实现上述 if else 逻辑
	strategyPattern()
}

// 策略模式就是将 if else 中每个条件判断抽象为一个 对象（i.e. go 的 struct）。
// 这些 条件对象 通常要包含两个方法: 1. 判断策略是否应该执行 2. 策略执行的具体逻辑
//
// 多个 条件对象 要实现一个接口。
type Strategy interface {
	IsMatch(data *StrategyData) bool // 1. 判断策略是否应该执行。相当于 if else 中的条件判断
	Matched(data *StrategyData)      // 2. 策略执行的具体逻辑。相当于 if else 中的具体逻辑
	// ... 其他方法，比如：优先级排序、条件判断的依赖关系、策略失败时的处理、etc.
	NotMatched(data *StrategyData) // 3. 策略不执行时的处理
}

// 通常一个方法里应该包含一个策略数据的参数
type StrategyData struct {
	a int
	b int
	c int
}

// ######## 定义 条件对象 作为策略 ########
//
// 策略1
type StrategyOne struct{}

func (c *StrategyOne) IsMatch(data *StrategyData) bool {
	return data.a == 1
}
func (c *StrategyOne) Matched(data *StrategyData) {
	fmt.Println("策略模式满足条件 1 后执行")
}
func (c *StrategyOne) NotMatched(data *StrategyData) {
	fmt.Println("策略模式不满足条件 1 后执行")
}

// 策略2
type StrategyTwo struct{}

func (c *StrategyTwo) IsMatch(data *StrategyData) bool {
	return data.b == 2
}
func (c *StrategyTwo) Matched(data *StrategyData) {
	fmt.Println("策略模式满足条件 2 后执行")
}
func (c *StrategyTwo) NotMatched(data *StrategyData) {
	fmt.Println("策略模式不满足条件 2 后执行")
}

// 策略3
type StrategyThree struct{}

func (c *StrategyThree) IsMatch(data *StrategyData) bool {
	return data.c == 3
}
func (c *StrategyThree) Matched(data *StrategyData) {
	fmt.Println("策略模式满足条件 3 后执行")
}
func (c *StrategyThree) NotMatched(data *StrategyData) {
	fmt.Println("策略模式不满足条件 3 后执行")
}

// ######## 定义策略结束 ########

// 定义一个策略管理器，管理多个策略
type StrategyManager struct {
	strategies []Strategy
}

// 实例化一个策略管理器，为其添加多个策略
func NewStrategyManager() *StrategyManager {
	return &StrategyManager{
		strategies: []Strategy{
			&StrategyOne{},
			&StrategyTwo{},
			&StrategyThree{},
		},
	}
}

// Process 处理策略的逻辑。在这里遍历所有策略，找到匹配的策略并执行。就像 if-else 也要一个一个判断一样。
// 但是，如果策略很多（if else 条件很多），if else 会显得很臃肿，
// 尤其对于嵌套的 if else，策略模式会让代码看起来更清晰。这时候策略模式就会让代码看起来很优雅，可扩展性也很强。
// ！！！如果需要添加新的策略，只需要实现 Strategy 接口，并添加到 StrategyManager 中即可！！！
func (m *StrategyManager) Process(data *StrategyData) {
	for _, strategy := range m.strategies {
		if strategy.IsMatch(data) {
			strategy.Matched(data)
		} else {
			strategy.NotMatched(data)
		}
	}
}

// 使用策略模式
func strategyPattern() {
	processor := NewStrategyManager()
	processor.Process(&StrategyData{a: 1, b: 2, c: 4})
}

	if dataType.NewestDirectiveID == "" {
		level.Debug(c.logger).Log("msg", "首次获取指令，更新最新指令的 ID")
		dataType.NewestDirectiveID = result.CommandID
	} else if dataType.NewestDirectiveID != result.CommandID {
		level.Debug(c.logger).Log("msg", "发现新指令，更新最新指令的 ID")
        dataType.NewestDirectiveID = result.CommandID
        // 发送通知
    }

// 定义指令处理器接口
type DirectiveHandler interface {
    Handle(directive *DirectiveData) bool
    SetNext(handler DirectiveHandler)
}

// 基础处理器
type BaseHandler struct {
    next DirectiveHandler
}

func (h *BaseHandler) SetNext(handler DirectiveHandler) {
    h.next = handler
}

// 首次指令处理器
type FirstTimeHandler struct {
    BaseHandler
    logger log.Logger
}

func (h *FirstTimeHandler) Handle(data *DirectiveData) bool {
    if data.NewestDirectiveID == "" {
        level.Debug(h.logger).Log("msg", "首次获取指令，更新最新指令的 ID")
        data.NewestDirectiveID = data.Result.CommandID
        return true
    }
    if h.next != nil {
        return h.next.Handle(data)
    }
    return false
}

// 新指令处理器
type NewDirectiveHandler struct {
    BaseHandler
    logger log.Logger
}

func (h *NewDirectiveHandler) Handle(data *DirectiveData) bool {
    if data.NewestDirectiveID != data.Result.CommandID {
        level.Debug(h.logger).Log("msg", "发现新指令，更新最新指令的 ID")
        data.NewestDirectiveID = data.Result.CommandID
        // 发送通知
        return true
    }
    if h.next != nil {
        return h.next.Handle(data)
    }
    return false
}

// 使用示例
func (c *Client) processDirective(data *DirectiveData) {
    firstHandler := &FirstTimeHandler{logger: c.logger}
    newDirectiveHandler := &NewDirectiveHandler{logger: c.logger}
    
    firstHandler.SetNext(newDirectiveHandler)
    firstHandler.Handle(data)
}

// 规则定义
type Rule struct {
    Name      string
    Condition func(*DirectiveData) bool
    Action    func(*DirectiveData)
}

// 规则引擎
type RuleEngine struct {
    rules []Rule
}

func NewRuleEngine(logger log.Logger) *RuleEngine {
    return &RuleEngine{
        rules: []Rule{
            {
                Name: "FirstTime",
                Condition: func(data *DirectiveData) bool {
                    return data.NewestDirectiveID == ""
                },
                Action: func(data *DirectiveData) {
                    level.Debug(logger).Log("msg", "首次获取指令，更新最新指令的 ID")
                    data.NewestDirectiveID = data.Result.CommandID
                },
            },
            {
                Name: "NewDirective",
                Condition: func(data *DirectiveData) bool {
                    return data.NewestDirectiveID != data.Result.CommandID
                },
                Action: func(data *DirectiveData) {
                    level.Debug(logger).Log("msg", "发现新指令，更新最新指令的 ID")
                    data.NewestDirectiveID = data.Result.CommandID
                    // 发送通知
                },
            },
        },
    }
}

func (e *RuleEngine) Execute(data *DirectiveData) {
    for _, rule := range e.rules {
        if rule.Condition(data) {
            rule.Action(data)
            return
        }
    }
}

// 使用示例
func (c *Client) processDirective(data *DirectiveData) {
    engine := NewRuleEngine(c.logger)
    engine.Execute(data)
}