// package kserv_http -- встроенный HTTP-сервер.
package kserv_http

import (
	"embed"
	"fmt"
	"io/fs"
	"net/http"
	"os"
	"strings"
	"sync"
	"time"

	"github.com/gofiber/contrib/v3/monitor"
	"github.com/gofiber/fiber/v3"
	"github.com/gofiber/fiber/v3/middleware/compress"
	"github.com/gofiber/fiber/v3/middleware/static"

	mKs "gitp78su.ipnodns.ru/svi/kern/v4/lev0/core_spec"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev0/defs"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev0/defs/stream_name"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev0/etypes/ebool"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev0/helpers"
	mL1 "gitp78su.ipnodns.ru/svi/kern/v4/lev1"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev1/comp_spec"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev1/log_buf"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kctx"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kspec"
)

var (
	msg0       = defs.Txt("kernel_server_http")
	streamName = stream_name.NewAStreamName(msg0) // Контрольная строка для ожидателя потока
)

// kServHttp -- встроенный HTTP-сервер.
type kServHttp struct {
	kCtx     kspec.IKernelCtx
	lCtx     comp_spec.ILocalCtx
	log      comp_spec.ILogBuf
	strUrl   string // URL, на котором слушает HTTP-сервер
	fiberApp *fiber.App
	isWork   mKs.ISafeBool
	isEnd    mKs.ISafeBool
}

//go:embed static/*
var embedDirStatic embed.FS

var (
	kernServHttp *kServHttp
	block        sync.Mutex
	assert       = helpers.Assert
	hassert      = helpers.Hassert
)

func getParams() (string, comp_spec.ILogBuf, kspec.IKernelCtx) {
	param := &log_buf.LogBufParam{
		IsTerm_: mL1.NewSafeBool(true),
		Prefix_: defs.Txt("kServHttp"),
	}
	log := mL1.NewLogBuf(param)
	log.Debug(defs.Txt("GetKernelServHttp(): first run"))
	strLocalUrl := os.Getenv("LOCAL_HTTP_URL")
	hassert(strLocalUrl != "", "getParams(): env LOCAL_HTTP_URL not set")
	kCtx := kctx.GetKernelCtx()
	return strLocalUrl, log, kCtx
}

var msg1 = defs.Txt("GetKernelServHttp(): not have monolit name from kCtx")

// GetKernelServHttp -- возвращает  встроенный HTTP-сервер.
func GetKernelServHttp() kspec.IKernelServerHttp {
	block.Lock()
	defer block.Unlock()
	if kernServHttp != nil {
		kernServHttp.log.Debug(defs.Txt("GetKernelServHttp()"))
		return kernServHttp
	}
	strLocalUrl, log, kCtx := getParams()

	optMonolit := kCtx.Get(defs.Txt("monolitName"))
	optMonolit.Hassert(msg1)
	strMonolit := optMonolit.Some().Val().(string)
	confFiber := fiber.Config{
		ServerHeader: strMonolit,
		UnescapePath: true,
		ReadTimeout:  time.Second * 15,
		WriteTimeout: time.Second * 15,
		AppName:      strMonolit,
	}
	sf := &kServHttp{
		kCtx:     kCtx,
		log:      log,
		lCtx:     mL1.NewLocalCtx(kCtx.Ctx()),
		strUrl:   strLocalUrl,
		fiberApp: fiber.New(confFiber),
		isWork:   mL1.NewSafeBool(false),
		isEnd:    mL1.NewSafeBool(false),
	}
	sf.fiberApp.Use(compress.New(compress.Config{
		Level: compress.LevelBestCompression, // 2
	}))
	sf.fiberApp.Get("/static", static.New("/static", static.Config{
		FS:     fs.FS(embedDirStatic),
		Browse: true,
		MaxAge: 3600 * 24,
	}))
	// Или расширьте конфигурацию для индивидуальной настройки
	// Назначьте промежуточное программное обеспечение для /metrics
	// и измените заголовок на `Страница метрик MyService`
	sf.fiberApp.Get("/metrics", monitor.New(monitor.Config{
		Title: fmt.Sprintf("Страница метрик %q", strMonolit),
	}))
	sf.kCtx.Wg().Add(streamName)
	kCtx.Set(defs.Txt("fiberApp"), sf.fiberApp, defs.Txt("GetKernelServHttp() internal fiber app"))
	kernServHttp = sf
	kCtx.Set(defs.Txt("kServHttp"), kernServHttp, defs.Txt("kServHttp"))
	return kernServHttp
}

// IsWork -- возвращает признак работы.
func (sf *kServHttp) IsWork() mKs.EBool {
	res := sf.isWork.Get()
	return ebool.NewEBool(res)
}

// Log -- возвращает локальный лог.
func (sf *kServHttp) Log() comp_spec.ILogBuf {
	return sf.log
}

// Fiber -- возвращает объект веб-приложения fiber.
func (sf *kServHttp) Fiber() *fiber.App {
	return sf.fiberApp
}

// Run -- запускает сервер в работу (не блокирующий вызов).
func (sf *kServHttp) Run() {
	block.Lock()
	defer block.Unlock()
	if sf.isEnd.Get() {
		return
	}
	if sf.isWork.Get() {
		return
	}
	sf.log.Debug(defs.Txt("Run(): url='%v'", sf.strUrl))
	lstPort := strings.Split(sf.strUrl, ":")
	strPort := lstPort[len(lstPort)-1]
	strPort = strings.ReplaceAll(strPort, "/", "")
	strPort = strings.ReplaceAll(strPort, `"`, "")
	chErr := make(chan defs.IErr, 2)
	fnListen := func() {
		defer close(chErr)
		err := sf.fiberApp.Listen(":" + strPort)
		chErr <- defs.Err("kServHttp.Run().fnListen(): in listen server on port=%q, err=\n\t%v", strPort, err)
	}
	go fnListen()
	go sf.fnChErr(chErr)
	fnCheckServer := func() error {
		client := &http.Client{Timeout: 5 * time.Millisecond}
		url := sf.strUrl + "monitor"
		sf.log.Debug(defs.Txt("url=%v", url))
		var (
			resp *http.Response
			err  error
		)
		if resp, err = client.Get(url); err == nil {
			_ = resp.Body.Close()
		}
		return err
	}

	for {
		time.Sleep(time.Millisecond * 10)
		err := fnCheckServer()
		if err == nil {
			break
		}
	}

	sf.isWork.Set()
	go sf.close()
}

// В отдельном потоке ждёт закрытия канала.
func (sf *kServHttp) fnChErr(chErr <-chan defs.IErr) {
	err := <-chErr
	if err.Get() != "<nil>" {
		err := defs.Err("kServHttp.fnChErr(): in listen, err=\n\t%w", err)
		sf.log.Err(err)
		sf.kCtx.Cancel()
	}
}

// Ожидает окончания работы.
func (sf *kServHttp) close() {
	sf.kCtx.Wait()
	if !sf.isWork.Get() {
		return
	}
	sf.isWork.Reset()
	sf.isEnd.Set()
	err := sf.fiberApp.Server().Shutdown()
	assert(err == nil, "kServHttp.close(): in close server, err=\n\t%v", err)
	sf.kCtx.Wg().Done(streamName)
	sf.log.Debug(defs.Txt("close(): end"))
}