package main

import (
    "io"
    "fmt"
    "os"
)

// copy file using os package
func copyFileUsingOsPackage(src, dst string) error {
    bytesRead, err := os.ReadFile(src)
    if err != nil {
        return err
    }

    return os.WriteFile(dst, bytesRead, 0644)
}

// copy file using io package
func copyFileUsingIoPackage(src, dst string) (int64, error) {
        source, err := os.Open(src)
        if err != nil {
                return 0, err
        }
        defer source.Close()

        destination, err := os.Create(dst)
        if err != nil {
                return 0, err
        }
        defer destination.Close()
        
        nBytes, err := io.Copy(destination, source)
        
        return nBytes, err
}

func main() {
    src := "/tmp/file-src.txt"
    dst := "/tmp/file-dst.txt"

    n, err := copyFileUsingIoPackage(src, dst)

    if err != nil {
        panic(err)
    }

    fmt.Printf("Copied %d bytes", n)
    fmt.Println()

    err = copyFileUsingOsPackage(src, dst)

    if err != nil {
        panic(err)
    }
}

package main

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

func main() {
    filePath := "/tmp/file.ext"

    // get file name with extension
    fileName := filepath.Base(filePath)

    // get file extension
    fileExt := filepath.Ext(filePath)

    // truncate file name extension
    fileNameWithoutExt := strings.TrimSuffix(fileName, fileExt)

    fmt.Println("File name without extension: " + fileNameWithoutExt)
}

// $ go run main.go
// File name without extension: file

package main

import (
	b64 "encoding/base64"
	"fmt"
)

func main() {
	str := "text123321!?$*&()'-=@~"

	// Encode using the standard encoder
	strEnc := b64.StdEncoding.EncodeToString([]byte(str))
	fmt.Println(strEnc)

	strDec, err := b64.StdEncoding.DecodeString(strEnc)

	if err != nil {
		panic(err)
	}

	fmt.Println(string(strDec))
	fmt.Println()

	// Encode using a URL-compatible base64 format
	strEnc = b64.URLEncoding.EncodeToString([]byte(str))
	fmt.Println(strEnc)

	strDec, err = b64.URLEncoding.DecodeString(strEnc)

	if err != nil {
		panic(err)
	}

	fmt.Println(string(strDec))
}

// $ go run main.go
// dGV4dDEyMzMyMSE/JComKCknLT1Afg==
// text123321!?$*&()'-=@~

// dGV4dDEyMzMyMSE_JComKCknLT1Afg==
// text123321!?$*&()'-=@~

package main

import (
	"fmt"
	"net"
	"net/url"
)

func main() {
	s := "mysql://user:pass@host.com:3306/path?key=value#fragment"

	u, err := url.Parse(s)

	if err != nil {
		panic(err)
	}

	fmt.Println("Scheme: " + u.Scheme)

	fmt.Println("Username: " + u.User.Username())
	p, _ := u.User.Password()
	fmt.Println("Password: " + p)

	fmt.Println("Host with port: " + u.Host)

	host, port, err := net.SplitHostPort(u.Host)

	if err != nil {
		panic(err)
	}

	fmt.Println("Host: " + host)
	fmt.Println("Port: " + port)

	fmt.Println("Path: " + u.Path)
	fmt.Println("Fragment: " + u.Fragment)

	fmt.Println("Raw query: " + u.RawQuery)

	m, err := url.ParseQuery(u.RawQuery)

	if err != nil {
		panic(err)
	}

	fmt.Println("Value: " + m["key"][0])
}

// $ go run main.go 
// Scheme: mysql
// Username: user
// Password: pass
// Host with port: host.com:3306
// Host: host.com
// Port: 3306
// Path: /path
// Fragment: fragment
// Raw query: key=value
// Value: value

package main

import (
	"fmt"
	"time"
)

func print(from string) {
	for i := 0; i < 3; i++ {
		fmt.Println(from, ":", i)
	}
}

func main() {
	// Synchronous function call
	print("synchronous call")

	// Asynchronous function call
	// To run this function in a goroutine, use go f(s)
	// This new goroutine will execute concurrently with the calling main goroutine
	go print("asynchronous call")

	// Goroutine can also be execute as an anonymous function
	go func(msg string) {
		fmt.Println(msg)
	}("asynchronous anonymous call")

	// Two previous function calls are now running asynchronously in separate goroutines
	// Wait for them to finish
	time.Sleep(time.Second)
	fmt.Println("done")
}

// $ go run main.go
// synchronous call : 0
// synchronous call : 1
// synchronous call : 2
// asynchronous anonymous call
// asynchronous call : 0
// asynchronous call : 1
// asynchronous call : 2
// done

package main

import "fmt"

func main() {
    // Create unbuffered channel
	unbufferedChannel := make(chan string)

	go func() {
        // Send a value into a channel using the channel<- syntax
		unbufferedChannel <- "unbuffered channel"
	}()

    // The <-channel syntax receives a value from the channel
	fmt.Println(<-unbufferedChannel)

    // Create buffered channel with size 2
	bufferedChannel := make(chan string, 2)

    // Send a value to a buffered channel. The operation in non blocking
	bufferedChannel <- "buffered"
	bufferedChannel <- "channel"

	fmt.Println(<-bufferedChannel)
	fmt.Println(<-bufferedChannel)
}

// go run main.go 
// unbuffered channel
// buffered
// channel

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
}