package main

import (
    "context"
    "encoding/json"
    "flag"
    "log"
    "net/http"
    "os"
    "os/signal"
    "path"
    "syscall"

    "github.com/go-chi/chi"
)

func main() {
    ctx := context.Background()
    // чтобы можно было подсовывать разнеые конфиги при запуске. Например, main.exe -c config-new.yaml
    configPath := flag.String("c", "config.yaml", "set config path")
    flag.Parse()

    // посмотри, что делает configure, это моя функция
    cfg, err := configure(*configPath)
    if err != nil {
        log.Fatalf("Can't configure, cause %s", err)
    }
    // Создание роутера, который занимается перенаправлением в нужный хендлер, в зависимости от пути
    r := chi.NewRouter()

    // curl -XGET localhost:8080/example/romik получишь в ответ Вонючий Ромик
    r.Get(path.Join(cfg.Name, "romik"), func(w http.ResponseWriter, req *http.Request) {
        log.Printf("Method = %s, URL = %s, Queries = %v", req.Method, req.URL.String(), req.URL.Query())
        // записываем ответ в ResponseWriter
        err := json.NewEncoder(w).Encode("Вонючий Ромик")
        if err != nil {
            log.Println(err)
        }
    })

    // curl -XGET localhost:8080/example/withname?name=romik, получишь в ответ romik
    r.Get(path.Join(cfg.Name, "withname"), func(w http.ResponseWriter, req *http.Request) {
        log.Printf("Method = %s, URL = %s, Queries = %v", req.Method, req.URL.String(), req.URL.Query())
        name := req.URL.Query().Get("name")
        if name == "" {
            log.Println("name param is missing")
            return
        }
        err := json.NewEncoder(w).Encode(name)
        if err != nil {
            log.Println(err)
        }
    })

    // curl -XGET localhost:8080/example/dynamic/romik получишь в ответ romik, /example/dynamic/nastya получишь в ответ nastya
    r.Get(path.Join(cfg.Name, "dynamic/{name}"), func(w http.ResponseWriter, req *http.Request) {
        log.Printf("Method = %s, URL = %s, Queries = %v", req.Method, req.URL.String(), req.URL.Query())
        name := chi.URLParam(req, "name")
        err := json.NewEncoder(w).Encode(name)
        if err != nil {
            log.Println(err)
        }
    })

    // curl -XPOST localhost:8080/example/post -d '{"name" : "romik"}' получишь в ответ romik
    r.Post(path.Join(cfg.Name, "post"), func(w http.ResponseWriter, req *http.Request) {
        log.Printf("Method = %s, URL = %s, Queries = %v", req.Method, req.URL.String(), req.URL.Query())
        body := map[string]interface{}{}
        // Парсим тело запроса (-d) в формате json в map[sting]interface{} (любой json можно представить в виде map[stroing]interface{})
        if err := json.NewDecoder(req.Body).Decode(&body); err != nil {
            log.Println(err)
            return
        }
        name, ok := body["name"]
        if !ok {
            log.Println("name field is missing")
            return
        }
        err = json.NewEncoder(w).Encode(name)
        if err != nil {
            log.Println(err)
        }
    })

    // Создание сервера, который и будет слушать на порту 8080, и перенаправлять на нужный хендрел с помощью r
    server := &http.Server{
        Addr:    cfg.ServerAddr,
        Handler: r,
    }

    go func() {
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatal(err)
        }
    }()

    log.Println("Start serving on", cfg.ServerAddr)
    defer server.Shutdown(ctx)
    // Прехватывание сигналов от операционной системы. Например, если ты нажмешь ctrl + c, то это будет syscall.SIGINT
    sgnl := make(chan os.Signal, 1)
    signal.Notify(sgnl,
        syscall.SIGHUP,
        syscall.SIGINT,
        syscall.SIGTERM,
        syscall.SIGQUIT)
    // Ждем сигнала, чтобы не завершился сразу мейн
    stop := <-sgnl
    log.Printf("Server stop with signal %s", stop.String())
}