package main

import (
        "fmt"
        "sync"
)

// Observer 接口定义了观察者需要实现的 Update 方法
type Observer interface {
        Update(message string)
}

// Subject 接口定义了主题需要实现的方法
type Subject interface {
        Attach(observer Observer)
        Detach(observer Observer)
        Notify(message string)
}

// ConcreteSubject 具体主题的实现
type ConcreteSubject struct {
        observers []Observer
        mu        sync.Mutex // 用于并发安全
}

func (s *ConcreteSubject) Attach(observer Observer) {
        s.mu.Lock()
        defer s.mu.Unlock()
        s.observers = append(s.observers, observer)
}

func (s *ConcreteSubject) Detach(observer Observer) {
        s.mu.Lock()
        defer s.mu.Unlock()
        for i, o := range s.observers {
                if o == observer {
                        s.observers = append(s.observers[:i], s.observers[i+1:]...)
                        break
                }
        }
}

func (s *ConcreteSubject) Notify(message string) {
        s.mu.Lock()
        defer s.mu.Unlock()
        for _, observer := range s.observers {
                // 使用Goroutine异步通知
                go observer.Update(message)
        }
}

// ConcreteObserver 具体观察者的实现
type ConcreteObserver struct {
        id int
}

func (o *ConcreteObserver) Update(message string) {
        fmt.Printf("Observer %d received message: %s\n", o.id, message)
}

func main() {
        subject := &ConcreteSubject{}

        observer1 := &ConcreteObserver{id: 1}
        observer2 := &ConcreteObserver{id: 2}

        subject.Attach(observer1)
        subject.Attach(observer2)

        // 使用channel来传递消息
        messages := make(chan string)

        // 启动一个goroutine来模拟消息发送
        go func() {
                messages <- "Hello, Observers!"
                close(messages)
        }()

        // 从channel接收消息并通知观察者
        go func() {
                for message := range messages {
                        subject.Notify(message)
                }
        }()

        // 等待所有消息处理完成
        // 这里仅为示例，实际应用中可能需要更复杂的同步机制
        select {}
}