package main

import (
	"fmt"
	"os"
	"strings"
)

func main() {
	os.Setenv("FOO", "1")
	fmt.Println("FOO:", os.Getenv("FOO"))
	fmt.Println("BAR:", os.Getenv("BAR"))

	fmt.Println("----------------------")

	for _, env := range os.Environ() {
		pair := strings.SplitN(env, "=", 2)
		fmt.Println(pair[0])
	}
}

// FOO: 1
// BAR: 
// ----------------------
// HOSTNAME
// PWD
// HOME
// LANG
// SHLVL
// PATH
// _
// FOO

package main

import "fmt"

func factorial(n int) int {
	if n == 0 {
		return 1
	}

	return n * factorial(n-1)
}

func main() {
	fmt.Println(factorial(5))
}

// $ go run main.go 
// 120

package main

import "fmt"

// The function createCounter returns anonymous function defined within its body.
// The returned function encapsulates the variable count, creating a closure.
func createCounter() func() int {
	count := 0

	return func() int {
		count++

		return count
	}
}

func main() {
    // We invoke createCounter, storing the result (a function) in counter variable.
    // This function captures and retains its own count value,
    // which updates with each subsequent invocation of createCounter.
	counter := createCounter()

	fmt.Println(counter())
	fmt.Println(counter())
	fmt.Println(counter())

	newCounter := createCounter()
	
    fmt.Println(newCounter())
}

// $ go run main.go 
// 1
// 2
// 3
// 1

package main

import (
    "fmt"
    "runtime"
)

func main() {
    // The runtime.GOOS constant can be used to detect the OS at runtime,
    // since this constant is only set at runtime.
    os := runtime.GOOS

    switch os {
    case "windows":
        fmt.Println("Windows")
    case "darwin":
        fmt.Println("MacOS")
    case "linux":
        fmt.Println("Linux")
    default:
        fmt.Printf("%s.\n", os)
    }

    // The runtime.GOARCH constant can be used to determine the target architecture of a running program.
    fmt.Println(runtime.GOARCH)
}

// Output:
// Linux
// amd64

package main

import (
    "fmt"
    "os"
    "path/filepath"
)

func checkErr(err error) {
    if err != nil {
        panic(err)
    }
}

func main() {
    // The simplest way to create a temporary file is to call os.CreateTemp.
    // It will create and open the file for reading and writing.
    // We used "" as the first argument, so os.CreateTemp will create a file in the default directory.
    tmpFile, err := os.CreateTemp("", "tmpfile")
    checkErr(err)
    defer os.Remove(tmpFile.Name())

    fmt.Println("Temp file name:", tmpFile.Name())

    // Write some data to the temporary file
    _, err = tmpFile.Write([]byte{1, 2, 3, 4, 5})
    checkErr(err)

    // If we intend to write a lot of temporary files, we may prefer to create a temporary directory.
    // The arguments to os.MkdirTemp are the same as for os.CreateTemp, but it returns the directory name rather than the opened file.
    dName, err := os.MkdirTemp("", "tmpdir")
    checkErr(err)
    defer os.RemoveAll(dName)
    
    fmt.Println("Temp directory name:", dName)

    fName := filepath.Join(dName, "testFile")
    err = os.WriteFile(fName, []byte{1, 2, 3, 4, 5}, 0666)
    checkErr(err)
    defer os.Remove(fName)
}

// Output:
// Temp file name: /tmp/tmpfile3400905374
// Temp directory name: /tmp/tmpdir2812568099

package main

import "fmt"

func main() {
    // Recover function must be called inside a deferred function.
    // When the enclosing function panics, defer is activated and the restore call inside it catches the panic.
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("recovered: %s\n", r)
        }
    }()

    panic("some fatal error")
    
    // This code won't run because of panic.
    // Basic operations stop during a panic and resume during a deferred close.
    fmt.Println("after panic")
}

package main

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

func checkErr(err error) {
    if err != nil {
        panic(err)
    }
}

func main() {
    content := "Some content"
    // write a string (or just bytes) into a file
    err := os.WriteFile("/tmp/dfile1", []byte(content), 0644)
    checkErr(err)

    // open a file for writing
    file, err := os.Create("/tmp/dfile2")
    checkErr(err)
    // defer a Close immediately after opening a file
    defer file.Close()

    bytesCount, err := file.Write([]byte(content))
    checkErr(err)
    fmt.Printf("wrote %d bytes\n", bytesCount)

    bytesCount, err = file.WriteString("Some other content\n")
    checkErr(err)
    fmt.Printf("wrote %d bytes\n", bytesCount)
    // flush writes to a stable storage (file system for example)
    file.Sync()

    // bufio provides buffered writers
    writer := bufio.NewWriter(file)
    bytesCount, err = writer.WriteString("Some othe buffered content\n")
    checkErr(err)
    fmt.Printf("wrote %d bytes\n", bytesCount)
    // ensure all buffered operations have been applied to the underlying writer
    writer.Flush()
}

package main

import (
	"crypto/rand"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
)

func GenerateRandomHash(n int) (string, error) {
	b := make([]byte, n)
	_, err := rand.Read(b)

	// Note that err == nil only if we read len(b) bytes.
	if err != nil {
		return "", err
	}

	hasher := sha256.New()
	hasher.Write(b)
	sha := hex.EncodeToString(hasher.Sum(nil))

	return sha, nil
}

func main() {
	hash, err := GenerateRandomHash(512)

	if err != nil {
		panic(err)
	}

	fmt.Println(hash)
}

// go run main.go 
// 34c0fb393623843e56719b5d9d66385a55b4b4d3393187b7b1a76aee46c421c5

package main

import (
    "crypto/sha256"
    "fmt"
)

func main() {
    str := "some string to calculate hash"
    hash := sha256.New()

    hash.Write([]byte(str))
    sum := hash.Sum(nil) // the argument can be used to append to an existing byte slice

    fmt.Println(str)
    fmt.Printf("%x\n", sum)
}

// go run main.go 
// some string to calculate hash
// 7aad383b9ad516fa67057adc283ce2cf71858aff317a5e267adebfdbd5dda5fd

package main

import (
	"fmt"
	"sync"
)

// without using mutex the following error can happen: "fatal error: concurrent map writes" while changing the map in multiple goroutines
type Storage struct {
	sync.Mutex
	storage map[string]int // map is not threade-safe
}

func (s *Storage) Increment(name string) {
	s.Lock() // lock the mutex before accessing counters
	defer s.Unlock() // unlock the mutex at the end of the function using a defer statement
    s.storage[name]++
}

func (s *Storage) Decrement(name string) {
	s.Lock()
    defer s.Unlock()
	s.storage[name]--
}

func main() {
	s := &Storage{
		storage: make(map[string]int),
	}

	wg := sync.WaitGroup{}
	wg.Add(5)

    // increment a named counter in a loop
	increment := func(name string, count uint) {
		for i := 0; i < int(count); i++ {
			s.Increment(name)
		}

		wg.Done()
	}

    // decrement a named counter in a loop
	decrement := func(name string, count uint) {
		for i := 0; i < int(count); i++ {
			s.Decrement(name)
		}

		wg.Done()
	}

    // run 5 goroutines concurrently
	go increment("a", 1000)
	go decrement("a", 500)

	go increment("b", 1000)
	go increment("b", 1000)
	go decrement("b", 1500)

	wg.Wait() // wait for the goroutines to finish

	fmt.Println(s.storage)
}

// $ go run main.go  
// map[a:500 b:500]

// without mutex the following error can happen
// $ go run main.go
// fatal error: concurrent map writes

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
)

func main() {
    sigs := make(chan os.Signal, 1) // create channel for signal, it should be buffered
    signal.Notify(sigs, syscall.SIGINT) // register the channel to receive notifications of the specified signals
    done := make(chan bool, 1)

    go func() {
        sig := <-sigs // wait for OS signal, once received, notify main go routine
        fmt.Printf("\nos signal: %v\n", sig)
        done <- true
    }()

    fmt.Println("awaiting signal")
    <-done // wait for the expected signal and then exit
    fmt.Println("exiting")
}

// $ go run main.go 
// awaiting os signal
// ^C
// os signal: interrupt
// exiting program

package main

import (
    "fmt"
    "time"
)

func main() {
    // in this example we will choose between two channels
    c1 := make(chan string)
    c2 := make(chan string)

    go func() {
        time.Sleep(1 * time.Second)
        c1 <- "one"
    }()

    // each channel will receive a value after some time
    go func() {
        time.Sleep(2 * time.Second)
        c2 <- "two"
    }()

    // use select statement to wait for both values ​​at the same time,
    // printing each one as it arrives
    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-c1:
            fmt.Println("received", msg1)
        case msg2 := <-c2:
            fmt.Println("received", msg2)
        }
    }
}

package main

import (
    "fmt"
    "time"
)

// this is a worker that we will run in several parallel instances
// these workers will receive tasks through the 'jobs' channel and send the results to 'results'
// we will wait for one second for each task to simulate heavy requests
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)
        fmt.Println("worker", id, "finished job", j)
        results <- j * 2
    }
}

func main() {
    // to use worker pool, we need to send a task and receive the execution results
    // therefore 2 channels are created
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    // start 3 workers, initially blocked because no assignments yet
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // send 5 jobs and then close the channel, notofying that all jobs have been sent
    for j := 1; j <= 5; j++ {
        jobs <- j
    }

    close(jobs)

    // collect all the results
    // this also ensures that the goroutines have ended
    for a := 1; a <= 5; a++ {
        <-results
    }
}

package main

import (
    "fmt"
    "time"
)

// the channel is used to notify main goroutine that the function completed successfully
func worker(done chan bool) {
    fmt.Println("working...")
    time.Sleep(time.Second)
    fmt.Println("done")

    done <- true // send a value to indicate that the function completed successfully
}

func main() {
    done := make(chan bool, 1) // create a buffered channel for notification
    go worker(done) // run worker

    <-done // blocked until a notification is received from the worker from the channel
           // if you remove the line <- done the program will close before the worker starts
}

package main

import "fmt"

// return target index if it exists in arr
func search(arr []int, target int) int {
    low := 0
    high := len(arr) - 1

    for low <= high {
        mid := (low + high) / 2

        if arr[mid] < target {
            low = mid + 1
        } else if arr[mid] > target {
            high = mid - 1
        } else {
            return mid
        }
    }

    return -1
}

func main() {
    target := 7
    items := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    fmt.Printf("Element '%d' index is %d", target, search(items, target))
}

// $ output
// 6

package main

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

func main() {
	wg := &sync.WaitGroup{} // WaitGroup is used to wait for the execution of all running goroutines

	for i := 1; i <= 5; i++ {
		wg.Add(1) // launch several goroutines and increment the counter in WaitGroup for each running goroutine

		go func(id int) {
			worker(id, wg)
		}(i)
	}

	fmt.Println("waiting for all goroutines to complete")
	wg.Wait() // block the execution of the program until the WaitGroup counter becomes equal to 0 again
	fmt.Println("done")
}

func worker(id int, wg *sync.WaitGroup) {
	fmt.Printf("worker %d started\n", id)
	time.Sleep(time.Second) // Sleep simulates a long task
	
    fmt.Printf("worker %d finished\n", id)
	wg.Done() // notify WaitGroup that the worker has completed
}

// $ go run waitgroups.go 
// waiting for all goroutines finished
// worker 4 started
// worker 1 started
// worker 2 started
// worker 3 started
// worker 2 finished
// worker 4 finished
// worker 1 finished
// worker 3 finished
// done

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
)

func main() {
	var atomicCounter, nonAtomicCounter uint64
	wg := sync.WaitGroup{}

	for i := 0; i < 50; i++ {
		wg.Add(1)

		go func() { // run 50 goroutines, each goroutine increases the counter 1000 times
			for c := 0; c < 1000; c++ {
				atomic.AddUint64(&atomicCounter, 1) // increase atomic counter
				nonAtomicCounter++ // increase non-atomic counter
			}

			wg.Done()
		}()
	}

	wg.Wait() // wait until all goroutines finish
	
	fmt.Println("atomic counter value:", atomicCounter)
	fmt.Println("non atomic counter value:", nonAtomicCounter)
}

// go run counters.go 
// atomic counter value: 50000
// non atomic counter value: 30648

package main

import (
	"fmt"
	"time"
)

func main() {
	first := make(chan string, 1)

	go func() {
		time.Sleep(2 * time.Second) // wait 2 seconds before send value to channel
		first <- "first result"     // send value to the channel
	}()

	select {
	case result := <-first:
		fmt.Println(result)
	case <-time.After(time.Second): // timeout occurs before the value is read from the first channel
		fmt.Println("first timeout")
	}

	second := make(chan string, 1)

	go func() {
		time.Sleep(time.Second)   // wait 1 second before send value to the channel
		second <- "second result" // send value to the channel
	}()

	select {
	case result := <-second: // the value from the channel is read before the timeout expires
		fmt.Println(result)
	case <-time.After(2 * time.Second):
		fmt.Println("second timeout")
	}
}

// $ go run timeouts.go 
// first timeout
// second result

package main

import (
	"fmt"
	"time"
)

func main() {
	ticker := time.NewTicker(time.Second)
	fmt.Println("ticker is started")

	done := make(chan struct{})

	go func() {
		for {
			select {
			case <-done:
				return
			case t := <-ticker.C:
				fmt.Println("tick", t)
			}
		}
	}()

	time.Sleep(5 * time.Second)

	ticker.Stop()
	fmt.Println("ticker is stopped")

	time.Sleep(5 * time.Second)
	done <- struct{}{}
}

// go run tickers.go 
// ticker is started
// tick 2024-02-09 23:40:25.809616086 +0700 +07 m=+1.000091237
// tick 2024-02-09 23:40:26.809742343 +0700 +07 m=+2.000152938
// tick 2024-02-09 23:40:27.809804037 +0700 +07 m=+3.000214622
// tick 2024-02-09 23:40:28.809852444 +0700 +07 m=+4.000263029
// ticker is stopped
// tick 2024-02-09 23:40:29.809908932 +0700 +07 m=+5.000319557

package main

import (
	"fmt"
	"time"
)

func main() {
	firstTimer := time.NewTimer(3 * time.Second)
	value := <-firstTimer.C // value is a current time

	fmt.Printf("first timer expired: %v\n", value) // the line printed 3 seconds after running code

	secondTimer := time.NewTimer(2 * time.Second)

	go func() {
		<-secondTimer.C
		fmt.Println("second timer expired") // the line is not printed because the second timer is stopped before expiration
	}()

	stop := secondTimer.Stop() // stop second timer before it expired

	if stop {
		fmt.Println("second timer is stopped")
	}
}

// $ go run timers.go
// first timer expired: 2024-02-09 22:32:57.570649221 +0700 +07 m=+3.002054417
// second timer is stopped