package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"time"

	"github.com/gin-gonic/gin"
)

// go get -u github.com/gin-gonic/gin

func main() {
    // gin.DisableConsoleColor()
    // gin.ForceConsoleColor()

	// r := gin.Default()

    f, _ := os.Create("gin.log")

    gin.DefaultWriter = io.MultiWriter(f, os.Stdout)

    r := gin.Default()

    // r := gin.New()

    // r.Use(gin.LoggerWithFormatter(func(param gin.LogFormatterParams) string {
    //     return fmt.Sprintf("%s - [%s] \"%s %s %s %d %s \"%s\" %s\"\n",
	// 			param.ClientIP,
	// 			param.TimeStamp.Format(time.RFC1123),
	// 			param.Method,
	// 			param.Path,
	// 			param.Request.Proto,
	// 			param.StatusCode,
	// 			param.Latency,
	// 			param.Request.UserAgent(),
	// 			param.ErrorMessage,
	// 	)
    // }))

    // r.Use(gin.Recovery())

	r.GET("/ping", func(ctx *gin.Context) {
		ctx.JSON(200, gin.H{
			"message": "pong",
		})
	})

	r.GET("/asciijson", func(ctx *gin.Context) {
		data := map[string]interface{}{
			"lang": "GO语言",
			"tag":  "<br>",
		}

		// will output : {"lang":"GO\u8bed\u8a00","tag":"\u003cbr\u003e"}
		ctx.AsciiJSON(http.StatusOK, data)
	})

	r.GET("/getb", GetDataB)
	r.GET("/getc", GetDataC)
	r.GET("/getd", GetDataD)

	r.LoadHTMLFiles("form.html", "index.html")
	// r.GET("/", indexHandler)
	// r.POST("/", formHandler)

    r.GET("/testing", startPage)

    r.GET("/person/:name/:address", func(ctx *gin.Context) {
        var person Person

        if err := ctx.ShouldBindUri(&person); err != nil {
            ctx.JSON(400, gin.H{"msg": err})
            return
        }

        ctx.JSON(http.StatusOK, gin.H{"name": person.Name, "address": person.Address})
    })

    r.GET("/long_async", func(c *gin.Context) {
		// create copy to be used inside the goroutine
		cCp := c.Copy()
		go func() {
			// simulate a long task with time.Sleep(). 5 seconds
			time.Sleep(5 * time.Second)

			// note that you are using the copied context "cCp", IMPORTANT
			log.Println("Done! in path "   cCp.Request.URL.Path)
		}()
	})

	r.GET("/long_sync", func(c *gin.Context) {
		// simulate a long task with time.Sleep(). 5 seconds
		time.Sleep(5 * time.Second)

		// since we are NOT using a goroutine, we do not have to copy the context
		log.Println("Done! in path "   c.Request.URL.Path)
	})

    r.GET("/welcome", func(c *gin.Context) {
        firstname := c.DefaultQuery("firstname", "Guest")
        lastname := c.Query("lastname") // shortcut for c.Request.URL.Query().Get("lastname")

        c.String(http.StatusOK, "Hello %s %s", firstname, lastname)
    })

    // r.GET("/test", func(c *gin.Context) {
    //     c.Redirect(http.StatusMovedPermanently, "http://www.google.com/")
    // })

    r.GET("/test", func(c *gin.Context) {
        c.Request.URL.Path = "/test2"
        r.HandleContext(c)
    })

    r.GET("/test2", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"hello": "world"})
    })

    authorized := r.Group("/admin", gin.BasicAuth(gin.Accounts{
		"foo":    "bar",
		"austin": "1234",
		"lena":   "hello2",
		"manu":   "4321",
	}))

	// /admin/secrets endpoint
	// hit "localhost:8080/admin/secrets
	authorized.GET("/secrets", func(c *gin.Context) {
		// get user, it was set by the BasicAuth middleware
		user := c.MustGet(gin.AuthUserKey).(string)
		if secret, ok := secrets[user]; ok {
			c.JSON(http.StatusOK, gin.H{"user": user, "secret": secret})
		} else {
			c.JSON(http.StatusOK, gin.H{"user": user, "secret": "NO SECRET :("})
		}
	})

    r.GET("/", func(ctx *gin.Context) {
        ctx.HTML(http.StatusOK, "index.html", nil)
    })

    r.POST("/upload", func(ctx *gin.Context) {
        name := ctx.PostForm("name")
        email := ctx.PostForm("email")

        form, err := ctx.MultipartForm()

        if err != nil {
            ctx.String(http.StatusBadRequest, fmt.Sprintf("get form err: %s", err.Error()))
        }

        files := form.File["files"]

        for _, file := range files {
            filename := filepath.Base(file.Filename)

            if err := ctx.SaveUploadedFile(file, "files/" filename); err != nil {
                ctx.String(http.StatusBadRequest, fmt.Sprintf("upload file err: %s", err.Error()))
            }
        }

        ctx.String(http.StatusOK, fmt.Sprintf("Uploaded successfully %d files with fields name=%s and email=%s.", len(files), name, email))
    })

    r.POST("/download", func(ctx *gin.Context) {
        form, err := ctx.MultipartForm()
        file := form.File["file"]

        filename := filepath.Base(file[0].Filename)

        if err != nil {
            ctx.String(http.StatusBadRequest, fmt.Sprintf("get file path err: %s", err.Error()))
        }

        ctx.FileAttachment("files/" filename, filename)
        ctx.String(http.StatusOK, fmt.Sprintf("Download successfully %s", filename))
    })

    s := &http.Server{
        Addr:           ":8080",
        Handler:        r,
        ReadTimeout:    10 * time.Second,
        WriteTimeout:   10 * time.Second,
        MaxHeaderBytes: 1 << 20,
    }

    s.ListenAndServe()
}

type StructA struct {
    FieldA string `form:"field_a"`
}

type StructB struct {
    NestedStruct StructA
    FieldB string `form:"field_b"`
}

type StructC struct {
    NestedStructPointer *StructA
    FieldC string `form:"field_c"`
}

type StructD struct {
    NestedAnonyStruct struct {
        FieldX string `form:"field_x"`
    }
    FieldD string `form:"field_d"`
}

func GetDataB(c *gin.Context) {
    var b StructB
    c.Bind(&b)
    c.JSON(200, gin.H{
        "a": b.NestedStruct,
        "b": b.FieldB,
    })
}

func GetDataC(c *gin.Context) {
    var b StructC
    c.Bind(&b)
    c.JSON(200, gin.H{
        "a": b.NestedStructPointer,
        "c": b.FieldC,
    })
}

func GetDataD(c *gin.Context) {
    var b StructD
    c.Bind(&b)
    c.JSON(200, gin.H{
        "x": b.NestedAnonyStruct,
        "d": b.FieldD,
    })
}

type myForm struct {
    Colors []string `form:"colors[]"`
}

func indexHandler(c *gin.Context) {
    c.HTML(200, "form.html", nil)
}

func formHandler(c *gin.Context) {
    var fakeForm myForm
    c.Bind(&fakeForm)
    c.JSON(200, gin.H{"color": fakeForm.Colors})
}

type Person struct {
    Name string `form:"name" json:"name" uri:"name"`
    Address string `form:"address" json:"address" uri:"address"`
}

func startPage(ctx *gin.Context) {
    var person Person

    if ctx.Bind(&person) == nil {
        log.Println("====== Only Bind By Query String ======")
        log.Println(person.Name)
        log.Println(person.Address)
    }

    if ctx.BindJSON(&person) == nil {
        log.Println("====== Only Bind By JSON ======")
        log.Println(person.Name)
        log.Println(person.Address)
    }

    ctx.String(http.StatusOK, "Success")
}

// curl -X GET "localhost:8080/testing?name=appleboy&address=xyz"
// curl -X GET localhost:8080/testing --data '{"name":"JJ", "address":"xyz"}' -H "Content-Type:application/json"

// BasicAuth middleware
var secrets = gin.H{
	"foo":    gin.H{"email": "[email protected]", "phone": "123433"},
	"austin": gin.H{"email": "[email protected]", "phone": "666"},
	"lena":   gin.H{"email": "[email protected]", "phone": "523443"},
}

var testusers = []User{
    User{ID: "1", Name: "Chen Li"},
    User{ID: "2", Name: "Chen Lii"},
    User{ID: "3", Name: "Chen Liii"},
}

func main() {
    r := gin.Default()
    r.Use(gin.Recovery())

    public := r.Group("/")
    private := r.Group("/")

    private.Use(JwtAuthMiddleware("secret"))

    public.POST("/login", func(c *gin.Context) {
        id := c.PostForm("id")

        for _, user := range testusers {
            if user.ID == id {
                token, err := CreateAccessToken(&user, "secret", 2)

                if err != nil {
                    c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                    c.Abort()
                }

                c.SetCookie("access_token", token, 3600, "/", "localhost", false, true)
                c.JSON(http.StatusOK, gin.H{"token": token})
                return
            }
        }

        c.JSON(http.StatusOK, gin.H{"error": "User not found"})
    })

    private.GET("/ping", func(c *gin.Context) {
        cookietoken, _ := c.Cookie("access_token")
        c.JSON(http.StatusOK, gin.H{"cookie": cookietoken})
    })

    r.Run(":8080")
}

type User struct {
    ID string
    Name string
}

type JwtCustomClaims struct {
    Name string `json:"name"`
    ID string `json:"id"`
    jwt.StandardClaims
}

type JwtCustomRefreshClaims struct {
    ID string `json:"id"`
    jwt.StandardClaims
}

func CreateAccessToken(user *User, secrect string, expiry int) (accessToken string, err error) {
    exp := time.Now().Add(time.Hour * time.Duration(expiry)).Unix()

    claims := &JwtCustomClaims{
        Name: user.Name,
        ID: user.ID,
        StandardClaims: jwt.StandardClaims{
            ExpiresAt: exp,
        },
    }

    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)

    t, err := token.SignedString([]byte(secrect))

    if err != nil {
        return "", err
    }

    return t, err
}

func CreateRefreshToken(user *User, secret string, expiry int) (refreshToken string, err error) {
    claimsRefresh := &JwtCustomRefreshClaims{
        ID: user.ID,
        StandardClaims: jwt.StandardClaims{
            ExpiresAt: time.Now().Add(time.Hour * time.Duration(expiry)).Unix(),
        },
    }

    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claimsRefresh)

    rt, err := token.SignedString([]byte(secret))

    if err != nil {
        return "", err
    }

    return rt, err
}

func IsAuthorized(requestToken string, secret string) (bool, error) {
    _, err := jwt.Parse(requestToken, func(token *jwt.Token) (interface{}, error) {
		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
			return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
		}
		return []byte(secret), nil
	})
	if err != nil {
		return false, err
	}
	return true, nil
}

func ExtractIDFromToken(requestToken string, secret string) (string, error) {
    token, err := jwt.Parse(requestToken, func(t *jwt.Token) (interface{}, error) {
        if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
            return nil, fmt.Errorf("Unexpected signing method: %v", t.Header["alg"])
        }

        return []byte(secret), nil
    })

    if err != nil {
        return "", err
    }

    claims, ok := token.Claims.(jwt.MapClaims)

    if !ok && !token.Valid {
        return "", fmt.Errorf("Invalid Token")
    }

    return claims["id"].(string), nil
}

func JwtAuthMiddleware(secret string) gin.HandlerFunc {
    return func(c *gin.Context) {
        authHeader := c.Request.Header.Get("Authorization")
        t := strings.Split(authHeader, " ")

        if len(t) == 2 {
            authToken := t[1]
            
            authorized, err := IsAuthorized(authToken, secret)

            if authorized {
                userID, err := ExtractIDFromToken(authToken, secret)

                if err != nil {
                    c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
                    c.Abort()
                    return
                }

                c.Header("x-user-id", userID)
                c.Next()
                return
            }

            c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
			c.Abort()
			return
        }

        c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid token"})
        c.Abort()
    }
}

type Album struct {
    ID     int64
    Title  string
    Artist string
    Price  float32
}

var db *sql.DB

func main() {
	cfg := mysql.Config{
		User: "root",
		Passwd: "Lc15503539901",
		Net: "tcp",
		Addr: "127.0.0.1:3306",
		DBName: "recordings",	
	}

	var err error

	db, err := sql.Open("mysql", cfg.FormatDSN())

	if err != nil {
		log.Fatal(err)
	}

	// ping
	pingErr := db.Ping()

	if pingErr != nil {
		log.Fatal(pingErr)
	}

	fmt.Println("Connected!")

	albums, err := fetchAlbumsByArtist("John Coltrane", db)

	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Albums found: %v\n", albums)

	rows, err := db.Query("select * from album where artist = ?", "John Coltrane")

	albs := []Album{}

	for rows.Next() {
		var alb Album

		err := rows.Scan(&alb.ID, &alb.Title, &alb.Artist, &alb.Price)

		if err != nil {
			log.Fatal(err)
		}

		albs = append(albs, alb)
	}

	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%v", albums)

	albID, err := addAlbum(Album{
		Title:  "The Modern Sound of Betty Carter",
		Artist: "Betty Carter",
		Price:  49.99,
	}, db)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("ID of added album: %v\n", albID)

	newAlbID, err := updateAlbumById(Album{
		ID: 1,
		Title: "Red Brain",
		Artist: "John Coltrane",
		Price: 99.99,
	}, db)

	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("ID of updated album: %v\n", newAlbID)

	row, err := deleteAlbumById(5, db)

	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("ID of deleted album: %v\n", row)
}

// db is not initialized if no db parameter put in
func fetchAlbumsByArtist(name string, db *sql.DB) ([]Album, error) {
	var albums []Album

	rows, err := db.Query("SELECT * FROM album WHERE artist = ?", name)

	if err != nil {
		return nil, fmt.Errorf("fetchAlbumByArtist %q: %v", name, err)
	}

	defer rows.Close()

	for rows.Next() {
		var alb Album

		if err := rows.Scan(&alb.ID, &alb.Title, &alb.Artist, &alb.Price); err != nil {
            return nil, fmt.Errorf("albumsByArtist %q: %v", name, err)
        }
        albums = append(albums, alb)
	}

	if err := rows.Err(); err != nil {
        return nil, fmt.Errorf("albumsByArtist %q: %v", name, err)
    }

	return albums, nil
}

func addAlbum(alb Album, db *sql.DB) (int64, error) {
	result, err := db.Exec("insert into album (title, artist, price) values (?, ?, ?)", alb.Title, alb.Artist, alb.Price)

	if err != nil {
		return 0, fmt.Errorf("addAlbum: %v", err)
	}

	id, err := result.LastInsertId()

	if err != nil {
		return 0, fmt.Errorf("addAlbum: %v", err)
	}

	return id, nil
}

func updateAlbumById(newAlb Album, db *sql.DB) (int64, error) {
	result, err := db.Exec("update album set title = ?, artist = ?, price = ? where id = ?", newAlb.Title, newAlb.Artist, newAlb.Price, newAlb.ID)

	if err != nil {
		return 0, fmt.Errorf("updateAlbumById: %v", err)
	}

	id, err := result.RowsAffected()

	if err != nil {
		return 0, fmt.Errorf("updateAlbumById: %v", err)
	}

	return id, nil
}

func deleteAlbumById(id int, db *sql.DB) (int64, error) {
	result, err := db.Exec("delete from album where id = ?", id)

	if err != nil {
		return 0, fmt.Errorf("deleteAlbumById: %v", err)
	}

	row, err := result.RowsAffected()

	if err != nil {
		return 0, fmt.Errorf("deleteAlbumById: %v", err)
	}

	return row, nil
}

type Env struct {
	AccessTokenExpiryHour int `mapstructure:"ACCESS_TOKEN_EXPIRY_HOUR"`		// no space allowed
	RefreshTokenExpiryHour int `mapstructure:"REFRESH_TOKEN_EXPIRY_HOUR"`
	AccessTokenSecret string `mapstructure:"ACCESS_TOKEN_SECRET"`
	RefreshTokenSecret string `mapstructure:"REFRESH_TOKEN_SECRET"`
}

func NewEnv() *Env {
	env := Env{}
	viper.SetConfigFile(".env")

	err := viper.ReadInConfig()
	if err != nil {
		log.Fatal("Can't find the file .env : ", err)
	}

	err = viper.Unmarshal(&env)
	if err != nil {
		log.Fatal("Environment can't be loaded: ", err)
	}

	return &env
}

func main() {
	env := NewEnv()

	fmt.Println(env.AccessTokenExpiryHour)
	fmt.Println(env.AccessTokenSecret)
}

package route

import (
	"backend/bootstrap"

	"github.com/gin-gonic/gin"
	"github.com/swaggo/files"
	"github.com/swaggo/gin-swagger"
)

func NewSwagDocRouter(env *bootstrap.Env, group *gin.RouterGroup) {
	group.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))
}

package main

import (
    _ "yourmodule/docs"
)

package main

import (
	"fmt"
	"time"
)

func main() {
	go func() {
		for i := 10; i < 20; i   {
			fmt.Print(i, " ")
		}
	}()

	go function()

	time.Sleep(1 * time.Second)
}

func function() {
	for i := 0; i < 10; i   {
		fmt.Print(i)
	}
	fmt.Println()
}

package main

import (
	"flag"
	"fmt"
	"time"
)

func main() {
	n := flag.Int("n", 10, "Number of goroutines")
	flag.Parse()

	count := *n
	fmt.Printf("Going to create %d goroutines.\n", count)

	for i := 0; i < count; i   {
		go func(x int) {
			fmt.Printf("%d ", x)
		}(i)
	}

	time.Sleep(time.Second)
	fmt.Println("\nExiting...")
}

package main

import (
	"flag"
	"fmt"
	"sync"
)

func main() {
	n := flag.Int("n", 10, "Number of goroutines")
	flag.Parse()

	count := *n
	fmt.Printf("Going to create %d goroutines.\n", count)

	var waitGroup sync.WaitGroup
	
	fmt.Printf("%#v\n", waitGroup)
	for i := 0; i < count; i   {
		waitGroup.Add(1)
		go func(x int) {
			defer waitGroup.Done()
			fmt.Printf("%d ", x)
		}(i)
	}

	fmt.Printf("\n%#v\n", waitGroup)
	waitGroup.Wait()
	fmt.Println("\nExiting...")
}

package main

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan int)
	go writeToChannel(c, 10)
	time.Sleep(1 * time.Second)
}

func writeToChannel(c chan int, x int) {
	fmt.Println(x)
	c <- x

    // ignored because no one reads contents in channel
	close(c)
	fmt.Println(x)
}

// c is a chan, v is a value, k is a variable
// c, v, and k have the same value type

// write
c <- v

// read
k := <- c

package main

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan int)
	go writeToChannel(c, 10)
	time.Sleep(1 * time.Second)
	fmt.Println("Read:", <-c)
	time.Sleep(1 * time.Second)

	_, ok := <- c

	if ok {
		fmt.Println("Channel is open!")
	} else {
		fmt.Println("Channel is closed!")
	}
}

func writeToChannel(c chan int, x int) {
	fmt.Println("1", x)
	c <- x
	close(c)
	fmt.Println("2", x)
}

package main

import (
	"fmt"
	"math/rand"
	"os"
	"strconv"
	"time"
)

var CLOSEA = false				// checked by first(), altered bt second()
var DATA = make(map[int]bool)

func main() {
	if len(os.Args) != 3 {
		fmt.Println("Need two integer parameters!")
		os.Exit(1)
	}

	n1, _ := strconv.Atoi(os.Args[1])
	n2, _ := strconv.Atoi(os.Args[2])

	if n1 > n2 {
		fmt.Printf("%d should be smaller than %d\n", n1, n2)
		return
	}

	rand.Seed(time.Now().UnixNano())

	A := make(chan int) // for input
	B := make(chan int) // for output

	go first(n1, n2, A)
	go second(B, A)
	third(B)
}

func random(min, max int) int {
	return min   rand.Intn(max - min)
}

func first(min, max int, out chan<- int) {
	for {
		if CLOSEA {
			close(out)
			return
		}
		out <- random(min, max)
	}
}

func second(out chan<- int, in <-chan int) {
	for x := range in {
		fmt.Print(x, " ")

		_, ok := DATA[x]

		if ok {
			CLOSEA = true
		} else {
			DATA[x] = true
			out <- x
		}
	}

	fmt.Println()
	close(out)
}

func third(in <-chan int) {
	sum := 0

	for x := range in {
		sum  = x
	}

	fmt.Printf("The sum of the random numbers is %d.\n", sum)
}

package main

import (
	"fmt"
	"os"
	"strconv"
	"time"
)

func main() {
	start := time.Now()

	if len(os.Args) != 3 {
		fmt.Println("Need two integer parameters")
		os.Exit(1)
	}

	n1, _ := strconv.Atoi(os.Args[1])
	n2, _ := strconv.Atoi(os.Args[2])

	if n1 > n2 {
		fmt.Printf("%d should be less than %d\n", n1, n2)
	}

	// sum := 0

	// for i := n1; i <= n2; i   {
	// 	sum  = i*i
	// }

	// fmt.Println(sum)

	A := make(chan int)
	B := make(chan int)

	go first(n1, n2, A)
	go second(A, B)
	third(B)

	fmt.Println(time.Since(start))
}

func first(min, max int, out chan<- int) {
	i := min

	for i <= max {
		out <- i
		i  
	}

	close(out)
}

func second(in <-chan int, out chan<- int) {
	for i := range in {
		out <- i * i
	}

	close(out)
}

func third(in <-chan int) {
	sum := 0

	for x := range in {
		sum  = x
	}

	fmt.Println(sum)
}

package main

import (
	"fmt"
	"math/rand"
	"os"
	"strconv"
	"time"
)

func main() {
	rand.Seed(time.Now().Unix())
	createNumber := make(chan int)
	end := make(chan bool)

	if len(os.Args) != 2 {
		fmt.Println("Please give me an integer!")
		return
	}

	n, _ := strconv.Atoi(os.Args[1])
	fmt.Printf("Going to create %d random numbers.\n", n)
	go gen(0, 2*n, createNumber, end)
	for i := 0; i < n; i   {
		fmt.Printf("%d ", <-createNumber)
	}

	time.Sleep(5 * time.Second)
	fmt.Println("Exiting...")
	end <- true
}

func gen(min, max int, createNumber chan int, end chan bool) {
	for {
		select {
		case createNumber <- rand.Intn(max - min)   min:
		case <-end:
			close(end)
			return
		case <-time.After(4 * time.Second):
			fmt.Println("\ntime.After()!")
		}
	}
}

package main

import (
	"fmt"
	"time"
)

func main() {
	c1 := make(chan string)

	go func() {
		fmt.Println("c1 start")
		time.Sleep(time.Second * 3) // simulate this task needs 3 seconds
		c1 <- "c1 is ok"
	}()

	select {
	case res := <-c1:
		fmt.Println(res)
	case <-time.After(time.Second * 1):
		fmt.Println("timeout c1")
	}

	c2 := make(chan string)

	go func() {
		fmt.Println("c2 start")
		time.Sleep(time.Second * 3) // simulate this task needs 3 seconds
		c2 <- "c2 is ok"
	}()

	select {
	case res := <-c2:
		fmt.Println(res)
	case <-time.After(time.Second * 4):
		fmt.Println("timeout c2")
	}
}

package main

import (
	"fmt"
	"os"
	"strconv"
	"sync"
	"time"
)

func main() {
	arguments := os.Args
	start := time.Now()

	if len(arguments) != 2 {
		fmt.Println("Need a time duration!")
		return
	}

	var w sync.WaitGroup
	w.Add(1)

	t, err := strconv.Atoi(arguments[1])

	if err != nil {
		fmt.Println(err)
		return
	}

	duration := time.Duration(int32(t)) * time.Millisecond
	fmt.Printf("Timeout period is: %d\n", duration)

	if timeout(&w, duration) {
		fmt.Println("Timed out!")
		fmt.Println(time.Since(start))
	} else {
		fmt.Println("OK!")
		fmt.Println(time.Since(start))
	}

	w.Done()

	if timeout(&w, duration) {
		fmt.Println("Timed out!")
		fmt.Println(time.Since(start))
	} else {
		fmt.Println("OK!")
		fmt.Println(time.Since(start))
	}
}

func timeout(w *sync.WaitGroup, t time.Duration) bool {
	temp := make(chan int)

	go func() {
		time.Sleep(5 *time.Second)
		defer close(temp)
		w.Wait()
	}()

	select {
		case  <-temp:
			return false
		case <-time.After(t):
			return true
	}
}

package main

import "fmt"

func main() {
	numbers := make(chan int, 5)
	counter := 10

	for i := 0; i < counter; i   {
		select {
		case numbers <- i:
		default:
			fmt.Println("Not enough space for", i)
		}
	}

	for i := 0; i < counter 5; i   {
		select {
		case num := <-numbers:
			fmt.Println(num)
		default:
			fmt.Println("No more numbers")
			break
		}
	}
}

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func  main() {
	c := make(chan int)

	go add(c)
	go send(c)

	time.Sleep(2 * time.Second)
}

func add(c chan int) {
	sum := 0
	t := time.NewTimer(time.Second)

	for {
		select {
		case input := <-c:
			sum  = input
		case <-t.C:
			c = nil		// it will be blocked
			fmt.Println(sum)
		}
	}
}

func send(c chan int) {
	for {
		c <- rand.Intn(10)
	}
}

package main

import (
	"fmt"
	"os"
	"strconv"
	"time"
)

var times int

func main() {
	arguments := os.Args

	if len(arguments) != 2 {
		fmt.Println("Need just one argument!")
		return
	}

	times, err := strconv.Atoi(arguments[1])

	if err != nil {
		fmt.Println(err)
		return
	}

	cc := make(chan chan int)

	for i := 1; i < times 1; i   {
		f := make(chan bool)

		go f1(cc, f)

		ch := <-cc
		ch <- i

		for sum := range ch {
			fmt.Printf("Sum of %d is %d\n", i, sum)
		}

		fmt.Println()
		time.Sleep(time.Second)
		close(f)
	}
}

func f1(cc chan chan int, f chan bool) {
	c := make(chan int)

	cc <- c
	defer close(c)

	sum := 0

	select {
	case x := <-c:
		for i := 0; i < x; i   {
			sum  = i
		}

		c <- sum
	case <-f:
		return
	}
}

package main

import (
	"fmt"
	"os"
	"strconv"
	"sync"
	"time"
)

var (
	m sync.Mutex
	v1 int
)

func main() {
	if len(os.Args) != 2 {
		fmt.Println("Please give me an integer!")
		return
	}

	numGR, err := strconv.Atoi(os.Args[1])

	if err != nil {
		fmt.Println(err)
		return
	}

	var waitGroup sync.WaitGroup

	fmt.Printf("%d", read())

	for i := 0; i < numGR; i   {
		waitGroup.Add(1)

		go func(x int) {
			defer waitGroup.Done()
			change(x)
			fmt.Printf("-> %d", read())
		}(i)
	}

	waitGroup.Wait()
	fmt.Printf("-> %d\n", read())
}

func change(i int) {
	m.Lock()

	// this section will be executed by only one goroutine at a time
	// this section is called critical section
	time.Sleep(time.Second)
	v1  = 1
	if v1 % 10 == 0 {
		v1 -= 10 * i
	}

	m.Unlock()
}

func read() int {
	m.Lock()
	a := v1
	m.Unlock()
	return a
}

package main

import (
	"fmt"
	"sync"
)

var m sync.Mutex

func main() {
	var w sync.WaitGroup

	go func() {
		defer w.Done()
		function()
	}()

	w.Add(1)

	go func() {
		defer w.Done()
		function()
	}()

	w.Add(1)

	w.Wait()
}

func function() {
	m.Lock()
	fmt.Println("Locked")
	// no unlock
}

package main

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

type secret struct {
	RWM sync.RWMutex
	M sync.Mutex
	password string
}

var password = secret{password: "myPassword"}

func Change(c *secret, pass string) {
	c.RWM.Lock()
	fmt.Println("LChange")
	time.Sleep(10 * time.Second)

	c.password = pass
	c.RWM.Unlock()
}

// Using RWMutex
func show(c *secret) string {
	c.RWM.RLock()
	fmt.Print("show")

	time.Sleep(3 * time.Second)
	defer c.RWM.RUnlock()
	
	return c.password
}

// Using Mutex
func showWithLock(c *secret) string {
	c.M.Lock()

	fmt.Print("showWithLock")

	time.Sleep(3 * time.Second)
	defer c.M.Unlock()

	return c.password
}

func main() {
	var showFunction = func(c *secret) string { return "" }

	if len(os.Args) != 2 {
		fmt.Println("Using sync.RWMutex!")
		showFunction = show
	} else {
		fmt.Println("Using sync.Mutex!")
		showFunction = showWithLock
	}

	var waitGroup sync.WaitGroup

	fmt.Println("Pass:", showFunction(&password))

	for i := 0; i < 15; i   {
		waitGroup.Add(1)

		// reader
		go func() {
			defer waitGroup.Done()
			fmt.Println("Go Pass:", showFunction(&password))
		}()

		// writer
		go func() {
			waitGroup.Add(1)
			defer waitGroup.Done()
			Change(&password, "123456")
		}()

		waitGroup.Wait()
		fmt.Println("Pass:", showFunction(&password))
	}
}

package main

import (
	"fmt"
	"os"
	"strconv"
	"sync"
)

func main() {
	arguments := os.Args
	if len(arguments) != 2 {
		fmt.Println("Please provide an integer")
		os.Exit(1)
	}

	numGR, err := strconv.Atoi(arguments[1])
	if err != nil {
		fmt.Println(err)
		return
	}

	var waitGroup sync.WaitGroup

	k := make(map[int]int)
	k[1] = 12

	for i := 0; i < numGR; i   {
		waitGroup.Add(1)
		go func(i int) {
			defer waitGroup.Done()
			k[i] = i
		}(i)
	}

	k[2] = 10
	waitGroup.Wait()
	fmt.Printf("k = %#v\n", k)
}

package main

import (
	"context"
	"fmt"
	"os"
	"strconv"
	"time"
)

func main() {
	if len(os.Args) != 2 {
		fmt.Println("Need a delay!")
		return
	}

	delay, err := strconv.Atoi(os.Args[1])

	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("Delay:", delay)

	f1(delay)
	f2(delay)
	f3(delay)
}

func f1(t int) {
	c1 := context.Background()
	c1, cancel := context.WithCancel(c1)
	defer cancel()

	go func() {
		time.Sleep(4 * time.Second)
		cancel()
	}()

	select {
	case <-c1.Done():
		fmt.Println("f1():", c1.Err())
		return
	case r := <-time.After(time.Duration(t) * time.Second):
		fmt.Println("f1():", r)
	}

	return
}

func f2(t int) {
	c2 := context.Background()
	c2, cancel := context.WithTimeout(c2, time.Duration(t) * time.Second)
	defer cancel()

	go func() {
		time.Sleep(4 * time.Second)
		cancel()
	}()

	select {
	case <-c2.Done():
		fmt.Println("f2():", c2.Err())
		return
	case r := <-time.After(time.Duration(t) * time.Second):
		fmt.Println("f2():", r)
	}

	return
}

func f3(t int) {
	c3 := context.Background()
	deadline := time.Now().Add(time.Duration(2 * t) * time.Second)
	c3, cancel := context.WithDeadline(c3, deadline)
	defer cancel()

	go func() {
		time.Sleep(4 * time.Second)
		cancel()
	}()

	select {
	case <-c3.Done():
		fmt.Println("f3():", c3.Err())
		return
	case r := <-time.After(time.Duration(t) * time.Second):
		fmt.Println("f3():", r)
	}

	return
}