model

type AfterClickNotify interface {
	// data del objeto que fue cliqueado por el usuario
	NotifyUserHasClickedObject()
}

type AfterCreate interface {
	SetObjectInDomAfterCreate(data ...map[string]string) (err string)
}

type AfterDelete interface {
	SetObjectInDomAfterDelete(data ...map[string]string) (err string)
}

type AfterRead interface {
	SetObjectInDomAfterRead(data ...map[string]string) (err string)
}

type AfterUpdate interface {
	SetObjectInDomAfterUpdate(data ...map[string]string) (err string)
}

type AlternativeValidateAdapter interface {
	ValidateData(its_new, its_update_or_delete bool, all_data ...map[string]string) (err string)
}

type AppInfo struct {
	App_name         string
	Business_name    string
	Business_address string
	Business_phone   string
}

type BackendBootDataUser interface {
	BackendLoadBootData(u *User) BootPageData
}

type BackendHandler struct {
	BootResponse

	CreateApi
	ReadApi
	UpdateApi
	DeleteApi
}

type BackupHandlerAdapter interface {
	//backup_type ej: "create","delete","update"
	BackupOneObjectType(backup_type, table_name string, data any)
}

type BeforeAction interface {
	ExecuteBeforeAction(h *MainHandler)
}

type BootPageData struct {
	JsonBootActions string
}

type BootResponse interface {
	AddBootResponse(u *User) (r []Response, err string)
}

type ButtonForm struct {
	ModuleName string // ej:c.Module
	ObjectName string // ej: c.Form.ObjectName
	ButtonName string // ej: btn_printer
	Title      string // ej: Imprimir
	IconID     string // ej: icon-printer
	OnclickFun string // ej: printForm(this)
	Disabled   bool   // activado por defecto
}

type CipherAdapter interface {
	Encrypt(content []byte) (out, err string)
	Decrypt(content string) (out, err string)
}

type ClickedModuleEventAdapter interface {
	ClickedModuleEvent()
}

type ContainerViewAdapter interface {
	BuildContainerView(id, field_name string, allow_skip_completed bool) string
}

type CookieExpiration struct {
	OneHour bool
	OneDay  bool
	Forever bool
}

type CreateApi interface {
	Create(u *User, data ...map[string]string) (err string)
}

type CutData struct {

	// ej Modelo Objeto: usuario := Object{Name: "Usuario",Fields: []Field{
	// 		{Name: "name"}, //0
	// 		{Name: "email"},//1
	// 		{Name: "phone"},//2
	// 	},}
	// ej data normal con todos los campos: {"name":"John Doe","email":"johndoe@example.com","phone":"555"}
	// version recortada Data: {"John Doe","johndoe@example.com","555"}
	// Index Objeto al codificar = {"0:0","1:1","2:2"}
	// ej no mail: {"marcel", "777"}
	// Index al codificar = {"0:0","1:2"}
	Index map[int8]int8 `json:"i"`
	//Data ej en mapa: "Data":[{"id":"222","name":"manzana","valor":"1200"}]
	// ahora: "Data":["222","manzana","1200"]
	Data []string `json:"d"`
}

type CutResponse struct {
	//Action,Object,Module,Message
	//ej: ["create","user","ModuleUsers","ok"]
	CutOptions []string  `json:"o,omitempty"`
	CutData    []CutData `json:"d,omitempty"`
}

type DataBaseAdapter interface {
	RunDBOnClient() bool //verdadero corren en el cliente ej browser. por defecto falso corre en el servidor
	// items support in server db: []map[string]string, map[string]string
	CreateObjectsInDB(table_name string, on_server_too bool, items any) (err string)

	ReadDataDB(p struct {
		FROM_TABLE    string              //ej: "users,products" or: public.reservation, public.patient"
		SELECT        string              // "name, phone, address" default *
		WHERE         []map[string]string //ej: "patient.id_patient=reservation.id_patient, (OR) reservation.id_staff = '2'"
		AND_CONDITION bool                // OR default se agrega AND si es true
		ID            string              // unique search (usado en indexdb)
		ORDER_BY      string              // name,phone,address
		SORT_DESC     bool                //default ASC
		LIMIT         int                 // 10, 5, 100. note: Postgres y MySQL: "LIMIT 10", SQLite: "LIMIT 10 OFFSET 0" OR "" no limit
		RETURN_ANY    bool                // default string return []map[string]string, any = []map[string]interface{}
	}, async_results func(r struct {
		String []map[string]string
		Any    []map[string]any
	}, err string)) (sync_results []map[string]string, err string)

	UpdateObjectsInDB(table_name string, on_server_too bool, data ...map[string]string) (err string)
	DeleteObjectsInDB(table_name string, on_server_too bool, data ...map[string]string) (err string)

	CreateTablesInDB(objects []*Object, result func(err string))

	ClearAllTableDataInDB(tables ...string) (err string)
}

type DataConverter interface {
	EncodeStruct(in any) (result []byte, err string)
	// &out is a pointer
	DecodeStruct(in []byte, out any) (err string)
	//map_in ej []map[string]string or map[string]string
	EncodeMaps(map_in any, object_name ...string) (out []byte, err string)
	DecodeMaps(in []byte, object_name ...string) (out []map[string]string, err string)

	EncodeResponses(requests ...Response) (out []byte, err string)
	DecodeResponses(data []byte) (out []Response, err string)
}

type DeleteApi interface {
	Delete(u *User, data ...map[string]string) (err string)
}

type DevicePeripherals struct {
	KeyboardClientAdapter
	GamepadClientAdapter
}

type DomAdapter interface {
	BuildFrontendUI() (err string)
	InnerHTML(querySelector, html_content string) (err string)
	InsertAfterBegin(querySelector, html_content string) (err string)
	InsertBeforeEnd(querySelector, html_content string) (err string)
	// querySelector ej: "a[name='xxx']"
	ElementClicking(querySelector string) (err string)
	ElementFocus(querySelector string) (err string)
	ElementsDelete(object_name string, on_server_too bool, objects_ids ...map[string]string) (err string)

	SelectContent(SelectDomOptions struct {
		QuerySelector string // ej: querySelector "meta[name='JsonBootTests']"
		GetContent    string //ej: GetContent: "content"
		SetAfter      bool   // SetAfter ej: true = element.Set("content", "")
		StringReturn  bool   //return_as_string retornar como string de lo contrario sera un jsValue
	}) (jsValue any, err string)

	CallFunction(NameJsFunc string, Options struct {
		Params       map[string]any // Objecto como parámetro
		ResultInt    bool           // resultado en formato int
		ResultString bool           // resultado en string
	}) (result any, err string)
}

type FetchAdapter interface {
	//method ej: GET,POST
	// endpoint ej: http://localhost/upload
	// object ej: imagen
	// body_rq any ej: []map[string]string, map[string]string
	SendOneRequest(method, endpoint, object string, body_rq any, response func(result []map[string]string, err string))
	// only POST method
	SendAllRequests(endpoint string, body_rq []Response, response func(result []Response, err string))
}

type Field struct {
	// si el campo comienza com id_ se considera como único y perteneciente a una tabla específica ej: id_user su tabla es user
	// otros ej: id_usuario, apellido, address, city etc
	Name          string
	Legend        string //como se mostrara al usuario el campo en el encabezado ej: "name" por "Nombre Usuario"
	SourceTable   string // tabla origen ej: patient,user,product
	NotRenderHtml bool   // si no se necesita en formulario html

	*Input

	NotClearValueOnFormReset bool
	SkipCompletionAllowed    bool //se permite que el campo no este completado. por defecto siempre sera requerido

	Unique          bool //campo único e inalterable en db
	NotRequiredInDB bool // campo no requerido en base de datos al crear tabla
	Encrypted       bool // si estará encriptado su almacenamiento o no
}

type FileApi interface {
	// FileAddUploadApi(h *MainHandler, source *Object, file_settings any) error
	//backend file_request ej: r *http.Request, w http.ResponseWriter
	//frontend file_request ej: blob file js.Value
	FileUpload(object_name, area_file string, file_request ...any) (out []map[string]string, err string)
	//params ej: id:123
	FilePath(params map[string]string) (file_path, area string, err string)
}

type FileDiskRW interface {
	FileGet(path string) (item any, err string)

	FileDelete(path string) (err string)
}

type FormAdapter interface {
	// limpia los valores del formulario y campos en el map del objeto
	// nombre de objeto opcional de lo contrario se usara el actual
	FormClean(object_name ...string) (err string)
	//validate valida después de completar,auto_grow hacer crecer los campos según el contenido
	FormComplete(object_name string, data map[string]string, validate, auto_grow bool) (err string)
	// si no se envía el nombre el campo se realiza foco en el primer elemento
	FormInputFocus(object_name string, focus_field_name ...string) (err string)
}

type FormNotify interface {
	NotifyFormIsOK()
	NotifyFormERR(err string)
}

type FrontendBootDataUser interface {
	FrontendLoadHtmlBootData(data string) (err string)
}

type FrontendHandler struct {
	AfterCreate
	AfterRead
	AfterUpdate
	AfterDelete

	AfterClickNotify

	NotifyBootData
	NotifyFileDelete

	ViewHandlerObject

	ResetFrontendObjectStateAdapter

	FormNotify
}

type FrontendModuleHandlers struct {
	ClickedModuleEventAdapter
}

type GamepadClientAdapter interface {
	GamepadRegister(notifyConnection, pressAnyButton, pressSpecificButtons any)
}

type Header struct {
	Name    string // ej: Content-Type, Auth
	Content string
}

type HtmlAdapter interface {
	// retorna un elemento html del tipo js.Value
	GetHtmlModule(module_name string) (jsValue any, err string)
}

type Icon struct {
	Id      string   //ej: icon-search, icon-btn-save, icon-btn-new
	ViewBox string   //ej: "0 0 16 16", "0 0 448 512"
	Paths   []string //ej: m11.51 11..,m7.051..,m3.267 15...
}

type Input struct {
	InputName string

	Tag
	ItemViewAdapter
	Validate

	ResetParameters *struct {
		ResetJsFuncName    string         // nombre la la función js a llamar para reset
		Enable             bool           //parámetro estado por defecto a enviar
		NotSendQueryObject bool           //no envía querySelector Objeto por defecto siempre se envía
		Params             map[string]any // parámetros adicionales
	}

	TestData
}

type ItemViewAdapter interface {
	BuildItemsView(all_data ...map[string]string) (html string)
}

type KeyEnterAdapter interface {
	KeyEnter()
}

type KeyboardClientAdapter interface {
	KeyboardClientDisable(disable bool)
}

type KeyboardHandlerObject struct {
	KeyEnterAdapter
}

type Logger interface {
	// pare usar Log en una lines en funciones de tipo syscall/js se usa interface{}
	Log(message ...any)
}

type MainHandler struct {
	ProductionMode    bool
	FrontendExecution bool
	FileRootFolder    string // default "app_files"
	AppInfo

	SessionFrontendAdapter
	SessionBackendAdapter

	BackendBootDataUser
	FrontendBootDataUser

	ThemeAdapter
	DataBaseAdapter
	BackupHandlerAdapter
	TimeAdapter

	DomAdapter
	FormAdapter
	HtmlAdapter

	CipherAdapter
	DataConverter
	FetchAdapter

	FileApi
	FileDiskRW

	DevicePeripherals

	MessageAdapter
	Logger
	// contains filtered or unexported fields
}

type MessageAdapter interface {
	UserMessage(message ...any)
}

type Module struct {
	//nombre modulo ej: chat,patient,user
	ModuleName string
	//Titulo que vera el usuario ej: "Modulo Fotografía"
	Title string
	// id icono para utilizar en sprite svg ej: icon-info
	IconID string
	//interfaz usuario modulo
	UI
	// ej: keyboard,focus
	FrontendModuleHandlers
	//areas soportadas por el modulo ej: 'a','t','x'
	Areas map[string]string

	*MainHandler
	// contains filtered or unexported fields
}

type ModuleFrontend interface {
}

type NotifyBootData interface {
	NotifyBootDataIsLoaded()
}

type NotifyFileDelete interface {
	NotifyFileDeletion()
}

type Object struct {
	// ej: module.client, client.search_footer,user.datalist
	ObjectName string
	Table      string //tabla origen db ej: users

	PrincipalFieldsName []string //campos mas representativos ej: name, address, phone
	NoAddObjectInDB     bool
	Fields              []Field //campos

	*Module // módulo origen

	BackHandler BackendHandler

	FrontHandler FrontendHandler

	KeyboardHandlerObject

	FormData map[string]string // data temporal formulario

	AlternativeValidateAdapter
}

type ObjectsHandlerAdapter interface {
	// optional object_name or table_name ej: file.user,"" or "","user"
	GetObjectBY(object_name, table_name string) (o *Object, err string)
	GetAllObjects(only_type_db_table bool) (objects []*Object)
}

type Package struct {
	SkipMeInResponse bool     `json:"-"` //  saltarme al difundir
	Recipients       []string `json:"-"` // lista de ip, token o ids según app para el reenvió al finalizar solicitud
	TargetArea       bool     `json:"-"` // si es falso el destino por defecto es publico de lo contrario sera para todos quines tengan la misma area del usuario solicitante
	Response
}

type Page struct {
	StyleSheet string // url ej style.css

	AppName    string
	AppVersion string

	SpriteIcons string

	Menu string

	UserName string
	UserArea string
	Message  string

	Modules string

	Script string // ej main.js

	// JsonBootActions string //index ej <meta name="JsonBootActions" content="{{.JsonBootActions}}">
	// JsonBootTests   string
	BootPageData
}

type Permission struct {
	Read  bool
	Write bool
}

type ReadApi interface {
	Read(u *User, data ...map[string]string) (out []map[string]string, err string)
}

type ReadData interface {
	ReadByID(id string) (out []map[string]string, err string)
}

type Request struct {
	//usuario que ejecuta la solicitud
	*User
	// paquetes de solicitud y respuesta
	Packages []Package
}

type ResetFrontendObjectStateAdapter interface {
	ResetFrontendObjectState() (err string)
}

type ResetViewHandlerObjectAdapter interface {
	ResetViewHandlerObject() (err string)
}

type Response struct {
	Action  string              `json:"a,omitempty"` //acción a realizar con la solicitud: create, read, update, delete o error
	Object  string              `json:"o,omitempty"` //nombre de la tabla u objeto controlador hacia donde va la solicitud
	Message string              `json:"g,omitempty"` //mensaje para el usuario de la solicitud
	Data    []map[string]string `json:"d,omitempty"` //data entrada y respuesta json
}

type Responses struct {
	NoCut []Response    `json:"n,omitempty"` // normal
	Cut   []CutResponse `json:"c,omitempty"` //re cortada
}

type SessionBackendAdapter interface {
	// params ej: r *http
	BackendCheckUser(r_http any) (u *User, err string)
	SessionHandlerAdapter
}

type SessionFrontendAdapter interface {
	FrontendCheckUser(result func(u *User, err string))
	SessionHandlerAdapter
}

type SessionHandlerAdapter interface {
	SessionHandlerName() string
	UserSessionNumber
}

type SourceData interface {
	SourceData() map[string]string
}

type Tag interface {
	HtmlName() string
	ContainerViewAdapter
}

type TemplateModuleConfig struct {
	RenderAllSpaceCentered bool // ej para login
	Module                 *Module
	// ej:	`<div class="target-module">
	// 	<select name="select">
	// 		<option value="value1">Value 1</option>
	// 		<option value="value2" selected>Value 2</option>
	// 	</select>
	// </div>`
	HeaderInputTarget string

	Form        *Object
	FormButtons []*ButtonForm

	AsideList ContainerViewAdapter
}

type TestData interface {
	GoodTestData() (out []string)
	WrongTestData() (out []string)
}

type ThemeAdapter interface {
	// MenuButtonTemplate ej: <li class="navbar-item"><a href="#` + module_name + `" tabindex="` + index + `" class="navbar-link" name="` + module_name + `">
	// <svg aria-hidden="true" focusable="false" class="fa-primary"><use xlink:href="#` + icon_id + `" /></svg>
	// <span class="link-text">` + title + `</span></a></li>
	MenuButtonTemplate(module_name, index, icon_id, title string) string
	MenuClassName() string     // ej: .menu-container
	MenuItemClass() string     // ej: navbar-item
	RouterJSFuncName() string  //ej:"menuRouter"
	ModuleClassName() string   //ej: slider_panel
	MenuClassSelected() string //ej: hash-selected

	ModuleTemplate(*TemplateModuleConfig) string

	FunctionMessageName() string // ej: ShowMessageToUser
	// ej query: "div#"+o.ModuleName+" [data-id='"+o.ObjectName+"']"
	QuerySelectorMenuModule(module_name string) string
	QuerySelectorModule(module_name string) string
	QuerySelectorObject(module_name, object_name string) string
	QuerySelectorUserName() string
	QuerySelectorUserArea() string
}

type TimeAdapter interface {
	TimeNow
	TimeWeek
	UnixTimeHandler

	//esperar en milliseconds ej: 500, 2000 ..
	WaitFor(milliseconds int, callback func())

	// new_date ej: 2003-11-22 o "" para volver al estado normal
	SetDate(new_date string)
}

type TimeNow interface {
	//ej true: "30-12-2001", default false: "2006-01-02"
	DateToDay(DateFormatStructPointer any) string
	//ej default: "2006-01-02", "15:04" WithSeconds true = 15:04:05
	DateToDayHour(DateFormatStructPointer any) (date, hour string)
}

type TimeWeek interface {
	//date ej: 2006-01-02,  0 para Domingo, 1 para Lunes, etc.
	WeekDayNumber(date_in string) (n int, err string)
}

type UI interface {
	UserInterface(u *User) string
}

type UnixTimeHandler interface {
	UnixNano() int64
}

type UpdateApi interface {
	Update(u *User, data ...map[string]string) (err string)
}

type User struct {
	Token          string // token de sesión solicitante
	Id             string // id usuario
	Ip             string
	Name           string
	Area           string // valor de carácter ej: a,s,p... key "" sin area
	AreaName       string // nombre del area
	AccessLevel    string // aquí valor numérico 0 a 255
	LastConnection string //time.Time

	R any //r *http.Request.
	W any //w http.ResponseWriter
}

type UserSessionNumber interface {
	// ej: 1 or 2 or 34 or 400.....
	UserSessionNumber() (number string, err string)
}

type Validate interface {
	//options html ej: data-option="ch_doc"
	ValidateField(data_in string, skip_validation bool, options ...string) (err string)
}

type ViewHandlerObject interface {
	ViewHandlerName() string
	ContainerViewAdapter
	ItemViewAdapter
	ResetViewHandlerObjectAdapter
	NotifyStatusChangeAfterClicking()
}