// package kern -- библиотека гибкого универсального облегчённого ядра для любого микросервиса.
package kern

import (
	"context"
	"fmt"

	mL0 "gitp78su.ipnodns.ru/svi/kern/v4/lev0"
	mKa "gitp78su.ipnodns.ru/svi/kern/v4/lev0/alias"
	mKt "gitp78su.ipnodns.ru/svi/kern/v4/lev0/ktypes"
	mL1 "gitp78su.ipnodns.ru/svi/kern/v4/lev1"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kbus_http"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kbus_http/client_bus_http"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kbus_local"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kbus_local/client_bus_local"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kctx"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kmodule"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kmonolit"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kserv_http"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kstore_kv"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev3/mod_kctx"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev3/mod_keeper"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev3/mod_serv_http"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev3/mod_wui"
)

// GetKernelCtx -- возвращает контекст ядра.
func GetKernelCtx() *mL0.Result[mKt.IKernelCtx] {
	resCtx := kctx.GetKernelCtx()
	if resCtx.IsErr() {
		err := fmt.Errorf("GetKernelCtx(): err=\n\t%w", resCtx.Err())
		return NewErr[mKt.IKernelCtx](err)
	}
	return NewRes(mKt.IKernelCtx(resCtx.Val()))
}

// NewErr -- возвращает Result с ошибкой.
func NewErr[T any](err error) *mL0.Result[T] {
	return mL0.NewErr[T](err)
}

// NewRes -- возвращает успешный Result с значением.
func NewRes[T any](res T) *mL0.Result[T] {
	return mL0.NewRes(res)
}

// WrapErr -- оборачивает существующий Result с ошибкой с новой ошибкой.
func WrapErr[T any](res *mL0.Result[T], err error) *mL0.Result[T] {
	return mL0.WrapErr(res, err)
}

// GetKernelStoreKv -- возвращает быстрое key-value хранилище ядра.
func GetKernelStoreKv() *mL0.Result[mKt.IKernelStoreKv] {
	resStore := kstore_kv.GetKernelStore()
	if resStore.IsErr() {
		err := fmt.Errorf("GetKernelStoreKv(): err=\n\t%w", resStore.Err())
		return NewErr[mKt.IKernelStoreKv](err)
	}
	store := mKt.IKernelStoreKv(resStore.Val())
	return NewRes(store)
}

// GetKernelServerHttp -- возвращает веб-сервер ядра.
func GetKernelServerHttp() *mL0.Result[mKt.IKernelServerHttp] {
	kernServHttp := kserv_http.GetKernelServHttp()
	return kernServHttp
}

// NewSafeBool -- возвращает новый потокобезопасный булевый признак.
func NewSafeBool() mKt.ISafeBool {
	sb := mL1.NewSafeBool()
	return sb
}

// GetKernelBusLocal -- возвращает локальную шину данных.
func GetKernelBusLocal() *mL0.Result[mKt.IKernelBus] {
	resCtx := kctx.GetKernelCtx()
	if resCtx.IsErr() {
		err := fmt.Errorf("GetKernelBusLocal(): err=\n\t%w", resCtx.Err())
		return NewErr[mKt.IKernelBus](err)
	}
	kCtx := resCtx.Val()
	resSet := kCtx.Set("monolitName", "unknown monolit", "GetKernelBusLocal()")
	if resSet.IsErr() {
		err := fmt.Errorf("GetKernelBusLocal(): err=\n\t%w", resSet.Err())
		return NewErr[mKt.IKernelBus](err)
	}
	resBus := kbus_local.GetKernelBusLocal()
	if resBus.IsErr() {
		err := fmt.Errorf("GetKernelBusLocal(): err=\n\t%w", resBus.Err())
		return NewErr[mKt.IKernelBus](err)
	}
	bus := mKt.IKernelBus(resBus.Val())
	return NewRes(bus)
}

// GetKernelBusHttp -- возвращает HTTP шину данных.
func GetKernelBusHttp() *mL0.Result[mKt.IKernelBus] {
	bus := kbus_http.GetKernelBusHttp()
	return bus
}

// SleepMs -- спит миллисекунду.
func SleepMs() {
	mL1.SleepMs()
}

// GetMonolitLocal -- возвращает монолит с локальной шиной.
func GetMonolitLocal(name string) *mL0.Result[mKt.IKernelMonolit] {
	resCtx := kctx.GetKernelCtx()
	if resCtx.IsErr() {
		err := fmt.Errorf("GetMonolitLocal(): err=\n\t%w", resCtx.Err())
		return NewErr[mKt.IKernelMonolit](err)
	}
	kCtx := resCtx.Val()
	resSet := kCtx.Set("isLocal", true, "bus type")
	if resSet.IsErr() {
		err := fmt.Errorf("GetMonolitLocal(): err=\n\t%w", resSet.Err())
		return NewErr[mKt.IKernelMonolit](err)
	}
	for {
		SleepMs()
		optIsLocal := kCtx.Get("isLocal")
		if optIsLocal.IsVal() {
			break
		}
	}
	res := kmonolit.GetMonolit(name)
	if res.IsErr() {
		err := fmt.Errorf("GetMonolitLocal(): err=\n\t%w", res.Err())
		return NewErr[mKt.IKernelMonolit](err)
	}
	_ = kbus_local.GetKernelBusLocal()
	return NewRes(mKt.IKernelMonolit(res.Val()))
}

// GetMonolitHttp -- возвращает монолит с локальной шиной поверх HTTP.
func GetMonolitHttp(name string) *mL0.Result[mKt.IKernelMonolit] {
	resCtx := kctx.GetKernelCtx()
	if resCtx.IsErr() {
		err := fmt.Errorf("GetMonolitHttp(): err=\n\t%w", resCtx.Err())
		return NewErr[mKt.IKernelMonolit](err)
	}
	kCtx := resCtx.Val()
	_ = kbus_http.GetKernelBusHttp()
	resSet := kCtx.Set("isLocal", false, "bus type")
	if resSet.IsErr() {
		err := fmt.Errorf("GetMonolitHttp(): err=\n\t%w", resSet.Err())
		return NewErr[mKt.IKernelMonolit](err)
	}
	for {
		SleepMs()
		optIsLocal := kCtx.Get("isLocal")
		if optIsLocal.IsVal() {
			break
		}
	}
	res := kmonolit.GetMonolit(name)
	if res.IsErr() {
		err := fmt.Errorf("GetMonolitHttp(): err=\n\t%w", res.Err())
		return NewErr[mKt.IKernelMonolit](err)
	}
	return NewRes(mKt.IKernelMonolit(res.Val()))
}

// NewKernelModule -- возвращает новый модуль на ядре.
func NewKernelModule(name *mKa.AModuleName) *mL0.Result[mKt.IKernelModule] {
	resMod := kmodule.NewKernelModule(name)
	return resMod
}

// NewClientBusLocal -- возвращает клиент для работы с локальной шиной.
func NewClientBusLocal() *mL0.Result[mKt.IBusClient] {
	res := client_bus_local.NewClientBusLocal()
	if res.IsErr() {
		err := fmt.Errorf("NewClientBusLocal(): err=\n\t%w", res.Err())
		return NewErr[mKt.IBusClient](err)
	}
	client := res.Val()
	return NewRes(client)
}

// NewClientBusHttp -- возвращает клиент для работы с шиной поверх HTTP.
func NewClientBusHttp(url string) *mL0.Result[mKt.IBusClient] {
	client := client_bus_http.NewClientBusHttp(url)
	return client
}

// GetModuleServHttp -- возвращает модуль для IKernelServHttp.
func GetModuleServHttp() *mL0.Result[mKt.IKernelModule] {
	resHttp := mod_serv_http.GetModuleServHttp()
	if resHttp.IsErr() {
		err := fmt.Errorf("GetModuleServHttp(): err=\n\t%w", resHttp.Err())
		return NewErr[mKt.IKernelModule](err)
	}
	modServHttp := resHttp.Val()
	return NewRes(mKt.IKernelModule(modServHttp))
}

// GetModuleKernelCtx -- возвращает модуль для IKernelCtx.
func GetModuleKernelCtx() *mL0.Result[mKt.IKernelModule] {
	resMod := mod_kctx.GetModuleKernelCtx()
	if resMod.IsErr() {
		err := fmt.Errorf("GetModuleKernelCtx(): err=\n\t%w", resMod.Err())
		return NewErr[mKt.IKernelModule](err)
	}
	mod := resMod.Val()
	return NewRes(mKt.IKernelModule(mod))
}

// GetModuleKernelKeeper -- возвращает модуль для IKernelKeeper.
func GetModuleKernelKeeper() *mL0.Result[mKt.IKernelModule] {
	resKeeper := mod_keeper.GetModuleKeeper()
	if resKeeper.IsErr() {
		err := fmt.Errorf("GetModuleKernelKeeper(): err=\n\t%w", resKeeper.Err())
		return NewErr[mKt.IKernelModule](err)
	}
	modKernelKeeper := resKeeper.Val()
	return NewRes(mKt.IKernelModule(modKernelKeeper))
}

// GetModuleWui -- возвращает модуль для WUI.
func GetModuleWui() *mL0.Result[mKt.IKernelModule] {
	resMod := mod_wui.GetModuleWui()
	if resMod.IsErr() {
		err := fmt.Errorf("GetModuleWui(): err=\n\t%w", resMod.Err())
		return NewErr[mKt.IKernelModule](err)
	}
	modWui := resMod.Val()
	return NewRes(mKt.IKernelModule(modWui))
}

// NewLogBuf -- возвращает новый буферизованный лог.
func NewLogBuf(opts ...mL1.OptionLogBuf) mKt.ILogBuf {
	log := mL1.NewLogBuf(opts...)
	return log
}

// NewSafeBoolReact -- возвращает новую потокобезопасную реактивную булеву переменную.
func NewSafeBoolReact() mKt.ISafeBoolReact {
	val := mL1.NewSafeBoolReact()
	return val
}

// NewSafeInt -- возвращает новую потокобезопасную целочисленную переменную.
func NewSafeInt(val int) mKt.ISafeInt {
	val_ := mL1.NewSafeInt(val)
	return val_
}

// NewInt -- возвращает новую целочисленную переменную.
func NewInt(val int) mKt.Int {
	val_ := mL1.NewInt(val)
	return val_
}

// NewLocalCtx -- возвращает новый локальный контекст.
func NewLocalCtx(ctx context.Context) *mL0.Result[mKt.ILocalCtx] {
	resCtx := mL1.NewLocalCtx(ctx)
	if resCtx.IsErr() {
		err := fmt.Errorf("NewLocalCtx(): err=\n\t%w", resCtx.Err())
		return NewErr[mKt.ILocalCtx](err)
	}
	ctx_ := resCtx.Val()
	return NewRes(ctx_)
}

// NewSafeString -- возвращает новую потокобезопасную строку.
func NewSafeString() mKt.ISafeString {
	str := mL1.NewSafeString()
	return str
}

// MakeOk -- возвращает новый положительный результат операции.
func MakeOk[T any](res T) *mL0.Result[T] {
	return NewRes(res)
}

// MakeErr -- возвращает новую ошибку результат операции.
func MakeErr[T any](err error) *mL0.Result[T] {
	return NewErr[T](err)
}

// NewOpt -- возвращает новый не пустой результат операции.
func NewOpt[T any](some T) *mL0.Option[T] {
	return mL0.NewOpt(some)
}

// NewNone -- возвращает новый пустой результат операции.
func NewNone[T any]() *mL0.Option[T] {
	return mL0.NewNone[T]()
}

// FnHassert -- проверяет с жёстким падением условие.
type FnHassert = mL1.FnHassert

// Hassert -- возвращает ссылку на функцию Hassert.
func Hassert() FnHassert {
	return mL1.Hassert()
}

// FnAssert -- проверка на правильность утверждения с падением в панику на локальном стенде (soft assert).
type FnAssert = mL1.FnAssert

// Assert -- возвращает ссылку на функцию Hassert.
func Assert() FnAssert {
	return mL1.Assert()
}