Intermediate

package main

import "fmt"

func main() {
    // Create Employee with embedded Person
    emp := Employee{
        Person: Person{Name: "Alice", Age: 30}, // => Person is embedded type, must be named in initialization
        // => Creates Person struct with Name="Alice", Age=30
        Title:  "Engineer",                      // => Employee's own field
    }                                            // => emp is Employee{Person: Person{Name: "Alice", Age: 30}, Title: "Engineer"}
    // => emp has 3 accessible fields: Name, Age (promoted), Title (own)

    // Access embedded fields directly (field promotion)
    fmt.Println(emp.Name)    // => Output: Alice (emp.Name promoted from emp.Person.Name)
    // => Can access embedded Person.Name directly through emp.Name
    // => No need to write emp.Person.Name (though that also works)
    fmt.Println(emp.Title)   // => Output: Engineer (emp's own field)
    // => Title belongs to Employee, not promoted
    fmt.Println(emp.Age)     // => Output: 30 (emp.Age promoted from emp.Person.Age)
    // => Age promoted from embedded Person

    // Call embedded methods (method promotion)
    emp.Describe()           // => Calls Person.Describe() on embedded Person
    // => Person.Describe() promoted to Employee
    // => Equivalent to emp.Person.Describe()
    // => Method receiver sees emp.Person (the embedded Person value)
    // => Output: Alice is 30 years old

    // Explicit access to embedded type
    fmt.Println(emp.Person.Name) // => Output: Alice (explicit access, same as emp.Name)
    // => Can explicitly access through emp.Person if needed
    // => Both emp.Name and emp.Person.Name refer to same field
    fmt.Println(emp.Person.Age)  // => Output: 30 (explicit access, same as emp.Age)

    // Modify embedded field
    emp.Name = "Bob"         // => Sets emp.Person.Name = "Bob" (promoted access)
    // => Changes the Name field of embedded Person
    emp.Age = 35             // => Sets emp.Person.Age = 35 (promoted access)
    // => Changes the Age field of embedded Person
    emp.Describe()           // => Calls promoted Describe method
    // => Output: Bob is 35 years old (reflects updated values)

    // Embedded type is a value, not a pointer - changes don't affect original
    p := Person{Name: "Charlie", Age: 40} // => Create separate Person instance
    // => p is independent Person struct
    emp2 := Employee{Person: p, Title: "Manager"}
    // => emp2.Person is COPY of p (value embedding, not pointer)
    // => Changes to emp2.Person won't affect p
    emp2.Name = "David"      // => Changes emp2.Person.Name, NOT p.Name
    // => emp2.Person.Name is now "David"
    // => p.Name remains "Charlie" (independent copy)
    fmt.Println(p.Name)      // => Output: Charlie (p unchanged, still original value)
    // => Proves emp2.Person is copy, not reference to p
    fmt.Println(emp2.Name)   // => Output: David (emp2.Person.Name changed)
    // => emp2 has its own copy with modified name
}

// Person type definition
type Person struct {
    Name string              // => Person's name field (exported, capital N)
    Age  int                 // => Person's age field (exported, capital A)
}                            // => Person is simple struct with two fields

// Person method - available on Person and promoted to Employee
func (p Person) Describe() { // => Method receiver is Person (value receiver)
    // => Value receiver receives copy of Person (not pointer)
    fmt.Printf("%s is %d years old\n", p.Name, p.Age)
    // => Formats and prints description using Name and Age fields
    // => Example output: Alice is 30 years old
}

// Employee embeds Person - gets all Person fields and methods
type Employee struct {
    Person // => Embedded field (anonymous field) - all Person fields/methods promoted to Employee
           // => Employee now has Name, Age (from Person) and Title (own field)
           // => Embedding is composition, not inheritance
           // => No explicit field name (anonymous embedding)
    Title  string // => Employee's own field (not from Person)
}

package main

import (
    "errors"
    "fmt"
)

func main() {
    // Custom error with additional context
    err := performOperation()              // => err is *OperationError (implements error interface)
    // => performOperation returns error type (actually *OperationError underneath)
    if err != nil {                        // => err is not nil, error occurred
        // Type assertion to extract custom error type
        var opErr *OperationError          // => Declare variable of custom error type
        // => opErr is nil initially (will be set by errors.As)
        if errors.As(err, &opErr) {        // => errors.As extracts underlying type into opErr
            // => Checks if err wraps *OperationError anywhere in chain
            // => Sets opErr to point to the actual *OperationError
            // => Returns true because err IS *OperationError
            fmt.Printf("Operation failed: %s (Code: %d)\n", opErr.Message, opErr.Code)
            // => Output: Operation failed: invalid input (Code: 400)
            // => Can now access custom Message and Code fields

            // Access custom fields
            if opErr.Code >= 400 && opErr.Code < 500 {
                // => Code 400-499 indicates client error (user's fault)
                // => Code 500-599 would indicate server error
                fmt.Println("  Category: Client error")
                // => Output:   Category: Client error
            }
        }
    }

    // Error wrapping preserves error chain
    err = divideWithWrapping(10, 0)        // => err wraps ErrDivisionByZero
    // => divideWithWrapping returns wrapped error (two-layer error)
    // => Outer: "division failed: ...", Inner: ErrDivisionByZero
    if err != nil {                        // => err is not nil (division by zero occurred)
        fmt.Println("Wrapped error:", err)
        // => Prints outer error message (includes wrapped error)
        // => Output: Wrapped error: division failed: cannot divide by zero

        // errors.Unwrap extracts wrapped error
        original := errors.Unwrap(err)     // => original is ErrDivisionByZero
        // => Unwrap removes outer layer, returns inner error
        // => original is the sentinel error (cannot divide by zero)
        fmt.Println("Original:", original)
        // => Output: Original: cannot divide by zero

        // Check if error chain contains specific error
        if errors.Is(err, ErrDivisionByZero) {
            // => errors.Is walks error chain to find ErrDivisionByZero
            // => Works with wrapped errors (checks outer, then inner, recursively)
            // => Returns true because inner error IS ErrDivisionByZero
            fmt.Println("Detected division by zero error")
            // => Output: Detected division by zero error
        }
    }

    // Multiple error wrapping layers
    err = topLevelOperation()              // => err wraps multiple layers
    // => Layer 3: "top operation failed: ..."
    // => Layer 2: "division failed: ..."
    // => Layer 1: ErrDivisionByZero sentinel
    if err != nil {                        // => err is not nil
        fmt.Println("\nMulti-layer error:", err)
        // => Prints outermost error message (includes all wrapped messages)
        // => Output: Multi-layer error: top operation failed: division failed: cannot divide by zero

        // errors.Is still finds ErrDivisionByZero through all layers
        if errors.Is(err, ErrDivisionByZero) {
            // => errors.Is recursively unwraps: Layer 3 → Layer 2 → Layer 1
            // => Finds ErrDivisionByZero at Layer 1 (innermost)
            // => Returns true (sentinel error found in chain)
            fmt.Println("Root cause: division by zero")
            // => Output: Root cause: division by zero
        }
    }
}

// Custom error type implementing error interface
type OperationError struct {
    Message string               // => Human-readable error message field
    Code    int                  // => HTTP-style error code (400, 500, etc.)
    // => Additional fields provide context beyond simple error string
}

// Error() method satisfies error interface (must return string)
func (e *OperationError) Error() string {
    // => Pointer receiver (*OperationError) allows errors.As to match both value and pointer
    // => This method is REQUIRED to implement error interface
    return fmt.Sprintf("operation error: %s", e.Message)
    // => Returns formatted string "operation error: invalid input"
    // => This string is used when error is printed or converted to string
}

// performOperation returns custom error type
func performOperation() error {
    // => Returns *OperationError as error interface
    // => Return type is error (interface), actual value is *OperationError
    return &OperationError{
        Message: "invalid input",    // => Custom error with context
        Code:    400,                // => Client error code (HTTP 400 Bad Request)
    }                                // => Returns pointer to OperationError (satisfies error interface)
}

// Sentinel error - predefined error value for comparison
var ErrDivisionByZero = errors.New("cannot divide by zero")
// => Global error variable, use errors.Is() to check for this specific error
// => Sentinel errors are package-level constants for well-known error conditions
// => Created once, reused everywhere (compare by identity, not message)
// => errors.New creates error with constant message

func divideWithWrapping(a, b int) error {
    if b == 0 {                      // => Check denominator (b must be non-zero)
        // => Division by zero is invalid operation
        // => %w verb wraps error, preserving it in error chain
        return fmt.Errorf("division failed: %w", ErrDivisionByZero)
        // => Returns error that wraps ErrDivisionByZero
        // => Outer message: "division failed: cannot divide by zero"
        // => Inner error: ErrDivisionByZero (accessible via Unwrap)
    }
    return nil                       // => No error (b is non-zero, division valid)
}

func topLevelOperation() error {
    err := divideWithWrapping(10, 0) // => err wraps ErrDivisionByZero
    // => err is "division failed: cannot divide by zero" (wrapped error)
    if err != nil {                  // => Check if division failed
        // => Wrap again, creating multi-layer error chain
        return fmt.Errorf("top operation failed: %w", err)
        // => Creates 3-layer error chain:
        // => Layer 3 (outermost): "top operation failed: ..."
        // => Layer 2: "division failed: ..."
        // => Layer 1 (innermost): ErrDivisionByZero
    }
    return nil                       // => No error (division succeeded)
}

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    // Marshal - Go struct to JSON string
    user := User{
        Name: "Alice",                 // => User.Name is exported (capital N)
        Age:  30,                      // => User.Age is exported (capital A)
        Email: "alice@example.com",    // => User.Email is exported (capital E)
    }                                  // => user is User{Name: "Alice", Age: 30, Email: "alice@example.com"}

    jsonBytes, err := json.Marshal(user) // => json.Marshal serializes struct to JSON bytes
    // => Marshal only serializes exported (capitalized) fields
    // => Returns []byte (JSON as bytes) and error
    if err != nil {                      // => Check for marshal errors (rare, usually type issues)
        fmt.Println("Marshal error:", err)
        // => Output: Marshal error: [error details]
        return
    }
    fmt.Println(string(jsonBytes))   // => Convert []byte to string for printing
    // => Output: {"Name":"Alice","Age":30,"Email":"alice@example.com"}
    // => JSON field names match Go field names (capitalized, not ideal for APIs)

    // Unmarshal - JSON string to Go struct
    jsonStr := `{"name":"Bob","age":25,"email":"bob@example.com"}` // => JSON with lowercase field names
    // => Raw string literal (backticks allow unescaped quotes)
    var person Person                    // => person is zero value Person{Name: "", Age: 0, Email: ""}
    // => Declare variable to receive unmarshaled data
    err = json.Unmarshal([]byte(jsonStr), &person) // => Unmarshal requires pointer to modify person
    // => json.Unmarshal uses struct tags to map JSON fields to Go fields
    // => &person allows json.Unmarshal to modify person in-place
    // => []byte(jsonStr) converts string to byte slice (required by Unmarshal)
    if err != nil {                      // => Check for unmarshal errors (invalid JSON, type mismatches)
        fmt.Println("Unmarshal error:", err)
        // => Output: Unmarshal error: invalid character... (example)
        return
    }
    fmt.Println(person)                  // => Print person struct
    // => Output: {Bob 25 bob@example.com}
    // => person is now Person{Name: "Bob", Age: 25, Email: "bob@example.com"}
    // => Struct tags mapped lowercase JSON fields to capitalized Go fields

    // Custom type with different JSON representation
    apiResponse := APIResponse{
        Status: 200,                     // => APIResponse.Status = 200 (HTTP OK)
        Data:   person,                  // => APIResponse.Data = person (Person struct)
    }                                    // => apiResponse is APIResponse{Status: 200, Data: Person{...}}
    // => Nested struct (Person inside APIResponse)

    responseJSON, _ := json.MarshalIndent(apiResponse, "", "  ")
    // => json.MarshalIndent pretty-prints JSON with indentation
    // => First param: value to marshal (apiResponse)
    // => Second param: "" (prefix for each line, typically empty)
    // => Third param: "  " (indentation string, 2 spaces per level)
    fmt.Println(string(responseJSON)) // => Convert []byte to string and print
    // => Output (formatted with indentation):
    // => {
    // =>   "status": 200,
    // =>   "data": {
    // =>     "name": "Bob",
    // =>     "age": 25,
    // =>     "email": "bob@example.com"
    // =>   }
    // => }
    // => Nested Person struct marshaled recursively

    // Handling unknown fields
    unknownJSON := `{"name":"Charlie","age":28,"unknown":"ignored"}` // => JSON with extra field
    // => "unknown" field not in Person struct
    var person2 Person               // => person2 is zero value Person
    err = json.Unmarshal([]byte(unknownJSON), &person2)
    // => Unknown fields ("unknown") are silently ignored during unmarshal
    // => Only known fields (name, age, email) are extracted
    if err != nil {                  // => Check for unmarshal errors
        fmt.Println("Unmarshal error:", err)
    }
    fmt.Println(person2)             // => Print person2 struct
    // => Output: {Charlie 28 }
    // => person2 is Person{Name: "Charlie", Age: 28, Email: ""}
    // => Email is empty string (not in JSON, default value used)
}

// User - field names must be capitalized for json.Marshal to see them
type User struct {
    Name  string                       // => Exported field, marshals to JSON as "Name"
    Age   int                          // => Exported field, marshals to JSON as "Age"
    Email string                       // => Exported field, marshals to JSON as "Email"
}

// Person - struct tags control JSON mapping
type Person struct {
    Name  string `json:"name"`          // => Maps Go field "Name" to JSON field "name"
    Age   int    `json:"age"`           // => Maps Go field "Age" to JSON field "age"
    Email string `json:"email"`         // => Maps Go field "Email" to JSON field "email"
}

type APIResponse struct {
    Status int         `json:"status"`            // => Maps "Status" to "status" in JSON
    Data   Person      `json:"data"`              // => Maps "Data" to "data" in JSON
    // => Nested Person struct will be marshaled with its own tags
}

package main

import (
    "fmt"
    "time"
)

func main() {
    // Start goroutine with go keyword
    go printNumbers()        // => Spawns new goroutine running printNumbers()
                              // => Main goroutine continues immediately WITHOUT waiting
                              // => printNumbers runs concurrently with main
                              // => Two goroutines now executing: main and printNumbers

    // Main continues while goroutine runs
    fmt.Println("Main continues immediately")
                              // => Output: Main continues immediately (printed before goroutine finishes)
                              // => Demonstrates non-blocking nature of go keyword

    // Wait for goroutine to finish (crude synchronization)
    time.Sleep(1 * time.Second) // => Sleeps main goroutine for 1 second
                              // => Gives printNumbers goroutine time to complete
                              // => In production, use WaitGroups or channels (see Example 37)
                              // => If main exits early, goroutines are terminated
    fmt.Println("Main done")  // => Output: Main done (after sleep completes)

    // => Typical output (order may vary due to concurrency):
    // => Main continues immediately
    // => Number: 0
    // => Number: 1
    // => Number: 2
    // => Main done

    // Multiple goroutines with closure pitfall
    fmt.Println("\nMultiple goroutines:")
                              // => Output: (newline) Multiple goroutines:
    for i := 0; i < 3; i++ {  // => Loop creates 3 goroutines
        go func(id int) {     // => Anonymous function takes id parameter
                              // => CORRECT: id is function parameter, each goroutine gets its own copy
                              // => Avoids closure variable capture bug
            fmt.Printf("Goroutine %d running\n", id)
        }(i)                  // => Pass i as argument to goroutine function
                              // => i is copied to id at goroutine creation time
                              // => Each goroutine receives different id (0, 1, 2)
    }
                              // => Output order is non-deterministic (goroutines execute concurrently)
                              // => Possible output: "Goroutine 2", "Goroutine 0", "Goroutine 1"

    time.Sleep(100 * time.Millisecond)
                              // => Wait for all goroutines to complete
                              // => 100ms should be enough for 3 simple goroutines

    // PITFALL: Closure without parameter (WRONG - don't do this)
    fmt.Println("\nClosure pitfall (incorrect):")
    for i := 0; i < 3; i++ {
        go func() {
            // => WRONG: Captures i by reference, NOT by value
            // => All goroutines share the same i variable
            fmt.Printf("Goroutine %d (wrong)\n", i)
            // => Usually prints "Goroutine 3" multiple times (i = 3 after loop ends)
        }()
    }
    time.Sleep(100 * time.Millisecond)

    // Goroutine with return value (requires channel - see Example 35)
    resultChan := make(chan int)       // => Channel to receive result
    go func() {
        sum := 0
        for i := 1; i <= 5; i++ {
            sum += i                   // => sum is 1+2+3+4+5 = 15
        }
        resultChan <- sum              // => Send result to channel
    }()                                // => Goroutine starts immediately

    result := <-resultChan             // => Receive result from channel (blocks until sent)
    fmt.Printf("\nSum from goroutine: %d\n", result)
    // => Output: Sum from goroutine: 15
}

func printNumbers() {
    for i := 0; i < 3; i++ {
        fmt.Printf("Number: %d\n", i)  // => Prints to stdout
        time.Sleep(100 * time.Millisecond) // => Simulate work
    }                                  // => After loop, goroutine exits
}

package main

import (
    "fmt"
)

func main() {
    // Unbuffered channel - synchronizes sender and receiver
    messages := make(chan string) // => make(chan T) creates unbuffered channel
    // => Unbuffered means capacity is 0
    // => Send blocks until receiver ready, receive blocks until sender ready

    go func() {
        messages <- "Hello from goroutine" // => Send blocks until main goroutine receives
        // => After send completes, goroutine exits
    }()                           // => Goroutine starts executing immediately

    msg := <-messages             // => Receive blocks until goroutine sends
    // => msg is "Hello from goroutine" (type: string)
    fmt.Println(msg)
    // => Output: Hello from goroutine

    // Buffered channel - send doesn't block until buffer full
    buffered := make(chan int, 2) // => make(chan T, N) creates channel with buffer capacity N
    // => buffered has capacity 2, can hold 2 values before blocking
    // => len(buffered) is 0, cap(buffered) is 2

    buffered <- 1                 // => Send 1 (doesn't block, buffer has space)
    // => len(buffered) is now 1, cap(buffered) still 2
    buffered <- 2                 // => Send 2 (doesn't block, buffer now full)
    // => len(buffered) is now 2, cap(buffered) still 2
    // buffered <- 3              // => This would DEADLOCK (buffer full, no receiver)
    // => Sends to full buffered channel block until receiver consumes

    val1 := <-buffered            // => Receive 1 (buffer now has space)
    fmt.Println(val1)             // => Output: 1
    // => len(buffered) is now 1
    val2 := <-buffered            // => Receive 2 (buffer now empty)
    fmt.Println(val2)             // => Output: 2
    // => len(buffered) is now 0

    // Range over channel - iterate until close
    results := make(chan int)     // => Unbuffered channel
    go func() {
        results <- 10             // => Send 10 (blocks until received)
        results <- 20             // => Send 20 (blocks until received)
        results <- 30             // => Send 30 (blocks until received)
        close(results)            // => Close channel (signals no more values)
        // => After close, receives return zero value and closed status
        // => Cannot send on closed channel (panic)
    }()

    for value := range results {  // => range receives from channel until closed
        // => value is 10, then 20, then 30
        fmt.Println(value)
    }                             // => Loop exits when channel closed
    // => Output: 10 20 30

    // Checking if channel is closed
    data := make(chan int, 1)
    data <- 42                    // => Send 42
    close(data)                   // => Close channel

    val, ok := <-data             // => Receive with "comma ok" idiom
    // => val is 42, ok is true (value was sent before close)
    fmt.Printf("Value: %d, Open: %t\n", val, ok)
    // => Output: Value: 42, Open: true

    val, ok = <-data              // => Receive again after close
    // => val is 0 (zero value for int), ok is false (channel closed)
    fmt.Printf("Value: %d, Open: %t\n", val, ok)
    // => Output: Value: 0, Open: false

    // Nil channel - sends and receives block forever
    var nilChan chan int          // => nilChan is nil (uninitialized channel)
    // => Sending/receiving on nil channel blocks forever (useful in select)
    // nilChan <- 1                // => Would block forever (deadlock)
    // <-nilChan                   // => Would block forever (deadlock)
}

package main

import (
    "fmt"
    "time"
)

func main() {
    // Select between two channels
    ch1 := make(chan string)           // => Unbuffered channel 1 (no buffer, sends block)
    ch2 := make(chan string)           // => Unbuffered channel 2
    // => Both channels start empty (no data available)

    go func() {                        // => Launch goroutine 1
        time.Sleep(100 * time.Millisecond) // => Simulate work (goroutine sleeps 100ms)
        // => Goroutine pauses for 100ms before sending
        ch1 <- "from channel 1"        // => Send after 100ms delay
        // => This send blocks until select receives
        // => At 100ms mark, ch1 becomes ready for select
    }()

    go func() {                        // => Launch goroutine 2
        time.Sleep(200 * time.Millisecond) // => Simulate longer work (200ms sleep)
        // => Goroutine pauses for 200ms before sending
        ch2 <- "from channel 2"        // => Send after 200ms delay
        // => At 200ms mark, ch2 becomes ready for select
    }()

    // Wait for either channel (select blocks until one is ready)
    for i := 0; i < 2; i++ {           // => Loop twice to receive from both channels
        // => First iteration at i=0, second at i=1
        select {                       // => select waits for ANY case to be ready
        // => Blocks until at least one channel has data
        case msg1 := <-ch1:            // => If ch1 has data, receive it
            // => Receives value from ch1, assigns to msg1
            fmt.Println("Received:", msg1)
            // => First iteration: msg1 is "from channel 1" (ch1 ready at 100ms)
            // => Output: Received: from channel 1
        case msg2 := <-ch2:            // => If ch2 has data, receive it
            // => Receives value from ch2, assigns to msg2
            fmt.Println("Received:", msg2)
            // => Second iteration: msg2 is "from channel 2" (ch2 ready at 200ms)
            // => Output: Received: from channel 2
        }
        // => select executes whichever case is ready first
        // => Only ONE case executes per select (not all ready cases)
    }
    // => Final output (in order):
    // => Received: from channel 1
    // => Received: from channel 2

    // Select with timeout pattern
    timeoutCh := make(chan string)     // => Channel that never receives data
    // => timeoutCh will never have data (no goroutine sends to it)
    select {                           // => Wait for message OR timeout
    case msg := <-timeoutCh:           // => Wait for message from timeoutCh
        // => This case will never execute (timeoutCh never sends)
        fmt.Println("Got message:", msg)
    case <-time.After(100 * time.Millisecond): // => time.After returns channel that sends after duration
        // => time.After(100ms) creates channel, sends value after 100ms
        // => We ignore the value (<-), only care that timeout fired
        fmt.Println("Timeout - no message received")
        // => This case executes at 100ms (timeout reached)
    }
    // => Output: Timeout - no message received (timeoutCh never sends)

    // Default case - non-blocking receive
    results := make(chan int)          // => Empty unbuffered channel
    // => No data available in results channel
    select {                           // => Try to receive, don't block
    case result := <-results:          // => Try to receive from results
        // => Would block normally, but default case prevents blocking
        fmt.Println("Got result:", result)
    default:                           // => Executes IMMEDIATELY if no other case ready
        // => default makes select non-blocking (no wait)
        // => If no case ready, default executes instantly
        fmt.Println("No result available")
        // => This executes because results is empty
    }
    // => Output: No result available (results is empty, default executes)

    // Select with send operations
    data := make(chan int, 1)          // => Buffered channel, capacity 1
    // => Buffer has space for 1 value before send blocks
    select {                           // => Try to send, don't block
    case data <- 42:                   // => Try to send 42 to data channel
        // => Succeeds because buffer has space (0/1 used)
        // => data channel now contains 42 (1/1 buffer full)
        fmt.Println("Sent 42")
        // => This executes because send succeeded
    default:                           // => Would execute if send would block
        fmt.Println("Channel full")
    }
    // => Output: Sent 42

    select {
    case data <- 99:                   // => Try to send (fails, buffer full)
        fmt.Println("Sent 99")
    default:                           // => Executes because send would block
        fmt.Println("Channel full")
    }
    // => Output: Channel full

    // Select blocks until ANY case is ready
    // If multiple cases ready simultaneously, select chooses randomly
    ready1 := make(chan int, 1)        // => Buffered channel, capacity 1
    ready2 := make(chan int, 1)        // => Buffered channel, capacity 1
    ready1 <- 1                        // => Send 1 to ready1 (buffer now full)
    ready2 <- 2                        // => Send 2 to ready2 (buffer now full)
    // => Both channels have data available

    select {
    case v := <-ready1:                // => Both cases ready
        // => v is 1 (type: int)
        fmt.Println("Got from ready1:", v)
        // => Output: Got from ready1: 1
    case v := <-ready2:                // => Both cases ready
        // => v is 2 (type: int)
        fmt.Println("Got from ready2:", v)
        // => Output: Got from ready2: 2
    }
    // => select chooses randomly when multiple cases ready
    // => Output: randomly "Got from ready1: 1" OR "Got from ready2: 2"
}

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup // => Counter starts at 0

    for i := 0; i < 3; i++ {
        wg.Add(1)          // => Increment counter before spawning
        go func(id int) {  // => Pass i to avoid closure pitfall
            defer wg.Done() // => Decrement when complete
            fmt.Printf("Worker %d processing\n", id)
            time.Sleep(100 * time.Millisecond)
        }(i)
    }

    wg.Wait()              // => Block until counter = 0
    fmt.Println("All workers complete")

    var mu sync.Mutex
    var counter int
    var wg2 sync.WaitGroup

    for i := 0; i < 5; i++ {
        wg2.Add(1)
        go func() {
            defer wg2.Done()
            mu.Lock()       // => Acquire exclusive lock
            counter++       // => Safe modification
            mu.Unlock()     // => Release lock
        }()
    }

    wg2.Wait()
    fmt.Println("Counter:", counter) // => Output: Counter: 5

    var rwmu sync.RWMutex
    var data = "initial"
    var wg3 sync.WaitGroup

    // Multiple readers run concurrently
    for i := 0; i < 3; i++ {
        wg3.Add(1)
        go func(id int) {
            defer wg3.Done()
            rwmu.RLock()    // => Read lock (doesn't block other readers)
            fmt.Printf("Reader %d: %s\n", id, data)
            time.Sleep(10 * time.Millisecond)
            rwmu.RUnlock()
        }(i)
    }

    wg3.Wait()

    var wg4 sync.WaitGroup
    wg4.Add(1)
    go func() {
        defer wg4.Done()
        rwmu.Lock()        // => Write lock (exclusive, blocks all)
        data = "updated"
        rwmu.Unlock()
    }()

    wg4.Wait()
    fmt.Println("Data after write:", data) // => Output: Data after write: updated
}

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    // Write to file
    filename := "/tmp/test.txt"      // => File path (absolute path to temp directory)
    file, err := os.Create(filename) // => Create file (truncates if exists)
    // => Returns *os.File (file handle) and error
    // => If file exists, content is deleted (truncated to 0 bytes)
    if err != nil {                  // => Check if creation failed (permissions, path issues)
        fmt.Println("Error creating file:", err)
        // => Output: Error creating file: permission denied (example)
        return
    }
    defer file.Close()               // => defer ensures file closed when function exits
    // => CRITICAL: Always defer file.Close() to prevent resource leaks
    // => File descriptors are limited (typically 1024 per process)

    // Write data to file
    n, err := file.WriteString("Line 1\n")    // => Write string, returns bytes written
    // => n is 7 (len("Line 1\n")), err is nil if success
    // => WriteString converts string to []byte internally
    if err != nil {                  // => Check write errors (disk full, I/O error)
        fmt.Println("Write error:", err)
        // => Output: Write error: no space left on device (example)
    }
    file.WriteString("Line 2\n")     // => Write another line
    // => Returns (7, nil) for successful write
    // => File now contains "Line 1\nLine 2\n" (14 bytes total)

    // Read entire file into memory
    data, err := os.ReadFile(filename) // => Read all bytes at once (convenience function)
    // => data is []byte containing entire file contents
    // => Opens file, reads all, closes automatically
    if err != nil {                  // => Check for read errors (file not found, permissions)
        fmt.Println("Error reading file:", err)
        return
    }
    fmt.Println("File contents:")    // => Output: File contents:
    fmt.Println(string(data))        // => Convert []byte to string
    // => Output:
    // => Line 1
    // => Line 2

    // Read line by line (buffered, memory efficient)
    file, err = os.Open(filename)    // => Open file for reading (read-only mode)
    // => Returns *os.File (file handle) and error
    // => Does NOT truncate file (unlike os.Create)
    if err != nil {                  // => Check open errors (file not found, permissions)
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()               // => Close when done (defer stacks, will execute in reverse)

    scanner := bufio.NewScanner(file) // => Create scanner (buffers reads for efficiency)
    // => scanner reads file in chunks (default 64KB buffer), not all at once
    // => Memory efficient for large files
    lineNum := 0                     // => Line counter
    for scanner.Scan() {              // => Read next line, returns false at EOF or error
        // => Scan advances to next line and returns true if successful
        line := scanner.Text()        // => Get current line (without \n newline)
        // => line is string containing line content
        lineNum++                    // => Increment line counter
        fmt.Printf("Read line %d: %s\n", lineNum, line)
        // => Output: Read line 1: Line 1
    }                                // => Loop exits when scanner.Scan() returns false (EOF)
    // => Final output:
    // => Read line 1: Line 1
    // => Read line 2: Line 2

    if err := scanner.Err(); err != nil { // => Check for scanner errors (I/O errors during scan)
        // => scanner.Err() returns nil if EOF reached normally
        // => Returns error if read failed due to I/O issue
        fmt.Println("Scanner error:", err)
    }

    // File info (metadata)
    info, err := os.Stat(filename)   // => Get file info without opening file
    // => Returns FileInfo interface (metadata only, no file handle)
    // => os.Stat follows symlinks (use os.Lstat for symlink info)
    if err != nil {                  // => Check stat errors (file not found, permissions)
        fmt.Println("Error getting info:", err)
        return
    }
    fmt.Printf("File name: %s\n", info.Name())     // => Base name (test.txt, not full path)
    // => Output: File name: test.txt
    fmt.Printf("File size: %d bytes\n", info.Size()) // => Size in bytes (14 for "Line 1\nLine 2\n")
    // => Output: File size: 14 bytes
    fmt.Printf("Modified: %v\n", info.ModTime())   // => Last modification time (time.Time)
    // => Output: Modified: 2025-12-25 10:30:45 +0700 WIB
    fmt.Printf("Is directory: %t\n", info.IsDir()) // => false (it's a file, not directory)
    // => Output: Is directory: false
    fmt.Printf("Permissions: %v\n", info.Mode())   // => File mode (permissions like -rw-r--r--)
    // => Output: Permissions: -rw-r--r--

    // Append to file
    appendFile, err := os.OpenFile(filename, os.O_APPEND|os.O_WRONLY, 0644)
    // => Open with append flag (writes go to end of file, not beginning)
    // => os.O_APPEND | os.O_WRONLY combines flags with bitwise OR
    // => 0644 is permissions (rw-r--r--, used only if file created)
    if err != nil {                  // => Check open errors
        fmt.Println("Error opening for append:", err)
        return
    }
    defer appendFile.Close()         // => Close append file handle

    appendFile.WriteString("Line 3\n") // => Appends to end of file (after "Line 2\n")
    // => Returns (7, nil) for successful write
    // => File now contains "Line 1\nLine 2\nLine 3\n" (21 bytes total)
    // => Next read will show all 3 lines
}

package main

import (
    "fmt"                                // => Formatted I/O
    "io"                                 // => I/O utilities (ReadAll)
    "net/http"                           // => HTTP client and types
    "net/url"                            // => URL parsing and query parameters
    "time"                               // => Time and duration types
)

func main() {
    // Simple GET request with default client
    resp, err := http.Get("https://api.example.com/users") // => http.Get uses default client
    // => Makes GET request to URL, returns response and error
    // => Default client has no timeout (can hang forever)
    // => Convenience wrapper for http.DefaultClient.Get(url)
    if err != nil {                      // => Check for network/DNS errors
        // => Common errors: connection refused, DNS lookup failure, timeout
        fmt.Println("Error:", err)       // => Output: Error: [network error details]
        return
        // => Early return on error (skip rest of processing)
    }
    defer resp.Body.Close()              // => CRITICAL: Always close response body to prevent leaks
    // => Body is io.ReadCloser, must be closed manually
    // => Leaked bodies exhaust file descriptors and memory
    // => defer ensures close even if function panics

    // Read response body
    body, err := io.ReadAll(resp.Body)   // => Read all bytes from body into memory
    // => body is []byte containing response content
    // => io.ReadAll buffers entire response (risky for large responses)
    // => For streaming, use io.Copy or read in chunks
    if err != nil {                      // => Check for I/O errors during read
        // => Can fail if connection drops mid-read
        fmt.Println("Read error:", err)  // => Output: Read error: [read failure details]
        return
    }
    fmt.Println("Status:", resp.Status)  // => resp.Status is "200 OK" (string)
    // => Output: Status: 200 OK
    // => resp.Status includes both code and text
    fmt.Println("Status Code:", resp.StatusCode) // => resp.StatusCode is 200 (int)
    // => Output: Status Code: 200
    // => resp.StatusCode is just the numeric code
    fmt.Println("Body:", string(body))   // => Convert []byte to string
    // => Output: Body: [JSON or HTML response content]
    // => Prints entire response body to console

    // Custom client with timeout
    client := &http.Client{              // => Create custom HTTP client
        // => Pointer to http.Client struct
        Timeout: 5 * time.Second,        // => Overall request timeout (includes connection, read, etc.)
        // => If request takes > 5s, client.Do returns timeout error
        // => Prevents hanging on slow/unresponsive servers
        // => 5 * time.Second is 5000000000 nanoseconds (5s duration)
    }                                    // => client is *http.Client with 5s timeout

    // Create custom request with headers
    req, err := http.NewRequest("GET", "https://api.example.com/users", nil)
    // => Creates GET request, nil body (GET requests typically have no body)
    // => req is *http.Request with URL, method, and empty body
    // => http.NewRequest returns (req, err) - req is nil if err != nil
    if err != nil {                      // => Check for request creation errors (rare)
        // => Only fails if method or URL invalid
        fmt.Println("Request creation error:", err)
        return
    }

    req.Header.Add("Authorization", "Bearer token123") // => Add authorization header
    // => Sets Authorization: Bearer token123 in request
    // => req.Header is http.Header (map[string][]string)
    req.Header.Add("Content-Type", "application/json") // => Add content type
    // => Sets Content-Type: application/json
    // => Header.Add appends value (allows multiple values for same key)
    req.Header.Set("User-Agent", "MyApp/1.0")          // => Set user agent (replaces existing)
    // => Set replaces all existing values, Add appends
    // => Use Set for single-value headers, Add for multi-value
    // => User-Agent identifies client to server

    resp, err = client.Do(req)           // => Execute request with custom client
    // => Sends request with all custom headers and timeout
    // => resp overwrites first response (original resp already closed)
    if err != nil {                      // => Check for timeout or network errors
        // => Timeout error message: "context deadline exceeded"
        fmt.Println("Error:", err)       // => Output: Error: context deadline exceeded (timeout)
        return
    }
    defer resp.Body.Close()              // => Close response body to prevent leaks
    // => Second defer (closes second response)

    // Check status code
    if resp.StatusCode == http.StatusOK { // => http.StatusOK is constant 200
        // => Successful responses are 2xx (200-299)
        fmt.Println("Request successful") // => Output: Request successful
    } else if resp.StatusCode >= 400 {   // => 4xx or 5xx indicates error
        // => 4xx is client error (404 Not Found, 401 Unauthorized)
        // => 5xx is server error (500 Internal Server Error)
        fmt.Printf("Request failed with status: %d\n", resp.StatusCode)
        // => Output: Request failed with status: 404 (example)
    }

    // Query parameters
    baseURL := "https://api.example.com/search" // => Base URL without query string
    // => baseURL is string, will be concatenated with encoded params
    params := url.Values{}               // => url.Values is map[string][]string
    // => Constructs query parameters safely with proper escaping
    // => Values{} creates empty map (no params initially)
    params.Add("q", "golang")            // => Add query parameter q=golang
    // => params is map[string][]string{"q": ["golang"]}
    // => Add appends value to list (supports multiple values for same key)
    params.Add("limit", "10")            // => Add limit=10 parameter
    // => params is map[string][]string{"q": ["golang"], "limit": ["10"]}
    fullURL := baseURL + "?" + params.Encode()
    // => params.Encode() converts to URL-encoded query string
    // => fullURL is "https://api.example.com/search?q=golang&limit=10"
    // => Properly escapes special characters (spaces, &, =, etc.)
    // => Encode handles URL encoding (spaces become %20, etc.)

    req2, _ := http.NewRequest("GET", fullURL, nil) // => Create request with query params
    // => req2 URL includes ?q=golang&limit=10
    // => _ discards error (we know URL is valid)
    resp2, err := client.Do(req2)        // => Execute request with 5s timeout
    // => Sends GET https://api.example.com/search?q=golang&limit=10
    // => Uses same client (5s timeout applies)
    if err != nil {                      // => Check for errors (timeout, network, etc.)
        // => Same error handling as previous requests
        fmt.Println("Error:", err)
        return
    }
    defer resp2.Body.Close()             // => Close second response body
    // => Always close bodies to prevent resource leaks
    // => Third defer in this function (closes third response)
}

package main

import (
    "fmt"                                // => For formatted output
    "io"                                 // => For ReadAll (reading request body)
    "net/http"                           // => HTTP server and handler types
)

func main() {
    // Create router (multiplexer)
    mux := http.NewServeMux()            // => ServeMux routes requests to handlers
    // => mux matches request URL to registered patterns
    // => Type: *http.ServeMux (pointer to multiplexer)

    // Register handler function
    mux.HandleFunc("/", homeHandler)     // => HandleFunc wraps function as Handler
    // => "/" matches all paths (default/fallback)
    // => homeHandler is func(ResponseWriter, *Request)
    mux.HandleFunc("/users", usersHandler)
    // => "/users" matches exactly "/users"
    // => More specific patterns take precedence over "/"
    mux.Handle("/data", &DataHandler{})  // => Handle registers Handler interface implementor
    // => DataHandler must implement ServeHTTP method
    // => &DataHandler{} creates pointer to empty struct

    // Start HTTP server
    fmt.Println("Server listening on :8080")
    // => Output to console before blocking
    err := http.ListenAndServe(":8080", mux) // => Blocks listening on port 8080
    // => mux is the handler (routes to registered handlers)
    // => ":8080" binds to all network interfaces on port 8080
    if err != nil {                      // => Returns error if server fails to start
        // => Common errors: port in use, permission denied
        fmt.Println("Error:", err)
        // => Print error and exit
    }
}

// Handler function - receives ResponseWriter and Request
func homeHandler(w http.ResponseWriter, r *http.Request) {
    // => w is ResponseWriter interface (writes response)
    // => r is *Request (contains request data)
    // => Called when request matches "/" pattern

    // Read request body
    body, err := io.ReadAll(r.Body)      // => Read all bytes from request body
    // => r.Body is io.ReadCloser (must be closed)
    // => body is []byte, err is error
    if err != nil {
        // => Error reading body (e.g., connection closed)
        http.Error(w, "Bad Request", http.StatusBadRequest) // => Send error response
        // => Sets status 400, writes "Bad Request\n" to body
        return
        // => Don't proceed if body read failed
    }
    defer r.Body.Close()                 // => Close body when done
    // => Defer runs at function exit, releases resources

    // Access request information
    fmt.Printf("Method: %s\n", r.Method) // => r.Method is "GET", "POST", etc.
    // => r.Method is string constant from HTTP request
    fmt.Printf("URL: %s\n", r.URL.Path)  // => r.URL.Path is "/", r.URL.RawQuery has params
    // => r.URL is *url.URL, Path is path component
    fmt.Printf("Headers: %v\n", r.Header) // => r.Header is map[string][]string
    // => Headers can have multiple values (e.g., Set-Cookie)

    // Write response
    fmt.Fprintf(w, "Hello from home! Method: %s, Body: %s\n", r.Method, string(body))
    // => Writes to ResponseWriter, sent to client
    // => string(body) converts []byte to string
    // => Fprintf formats and writes to w
}

// Handler function with JSON response
func usersHandler(w http.ResponseWriter, r *http.Request) {
    // Set response headers BEFORE writing body
    w.Header().Set("Content-Type", "application/json") // => Set content type header
    // => w.Header() is http.Header (map[string][]string)
    // => Set replaces all values for key "Content-Type"
    w.WriteHeader(http.StatusOK)         // => Set status code (must be before Write)
    // => Default status is 200 if not set explicitly
    // => http.StatusOK is constant 200
    // => Once WriteHeader called, status cannot change

    // Check request method
    if r.Method == http.MethodPost {     // => http.MethodPost is constant "POST"
        // => Method is string, comparing with constant
        fmt.Fprint(w, `{"status": "user created"}`) // => Write JSON string
        // => Backticks are raw string literal (no escaping needed)
    } else if r.Method == http.MethodGet {
        // => Check if GET request
        fmt.Fprint(w, `{"users": [{"id": 1}, {"id": 2}]}`)
        // => Return JSON array of users
    } else {
        // Method not allowed
        w.WriteHeader(http.StatusMethodNotAllowed)
        // => http.StatusMethodNotAllowed is 405
        // => Indicates server doesn't support method for this path
        fmt.Fprint(w, `{"error": "method not allowed"}`)
        // => JSON error response
    }
}

// Handler type - implements Handler interface
type DataHandler struct{}
// => Empty struct, no fields
// => Used as method receiver for ServeHTTP

// ServeHTTP makes DataHandler satisfy http.Handler interface
func (h *DataHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // => This method is called when request matches "/data"
    // => Any type with ServeHTTP(ResponseWriter, *Request) is a Handler
    // => h is pointer receiver (method on *DataHandler)

    // Access query parameters
    queryParams := r.URL.Query()         // => Returns url.Values (map[string][]string)
    // => Parses query string from URL (e.g., "?filter=active&sort=name")
    // => url.Values is alias for map[string][]string
    filter := queryParams.Get("filter")  // => Get first value of "filter" param
    // => Example: "/data?filter=active" sets filter to "active"
    // => Get returns "" if param not present

    response := fmt.Sprintf("Data response with filter: %s", filter)
    // => Formats string with filter value
    // => If filter="", output is "Data response with filter: "
    fmt.Fprint(w, response)              // => Write response
    // => Sends formatted response to client
}