package main

import "fmt"

func main() {
    s := []byte{'g', 'o', 'l', 'a', 'n', 'g'}

    // Go 1.20: Direct conversion from slice to array
    var a4 [4]byte = [4]byte(s) // a4 will be {'g', 'o', 'l', 'a'}
    fmt.Printf("Array a4: %v\n", a4)
    fmt.Printf("Array a4 as string: %s\n", string(a4[:]))

    var a6 [6]byte = [6]byte(s) // a6 will be {'g', 'o', 'l', 'a', 'n', 'g'}
    fmt.Printf("Array a6: %v\n", a6)
    fmt.Printf("Array a6 as string: %s\n", string(a6[:]))

    // Contrast with Go 1.17 style (slice to array pointer)
    ap4 := (*[4]byte)(s) // ap4 is a pointer to the first 4 bytes of s's underlying array
    fmt.Printf("Array pointer ap4: %v\n", *ap4)
    // Modify the array through the pointer - this affects the original slice's underlying data!
    ap4[0] = 'G'
    fmt.Printf("Original slice s after modifying via pointer: %s\n", string(s)) // Output: Golang

    // Note: Direct conversion creates a *copy* of the data
    a4_copy := [4]byte(s)
    a4_copy[0] = 'F' // Modify the copy
    fmt.Printf("Original slice s after modifying direct conversion copy: %s\n", string(s)) // Output: Golang (unaffected)
    fmt.Printf("Copied array a4_copy: %s\n", string(a4_copy[:]))                     // Output: Fola

    // Example that would panic at runtime
    shortSlice := []byte{'h', 'i'}
    var a3 [3]byte = [3]byte(shortSlice) // This line would cause a panic: runtime error
    _ = a3
    _ = shortSlice // Avoid unused variable error
}

Array a4: [103 111 108 97]
Array a4 as string: gola
Array a6: [103 111 108 97 110 103]
Array a6 as string: golang
Array pointer ap4: [103 111 108 97]
Original slice s after modifying via pointer: Golang
Original slice s after modifying direct conversion copy: Golang
Copied array a4_copy: Fola
panic: runtime error: cannot convert slice with length 2 to array or pointer to array with length 3

package main

import "fmt"

type Data struct {
    ID   int
    Meta interface{} // interface{} or any
}

func main() {
    // Slices are not comparable
    slice1 := []int{1}
    slice2 := []int{1}

    d1 := Data{ID: 1, Meta: slice1}
    d2 := Data{ID: 2, Meta: slice2} // Different ID
    d3 := Data{ID: 1, Meta: slice2} // Same ID, different slice instance (but content might be same)
    d4 := Data{ID: 1, Meta: slice1} // Same ID, same slice instance

    // Comparison stops at the first differing field (ID)
    // The Meta field (interface{} holding a slice) is never compared.
    fmt.Printf("d1 == d2: %t\n", d1 == d2) // Output: false. Comparison stops after comparing ID (1 != 2). No panic.

    // Comparison proceeds to Meta field because IDs are equal (1 == 1).
    // Comparing interfaces containing slices will cause a panic.
    // fmt.Printf("d1 == d3: %t\n", d1 == d3) // This line would panic: runtime error: comparing uncomparable type []int

    // Comparison proceeds to Meta field.
    // Even though it's the *same* slice instance, the comparison itself panics.
    // fmt.Printf("d1 == d4: %t\n", d1 == d4) // This line would also panic: runtime error: comparing uncomparable type []int

    // Array comparison example
    type Info struct {
        Count int
    }
    // Arrays of comparable types are comparable
    a1 := [2]Info{{Count: 1}, {Count: 2}}
    a2 := [2]Info{{Count: 1}, {Count: 3}} // Differs at index 1
    a3 := [2]Info{{Count: 0}, {Count: 2}} // Differs at index 0

    fmt.Printf("a1 == a2: %t\n", a1 == a2) // Output: false. Stops after comparing a1[1] and a2[1].
    fmt.Printf("a1 == a3: %t\n", a1 == a3) // Output: false. Stops after comparing a1[0] and a3[0].

    _, _, _, _ = d1, d2, d3, d4
}

package main

import "fmt"

// Generic map using comparable constraint for the key
type GenericMap[K comparable, V any] struct {
    m map[K]V
}

func NewGenericMap[K comparable, V any]() *GenericMap[K, V] {
    return &GenericMap[K, V]{m: make(map[K]V)}
}

func (gm *GenericMap[K, V]) Put(key K, value V) {
    gm.m[key] = value
}

func (gm *GenericMap[K, V]) Get(key K) (V, bool) {
    v, ok := gm.m[key]
    return v, ok
}

func main() {
    // Instantiate GenericMap with K=int (strictly comparable) - Works always
    intMap := NewGenericMap[int, string]()
    intMap.Put(1, "one")
    fmt.Println(intMap.Get(1)) // Output: one true

    // Instantiate GenericMap with K=any (interface{}) - Works in Go 1.20+
    // In Go 1.18/1.19, this would fail compilation because 'any'/'interface{}'
    // did not satisfy the 'comparable' constraint.
    anyMap := NewGenericMap[any, string]()

    // Use comparable types as keys - Works fine
    anyMap.Put(10, "integer")
    anyMap.Put("hello", "string")
    type MyStruct struct{ V int }
    anyMap.Put(MyStruct{V: 5}, "struct")

    fmt.Println(anyMap.Get(10))      // Output: integer true
    fmt.Println(anyMap.Get("hello")) // Output: string true
    fmt.Println(anyMap.Get(MyStruct{V: 5})) // Output: struct true

    // Attempt to use an uncomparable type (slice) as a key.
    // The Put operation itself will cause a panic during the map key comparison.
    keySlice := []int{1, 2}
    fmt.Println("Attempting to put slice key...")
    // The following line will panic in Go 1.20+
    // panic: runtime error: hash of unhashable type []int
    // or panic: runtime error: comparing uncomparable type []int
    // (depending on map implementation details)
    // anyMap.Put(keySlice, "slice")
    _ = keySlice // Avoid unused variable

    // Using interface values holding different uncomparable types also panics
    var i1 any = []int{1}
    var i2 any = map[string]int{}
    // The comparison i1 == i2 during map access would panic.
    // anyMap.Put(i1, "interface holding slice")
    // anyMap.Put(i2, "interface holding map")
    _ = i1
    _ = i2
}

package main

import (
    "errors"
    "fmt"
    "os"
    "time"
    "syscall"
)

// 定義一些具體的錯誤類型
var ErrDatabaseTimeout = errors.New("database timeout")
var ErrCacheFailed = errors.New("cache operation failed")
var ErrFileSystemReadOnly = errors.New("file system is read-only")

type NetworkError struct {
    Op  string
    Err error // Underlying network error
}

func (e *NetworkError) Error() string {
    return fmt.Sprintf("network error during %s: %v", e.Op, e.Err)
}

func (e *NetworkError) Unwrap() error {
    return e.Err // Implements single error unwrapping
}

// 模擬保存數(shù)據(jù)的操作，可能同時涉及多個系統(tǒng)
func saveData(data string) error {
    var errs []error // 用于收集所有發(fā)生的錯誤

    // 模擬數(shù)據(jù)庫操作
    if time.Now().Second()%2 == 0 { // 假設(shè)偶數(shù)秒時數(shù)據(jù)庫超時
        errs = append(errs, ErrDatabaseTimeout)
    }

    // 模擬緩存操作
    if len(data) < 5 { // 假設(shè)數(shù)據(jù)太短時緩存失敗
        // 包裝一個更具體的網(wǎng)絡(luò)錯誤
        netErr := &NetworkError{Op: "set cache", Err: errors.New("connection refused")}
        errs = append(errs, fmt.Errorf("%w: %w", ErrCacheFailed, netErr)) // 使用 %w 包裝原始錯誤和網(wǎng)絡(luò)錯誤
    }

    // 模擬文件系統(tǒng)操作
    if _, err := os.OpenFile("dummy.txt", os.O_WRONLY, 0666); err != nil {
        // 檢查是否是只讀文件系統(tǒng)錯誤（僅為示例，實際檢查更復(fù)雜）
        if os.IsPermission(err) { // os.IsPermission is a common check
            errs = append(errs, ErrFileSystemReadOnly)
        } else {
            errs = append(errs, fmt.Errorf("failed to open file: %w", err)) // 包裝底層 os 錯誤
        }
    }

    // 使用 errors.Join 將所有收集到的錯誤合并成一個
    // 如果 errs 為空 (即沒有錯誤發(fā)生), errors.Join 會返回 nil
    return errors.Join(errs...)
}

func main() {
    err := saveData("dat") // "dat" is short, likely triggers cache error
    if err != nil {
        fmt.Printf("Failed to save data:\n%v\n\n", err) // errors.Join 產(chǎn)生的錯誤會自動格式化，顯示所有子錯誤

        // 現(xiàn)在我們可以檢查這個聚合錯誤中是否包含特定的錯誤類型或值

        // 檢查是否包含數(shù)據(jù)庫超時錯誤
        if errors.Is(err, ErrDatabaseTimeout) {
            // errors.Is 會遍歷 err 解包出來的所有錯誤（通過 errors.Join 的 Unwrap() []error）
            // 如果找到 ErrDatabaseTimeout，則返回 true
            fmt.Println("Detected: Database Timeout")
        }

        // 檢查是否包含文件系統(tǒng)只讀錯誤
        if errors.Is(err, ErrFileSystemReadOnly) {
            // 同樣，errors.Is 會檢查所有被 Join 的錯誤
            fmt.Println("Detected: File System Read-Only")
        }

        // 提取具體的 NetworkError 類型
        var netErr *NetworkError
        if errors.As(err, &netErr) {
            // errors.As 會遍歷 err 解包出來的所有錯誤
            // 如果找到一個類型為 *NetworkError 的錯誤，就將其賦值給 netErr 并返回 true
            fmt.Printf("Detected Network Error: Op=%s, Underlying=%v\n", netErr.Op, netErr.Err)
            // 我們甚至可以進(jìn)一步檢查 NetworkError 內(nèi)部包裝的錯誤
            if errors.Is(netErr, syscall.ECONNREFUSED) { // 假設(shè)底層是 connection refused
                fmt.Println("   Network error specifically was: connection refused")
            }
        }

        // 也可以檢查原始的 Cache 失敗錯誤
        if errors.Is(err, ErrCacheFailed) {
            // 這會找到 fmt.Errorf("%w: %w", ErrCacheFailed, netErr) 中包裝的 ErrCacheFailed
            fmt.Println("Detected: Cache Failed (may have underlying network error)")
        }
    } else {
        fmt.Println("Data saved successfully!")
    }

    // 演示 fmt.Errorf 與多個 %w
    err1 := errors.New("error one")
    err2 := errors.New("error two")
    multiWError := fmt.Errorf("operation failed: %w; also %w", err1, err2)
    fmt.Printf("\nError from multiple %%w:\n%v\n", multiWError)
    if errors.Is(multiWError, err1) && errors.Is(multiWError, err2) {
        // multiWError 實現(xiàn) Unwrap() []error，包含 err1 和 err2
        fmt.Println("Multiple %w error contains both err1 and err2.")
    }
}

Failed to save data:
database timeout
cache operation failed: network error during set cache: connection refused
failed to open file: open dummy.txt: no such file or directory

Detected: Database Timeout
Detected Network Error: Op=set cache, Underlying=connection refused
Detected: Cache Failed (may have underlying network error)

Error from multiple %w:
operation failed: error one; also error two
Multiple %w error contains both err1 and err2.

package main

import (
    "fmt"
    "io"
    "net/http"
    "time"
)

// 模擬一個需要發(fā)送大量數(shù)據(jù)的 handler
func bigDataHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Println("Handling request for big data...")

    // 獲取與 ResponseWriter 關(guān)聯(lián)的 ResponseController
    rc := http.NewResponseController(w)

    // 假設(shè)我們要發(fā)送大量數(shù)據(jù)，可能超過服務(wù)器的默認(rèn) WriteTimeout
    // 我們可以為這個特定的請求禁用寫入超時
    // 將截止時間設(shè)置為空的 time.Time (零值) 即可禁用
    err := rc.SetWriteDeadline(time.Time{})
    if err != nil {
        // 如果設(shè)置截止時間失敗 (例如，底層連接不支持或已關(guān)閉)
        // 記錄錯誤并可能返回一個內(nèi)部服務(wù)器錯誤
        fmt.Printf("Error setting write deadline: %v\n", err)
        http.Error(w, "Failed to set write deadline", http.StatusInternalServerError)
        return
    }
    fmt.Println("Write deadline disabled for this request.")

    // 設(shè)置響應(yīng)頭
    w.Header().Set("Content-Type", "text/plain")
    w.WriteHeader(http.StatusOK)

    // 模擬發(fā)送大量數(shù)據(jù)
    for i := 0; i < 10; i++ {
        _, err := io.WriteString(w, fmt.Sprintf("This is line %d of a large response.\n", i+1))
        if err != nil {
            // 如果寫入過程中發(fā)生錯誤 (例如，連接被客戶端關(guān)閉)
            fmt.Printf("Error writing response data: %v\n", err)
            // 此時可能無法再向客戶端發(fā)送錯誤，但應(yīng)記錄日志
            return
        }
        // 模擬耗時操作
        time.Sleep(200 * time.Millisecond)
    }

    fmt.Println("Finished sending big data.")
}

// 模擬一個需要從客戶端讀取可能很慢的數(shù)據(jù)流的 handler
func slowUploadHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Println("Handling slow upload...")

    // 獲取 ResponseController (雖然這里主要控制讀取，但通過 ResponseWriter 獲取)
    rc := http.NewResponseController(w)

    // 假設(shè)服務(wù)器有 ReadTimeout，但我們預(yù)期這個上傳可能很慢
    // 我們可以延長讀取截止時間，比如設(shè)置為 1 分鐘后
    deadline := time.Now().Add(1 * time.Minute)
    err := rc.SetReadDeadline(deadline)
    if err != nil {
        fmt.Printf("Error setting read deadline: %v\n", err)
        http.Error(w, "Failed to set read deadline", http.StatusInternalServerError)
        return
    }
    fmt.Printf("Read deadline set to %v for this request.\n", deadline)

    // 現(xiàn)在可以安全地從 r.Body 讀取，直到截止時間
    bodyBytes, err := io.ReadAll(r.Body)
    if err != nil {
        // 檢查是否是超時錯誤
        if netErr, ok := err.(interface{ Timeout() bool }); ok && netErr.Timeout() {
            fmt.Println("Read timed out as expected.")
            http.Error(w, "Read timed out", http.StatusRequestTimeout)
        } else {
            fmt.Printf("Error reading request body: %v\n", err)
            http.Error(w, "Error reading body", http.StatusInternalServerError)
        }
        return
    }

    fmt.Printf("Received %d bytes.\n", len(bodyBytes))
    fmt.Fprintln(w, "Upload received successfully!")
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/bigdata", bigDataHandler)
    mux.HandleFunc("/upload", slowUploadHandler)

    // 創(chuàng)建一個帶有默認(rèn)超時的服務(wù)器 (例如 5 秒)
    server := &http.Server{
        Addr:         ":8080",
        Handler:      mux,
        ReadTimeout:  5 * time.Second, // 默認(rèn)讀取超時
        WriteTimeout: 5 * time.Second, // 默認(rèn)寫入超時
    }

    fmt.Println("Server starting on :8080...")
    fmt.Println("Try visiting http://localhost:8080/bigdata")
    fmt.Println("Try sending a POST request with a slow body to http://localhost:8080/upload")
    fmt.Println("Example using curl for slow upload:")
    fmt.Println(`  curl -X POST --data-binary @- http://localhost:8080/upload <<EOF`)
    fmt.Println(`  This is some data that will be sent slowly.`)
    fmt.Println(`  <You might need to wait or pipe slow input here>`)
    fmt.Println(`  EOF`)

    err := server.ListenAndServe()
    if err != nil && err != http.ErrServerClosed {
        fmt.Printf("Server error: %v\n", err)
    }
}

// 注意: SetReadDeadline/SetWriteDeadline 通常作用于底層的 net.Conn。
// 對于 HTTP/2，行為可能更復(fù)雜，因為一個連接上有多路復(fù)用的流。
// 對于 HTTP/3 (QUIC)，這些可能不適用或有不同的機制。
// 查閱具體 Go 版本的 net/http 文檔了解詳細(xì)語義。

package main

import (
    "log"
    "net/http"
    "net/http/httputil"
    "net/url"
    "os"
)

func main() {
    // 后端服務(wù)器的 URL
    backendURL, err := url.Parse("http://localhost:8081") // 假設(shè)后端服務(wù)運行在 8081 端口
    if err != nil {
        log.Fatal("Invalid backend URL")
    }

    // 創(chuàng)建一個簡單的后端服務(wù)器用于測試
    go startBackendServer()

    // 創(chuàng)建 ReverseProxy 并設(shè)置 Rewrite 鉤子
    proxy := &httputil.ReverseProxy{
        Rewrite: func(r *httputil.ProxyRequest) {
            // 1. 將出站請求的目標(biāo)設(shè)置為后端 URL
            // SetURL 會同時設(shè)置 r.Out.URL 和 r.Out.Host，并設(shè)置 Host header
            r.SetURL(backendURL)

            // 2. (可選) 如果需要 X-Forwarded-* 頭部，必須顯式調(diào)用 SetXForwarded
            // 如果不調(diào)用，這些頭部將不會被添加到出站請求中
            r.SetXForwarded()

            // 3. (可選) 添加或修改其他出站請求頭部
            r.Out.Header.Set("X-My-Proxy-Header", "Hello from proxy")

            // 4. (可選) 可以基于入站請求 r.In 進(jìn)行決策
            log.Printf("Rewriting request: In=%s %s, Out=%s %s",
                r.In.Method, r.In.URL.Path,
                r.Out.Method, r.Out.URL.String()) // 注意 r.Out.URL 已經(jīng)被 SetURL 修改

            // 注意：不需要再手動設(shè)置 r.Out.Host 或 Host header，SetURL 已處理
            // 注意：默認(rèn)情況下，ReverseProxy 會處理 hop-by-hop headers，這里無需手動處理
        },
        // 如果需要自定義錯誤處理
        ErrorHandler: func(rw http.ResponseWriter, req *http.Request, err error) {
            log.Printf("Proxy error: %v", err)
            http.Error(rw, "Proxy Error", http.StatusBadGateway)
        },
    }

    // 設(shè)置 Director 為 nil，因為我們使用了 Rewrite
    // proxy.Director = nil // 這行不是必需的，因為設(shè)置 Rewrite 優(yōu)先

    // 啟動代理服務(wù)器
    log.Println("Starting reverse proxy on :8080, forwarding to", backendURL)
    if err := http.ListenAndServe(":8080", proxy); err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

// 簡單的后端 HTTP 服務(wù)器
func startBackendServer() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Printf("[Backend] Received request: %s %s", r.Method, r.URL.String())
        log.Printf("[Backend] Host header: %s", r.Host)
        log.Printf("[Backend] X-Forwarded-For: %s", r.Header.Get("X-Forwarded-For"))
        log.Printf("[Backend] X-Forwarded-Host: %s", r.Header.Get("X-Forwarded-Host"))
        log.Printf("[Backend] X-Forwarded-Proto: %s", r.Header.Get("X-Forwarded-Proto"))
        log.Printf("[Backend] X-My-Proxy-Header: %s", r.Header.Get("X-My-Proxy-Header"))
        log.Printf("[Backend] User-Agent: %s", r.Header.Get("User-Agent"))

        w.Header().Set("Content-Type", "text/plain")
        w.WriteHeader(http.StatusOK)
        _, _ = w.Write([]byte("Hello from backend!"))
    })
    log.Println("Starting backend server on :8081")
    if err := http.ListenAndServe(":8081", mux); err != nil {
        log.Printf("Backend server error: %v", err)
        os.Exit(1) // 如果后端無法啟動，則退出
    }
}

// 在 Rewrite 函數(shù)中添加:
if r.Out.Header.Get("User-Agent") == "" {
    r.Out.Header.Set("User-Agent", "MyCustomProxy/1.0")
}