package oclib

import (
	"cloud.o-forge.io/core/oc-lib/dbs/mongo"
	"cloud.o-forge.io/core/oc-lib/logs"
	"cloud.o-forge.io/core/oc-lib/models"
	"cloud.o-forge.io/core/oc-lib/models/utils"
	"github.com/rs/zerolog"
)

type LibDataEnum int

const (
	INVALID             LibDataEnum = iota
	DATA_RESOURCE                   = utils.DATA_RESOURCE
	PROCESSING_RESOURCE             = utils.PROCESSING_RESOURCE
	STORAGE_RESOURCE                = utils.STORAGE_RESOURCE
	DATACENTER_RESOURCE             = utils.DATACENTER_RESOURCE
	WORKFLOW_RESOURCE               = utils.WORKFLOW_RESOURCE
	WORKFLOW                        = utils.WORKFLOW
)

func (d LibDataEnum) EnumIndex() int {
	return int(d)
}

type LibDataShallow struct {
	Data []utils.ShallowDBObject `bson:"data" json:"data"`
	Code int                     `bson:"code" json:"code"`
	Err  string                  `bson:"error" json:"error"`
}

type LibData struct {
	Data utils.DBObject `bson:"data" json:"data"`
	Code int            `bson:"code" json:"code"`
	Err  string         `bson:"error" json:"error"`
}

func Init(appName string) {
	logs.SetAppName(appName)
	logs.SetLogger(logs.CreateLogger("main", ""))
	mongo.MONGOService.Init(models.GetModelsNames(), GetConfig())
}

func GetLogger() zerolog.Logger {
	return logs.GetLogger()
}

func LoadAll(collection LibDataEnum) LibDataShallow {
	d, code, err := models.Model(collection.EnumIndex()).GetAccessor().LoadAll()
	if err != nil {
		return LibDataShallow{Data: d, Code: code, Err: err.Error()}
	}
	return LibDataShallow{Data: d, Code: code}
}

func LoadOne(collection LibDataEnum, id string) LibData {
	d, code, err := models.Model(collection.EnumIndex()).GetAccessor().LoadOne(id)
	if err != nil {
		return LibData{Data: d, Code: code, Err: err.Error()}
	}
	return LibData{Data: d, Code: code}
}

func UpdateOne(collection LibDataEnum, set map[string]interface{}, id string) LibData {
	model := models.Model(collection.EnumIndex())
	d, code, err := model.GetAccessor().UpdateOne(model.Deserialize(set), id)
	if err != nil {
		return LibData{Data: d, Code: code, Err: err.Error()}
	}
	return LibData{Data: d, Code: code}
}

func DeleteOne(collection LibDataEnum, id string) LibData {
	d, code, err := models.Model(collection.EnumIndex()).GetAccessor().DeleteOne(id)
	if err != nil {
		return LibData{Data: d, Code: code, Err: err.Error()}
	}
	return LibData{Data: d, Code: code}
}

func StoreOne(collection LibDataEnum, object map[string]interface{}) LibData {
	model := models.Model(collection.EnumIndex())
	d, code, err := model.GetAccessor().StoreOne(model.Deserialize(object))
	if err != nil {
		return LibData{Data: d, Code: code, Err: err.Error()}
	}
	return LibData{Data: d, Code: code}
}

func CopyOne(collection LibDataEnum, object map[string]interface{}) LibData {
	model := models.Model(collection.EnumIndex())
	d, code, err := model.GetAccessor().CopyOne(model.Deserialize(object))
	if err != nil {
		return LibData{Data: d, Code: code, Err: err.Error()}
	}
	return LibData{Data: d, Code: code}
}