package main

import (
    "fmt"
    "time"
)

func sayHello(name string) {
    for i := 0; i < 3; i++ {
        fmt.Printf("[%s] 你好 %d\n", name, i)
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    // 使用 go 关键字启动 goroutine
    go sayHello("协程A")
    go sayHello("协程B")
    go func() {
        fmt.Println("[匿名协程] 执行")
    }()

    time.Sleep(1 * time.Second) // 等待所有 goroutine 完成
}

import "sync"

func processItems(items []int) {
    var wg sync.WaitGroup

    for _, item := range items {
        wg.Add(1) // 重要：在 goroutine 外面 Add
        go func(item int) {
            defer wg.Done()
            process(item)
        }(item) // 重要：传入参数，避免闭包陷阱
    }

    wg.Wait() // 阻塞直到所有 goroutine 完成
}

// ❌ 常见错误：循环变量捕获
for i := 0; i < 5; i++ {
    go func() {
        fmt.Println(i) // 可能全部输出 5
    }()
}

// ✅ 正确：通过参数传递
for i := 0; i < 5; i++ {
    go func(n int) {
        fmt.Println(n)
    }(i)
}

// ✅ Go 1.22+：循环变量每次迭代都是新变量
// 不再需要额外处理

// 无缓冲 Channel（同步通信）
ch := make(chan int)

// 带缓冲 Channel（异步通信）
ch := make(chan int, 10)

// 发送
ch <- 42

// 接收
value := <-ch

// 关闭 Channel
close(ch)

func producer(ch chan<- int) {
    for i := 0; i < 100; i++ {
        ch <- i
    }
    close(ch)
}

func consumer(ch <-chan int) {
    for v := range ch {
        fmt.Printf("处理: %d\n", v)
    }
    // range 会在 Channel 关闭后自动退出
}

func main() {
    ch := make(chan int, 10)
    go producer(ch)
    consumer(ch) // 在主 goroutine 中消费
}

func fanOut(input <-chan int, workers int) []<-chan int {
    channels := make([]<-chan int, workers)
    for i := 0; i < workers; i++ {
        channels[i] = worker(input)
    }
    return channels
}

func fanIn(channels ...<-chan int) <-chan int {
    var wg sync.WaitGroup
    merged := make(chan int)

    for _, ch := range channels {
        wg.Add(1)
        go func(c <-chan int) {
            defer wg.Done()
            for v := range c {
                merged <- v
            }
        }(ch)
    }

    go func() {
        wg.Wait()
        close(merged)
    }()

    return merged
}

select {
case msg := <-ch1:
    fmt.Println("从 ch1 收到:", msg)
case msg := <-ch2:
    fmt.Println("从 ch2 收到:", msg)
case <-time.After(3 * time.Second):
    fmt.Println("超时")
default:
    fmt.Println("没有就绪的 Channel")
}

func fetchWithTimeout(url string, timeout time.Duration) ([]byte, error) {
    ch := make(chan []byte, 1)
    errCh := make(chan error, 1)

    go func() {
        resp, err := http.Get(url)
        if err != nil {
            errCh <- err
            return
        }
        defer resp.Body.Close()
        body, _ := io.ReadAll(resp.Body)
        ch <- body
    }()

    select {
    case body := <-ch:
        return body, nil
    case err := <-errCh:
        return nil, err
    case <-time.After(timeout):
        return nil, fmt.Errorf("请求超时 (%v)", timeout)
    }
}

func worker(done chan<- struct{}) {
    ticker := time.NewTicker(500 * time.Millisecond)
    defer ticker.Stop()

    heartbeat := time.NewTicker(2 * time.Second)
    defer heartbeat.Stop()

    for {
        select {
        case <-ticker.C:
            // 执行工作
            doWork()
        case <-heartbeat.C:
            // 发送心跳
            reportHealth()
        case <-done:
            // 收到停止信号
            return
        }
    }
}

select {
case ch <- value:
    fmt.Println("发送成功")
default:
    fmt.Println("Channel 已满，丢弃")
}

func fetchUserData(ctx context.Context, userID string) (*User, error) {
    // 创建子 context，5 秒超时
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()

    // 传递 context 给下游调用
    userCh := make(chan *User, 1)
    errCh := make(chan error, 1)

    go func() {
        user, err := db.QueryUser(ctx, userID)
        if err != nil {
            errCh <- err
            return
        }
        userCh <- user
    }()

    select {
    case user := <-userCh:
        return user, nil
    case err := <-errCh:
        return nil, err
    case <-ctx.Done():
        return nil, ctx.Err() // context.Canceled 或 context.DeadlineExceeded
    }
}

func crawl(startURL string, maxDepth int) []string {
    visited := &sync.Map{}
    results := make(chan string, 100)
    var wg sync.WaitGroup

    var crawlFunc func(url string, depth int)
    crawlFunc = func(url string, depth int) {
        defer wg.Done()
        if depth > maxDepth {
            return
        }
        if _, loaded := visited.LoadOrStore(url, true); loaded {
            return // 已访问
        }

        links, err := fetchLinks(url)
        if err != nil {
            return
        }
        results <- url

        for _, link := range links {
            wg.Add(1)
            go crawlFunc(link, depth+1)
        }
    }

    wg.Add(1)
    go crawlFunc(startURL, 0)

    // 等待完成后关闭 results
    go func() {
        wg.Wait()
        close(results)
    }()

    // 收集结果
    var urls []string
    for url := range results {
        urls = append(urls, url)
    }
    return urls
}