// package kmonolit -- модульный монолит на основе ядра.
package kmonolit

import (
	"sync"

	"gitp78su.ipnodns.ru/svi/kern/v4/lev0"
	mL1 "gitp78su.ipnodns.ru/svi/kern/v4/lev1"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev1/comp_spec"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kctx"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kspec"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev3/mod_ent"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev3/mod_spec"
)

// kMonolit -- объект модульного монолита.
type kMonolit struct {
	kCtx    kspec.IKernelCtx
	lCtx    comp_spec.ILocalCtx
	log     comp_spec.ILogBuf
	name    mod_ent.AModuleName
	isLocal *lev0.LBool
	isWork  lev0.ISafeBool
	isEnd   lev0.ISafeBool
	dict    map[mod_ent.AModuleName]mod_spec.IKernelModule // Словарь модулей монолита
}

var (
	mon   *kMonolit
	block sync.Mutex
)

var (
	txtIsLocal = lev0.ATxt("isLocal")
)

// GetMonolit -- возвращает монолит.
func GetMonolit(name mod_ent.AModuleName) *kMonolit {
	block.Lock()
	defer block.Unlock()
	if mon != nil {
		return mon
	}
	lev0.If(name == "").Hassert("NewMonolit(): name is empty")
	kCtx := kctx.GetKernelCtx()
	opt := kCtx.Get(txtIsLocal)
	opt.Hassert("GetMonolit(): in get from kernCtx isLocal -- not found")
	isLocalCtx := opt.Some()
	isLocal := isLocalCtx.Val().(lev0.Bool)
	lCtx := mL1.NewLocalCtx(kCtx.Ctx())
	sf := &kMonolit{
		kCtx:    kCtx,
		lCtx:    lCtx,
		name:    name,
		dict:    map[mod_ent.AModuleName]mod_spec.IKernelModule{},
		isWork:  mL1.NewSafeBool(false),
		isEnd:   mL1.NewSafeBool(false),
		isLocal: lev0.LetBool(isLocal),
	}
	sf.log = sf.lCtx.Log()
	sf.kCtx.Set("monolitName", name, "name of monolit")
	sf.kCtx.Set("monolit", sf, "monolit-app")
	mon = sf
	_ = mod_spec.IKernelMonolit(sf)
	return sf
}

// Ctx -- возвращает контекст монолита.
func (sf *kMonolit) Ctx() comp_spec.ILocalCtx {
	return sf.lCtx
}

// Log -- возвращает лог монолита.
func (sf *kMonolit) Log() comp_spec.ILogBuf {
	return sf.lCtx.Log()
}

// Name -- возвращает имя монолита.
func (sf *kMonolit) Name() mod_ent.AModuleName {
	return sf.name
}

// Add -- добавляет модуль в монолит.
func (sf *kMonolit) Add(module mod_spec.IKernelModule) {
	sf.kCtx.RLock()
	defer sf.kCtx.RUnlock()
	lev0.If(module == nil).Hassert("kMonolit.Add(): module==nil", []any{})
	_, isOk := sf.dict[module.Name().Get()]
	lev0.If(lev0.Bool(isOk)).Hassert("kMonolit.Add(): module(%v) already exists", []any{module.Name()})
	sf.dict[module.Name().Get()] = module
	sf.log.Debug("kMonolit.Add(): module='%v'", module.Name())
	if sf.isWork.Get() {
		go module.Run()
		sf.log.Debug("kMonolit.Add(): module='%v' is run", module.Name())
	}
	key := lev0.LetTxt("module_%v", len(sf.dict))
	moduleName := module.Name()
	comment := lev0.LetTxt("kMonolit.Add(): module=" + moduleName.Txt().Get())
	sf.lCtx.Set(key.Get(), module, comment.Get())
}

// Run -- запускает монолит в работу.
func (sf *kMonolit) Run() {
	sf.kCtx.RLock()
	defer sf.kCtx.RUnlock()
	if sf.isEnd.Get() {
		return
	}
	if sf.isWork.Get() {
		return
	}
	sf.isWork.Set()
	for _, module := range sf.dict {
		go module.Run()
	}
	sf.log.Debug("kMonolit.Run()")
}

// IsLocal -- возвращает признак локальной шины.
func (sf *kMonolit) IsLocal() *lev0.LBool {
	return sf.isLocal
}

// IsWork -- возвращает признак работы монолита.
func (sf *kMonolit) IsWork() *lev0.LBool {
	res := sf.isWork.Get()
	return lev0.LetBool(res)
}

// Ожидание завершения работы монолита.
func (sf *kMonolit) Wait() {
	sf.kCtx.Wait()
	sf.kCtx.Wg().Wait()
	sf.kCtx.Lock()
	defer sf.kCtx.Unlock()
	sf.isWork.Reset()
	sf.isEnd.Set()
	sf.log.Debug("kMonolit.close(): end")
}