package main

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

var ctxBuffOne context.Context
var cancelBuffOne context.CancelFunc

var ctxBuffTwo context.Context
var cancelBuffTwo context.CancelFunc

var bufferOneOpen = true
var bufferTwoOpen = true

func main() {
    fmt.Printf("Stat application. PID: %d\n", os.Getpid())

    ctxBuffOne, cancelBuffOne = context.WithCancel(context.Background())
    ctxBuffTwo, cancelBuffTwo = context.WithCancel(context.Background())

    go handleSignal()
    go bufferOne()
    go bufferTwo()

    for {
        if !bufferOneOpen && !bufferTwoOpen {
            fmt.Println("Finish application")
            return
        }
    }
}

func bufferOne() {
    defer func() {
        //time.Sleep(1 * time.Second)
        fmt.Println("bufferOne defer run")
    }()

    for {
        select {
        case <-ctxBuffOne.Done():
            //time.Sleep(3 * time.Second)
            fmt.Println("bufferOne: Context stop!!!")
            bufferOneOpen = false
            return
        default:
            fmt.Printf("Run bufferOne. PID: %d\n", os.Getpid())
            time.Sleep(1 * time.Second)
        }
    }
}

func bufferTwo() {
    defer func() {
        fmt.Println("bufferTwo defer run")
    }()

    for {
        select {
        case <-ctxBuffTwo.Done():
            fmt.Println("bufferTwo: Context stop!!!")
            bufferTwoOpen = false
            return
        default:
            fmt.Printf("Run bufferTwo. PID: %d\n", os.Getpid())
            time.Sleep(1 * time.Second)
        }
    }
}

func handleSignal() {
    sigCh := make(chan os.Signal)
    signal.Notify(sigCh, syscall.SIGHUP, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGTERM)
    for {
        sig := <-sigCh
        switch sig {
        case syscall.SIGHUP:
            stopSignal("1", sigCh)
            return
        case syscall.SIGINT:
            stopSignal("2", sigCh)
            return
        case syscall.SIGQUIT:
            stopSignal("3", sigCh)
            return
        case syscall.SIGTERM:
            stopSignal("15", sigCh)
            return
        }
    }
}

func stopSignal(numSignal string, ch chan os.Signal) {
    signal.Stop(ch)
    fmt.Println("Handle signal " + numSignal)
    cancelBuffOne()
    cancelBuffTwo()
}