package main
import (
    "fmt"
    "time"
)
 
func main() {
    ch := make(chan string) // Unbuffered channel
    
    go func() {
        fmt.Println("Goroutine: Sending data...")
        ch <- "Hello" // এখানে block হবে যতক্ষণ না main goroutine receive করে
        fmt.Println("Goroutine: Data sent!")
    }()
    
    time.Sleep(2 * time.Second) // ২ সেকেন্ড অপেক্ষা করি
    fmt.Println("Main: Receiving data...")
    msg := <-ch // এখন goroutine unblock হবে
    fmt.Println("Main: Received:", msg)
}
 
// Output:
// Goroutine: Sending data...
// (2 seconds pause)
// Main: Receiving data...
// Main: Received: Hello
// Goroutine: Data sent!

package main
import "fmt"
 
func main() {
    ch := make(chan int, 3) // Capacity 3
    
    // Buffer পূর্ণ না হওয়া পর্যন্ত block হবে না
    ch <- 1
    fmt.Println("Sent: 1")
    ch <- 2
    fmt.Println("Sent: 2")
    ch <- 3
    fmt.Println("Sent: 3")
    
    // ch <- 4 // এটা করলে deadlock হবে, কারণ buffer পূর্ণ
    
    // Receive করি
    fmt.Println("Received:", <-ch)
    fmt.Println("Received:", <-ch)
    
    // এখন আবার send করা যাবে
    ch <- 4
    fmt.Println("Sent: 4")
    
    fmt.Println("Received:", <-ch)
    fmt.Println("Received:", <-ch)
}
 
// Output:
// Sent: 1
// Sent: 2
// Sent: 3
// Received: 1
// Received: 2
// Sent: 4
// Received: 3
// Received: 4

// 1. Unbuffered Channel
ch := make(chan int)
 
// 2. Buffered Channel (Capacity 5)
bufCh := make(chan string, 5)
 
// 3. Nil Channel (Zero Value)
var nilCh chan int // এটি ব্যবহার করলে সবসময় block করে (Select-এ কাজে লাগে)
 

package main
import "fmt"
 
// এই ফাংশন শুধু চ্যানেলে ডেটা পাঠাতে পারবে (Write Only)
func producer(out chan<- int) {
    for i := 0; i < 5; i++ {
        out <- i
    }
    close(out) // Sender সবসময় চ্যানেল ক্লোজ করে
}
 
// এই ফাংশন শুধু চ্যানেল থেকে ডেটা পড়তে পারবে (Read Only)
func consumer(in <-chan int) {
    for v := range in {
        fmt.Println("Received:", v)
    }
}
 
func main() {
    ch := make(chan int)
    go producer(ch) // bidirectional channel কাস্ট হয়ে unidirectional হয়ে যায়
    consumer(ch)
}
 
// Output:
// Received: 0
// Received: 1
// Received: 2
// Received: 3
// Received: 4

package main
import "fmt"
 
func sendOnly(ch chan<- string) {
    ch <- "Hello"
    // val := <-ch // ❌ Compile Error: cannot receive from send-only channel
}
 
func receiveOnly(ch <-chan string) {
    msg := <-ch
    fmt.Println(msg)
    // ch <- "World" // ❌ Compile Error: cannot send to receive-only channel
}
 
func main() {
    ch := make(chan string, 1)
    sendOnly(ch)
    receiveOnly(ch)
}
 
// Output:
// Hello

package main
import "fmt"
 
// Stage 1: Generate numbers
func generate(out chan<- int) {
    for i := 1; i <= 5; i++ {
        out <- i
    }
    close(out)
}
 
// Stage 2: Square the numbers
func square(in <-chan int, out chan<- int) {
    for num := range in {
        out <- num * num
    }
    close(out)
}
 
// Stage 3: Print results
func print(in <-chan int) {
    for result := range in {
        fmt.Println("Result:", result)
    }
}
 
func main() {
    // Pipeline: generate → square → print
    ch1 := make(chan int)
    ch2 := make(chan int)
    
    go generate(ch1)
    go square(ch1, ch2)
    print(ch2)
}
 
// Output:
// Result: 1
// Result: 4
// Result: 9
// Result: 16
// Result: 25

close(ch)

v, ok := <-ch
if !ok {
    fmt.Println("Channel is closed and empty!")
    return
}
fmt.Println("Value:", v)
 

for v := range ch {
    fmt.Println(v)
}

len(ch) // buffer এ কয়টা item আছে
cap(ch) // buffer capacity

package main
import "fmt"
 
func main() {
    ch := make(chan int)
 
    go func() {
        for i := 1; i <= 10; i++ {
            ch <- i
        }
        close(ch)
    }()
 
    for v := range ch {
        fmt.Println(v)
    }
}

// ধরুন ch1 ক্লোজ হয়ে গেছে, আমরা চাই না ch1 থেকে আর রিড হোক
select {
case v, ok := <-ch1:
    if !ok {
        ch1 = nil // ch1 এখন nil, এই case আর কখনো এক্সিকিউট হবে না
    } else {
        fmt.Println(v)
    }
case v := <-ch2:
    fmt.Println(v)
}
 

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("Worker", id, "started job", j)
        time.Sleep(time.Second) // ভারী কাজ সিমুলেশন
        results <- j * 2
    }
}
 
func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)
 
    // ৩টি Worker চালু করলাম
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }
 
    // ৫টি কাজ পাঠালাম
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs) // কাজ পাঠানো শেষ
 
    // রেজাল্ট সংগ্রহ
    for a := 1; a <= 5; a++ {
        <-results
    }
}
 

func doWork(done <-chan bool) {
    for {
        select {
        case <-done:
            fmt.Println("Stopping work...")
            return
        default:
            fmt.Println("Working...")
            time.Sleep(500 * time.Millisecond)
        }
    }
}
 
func main() {
    done := make(chan bool)
    go doWork(done)
 
    time.Sleep(2 * time.Second)
    close(done) // সিগন্যাল পাঠানো হলো থামার জন্য
    time.Sleep(1 * time.Second)
}