braza

type App struct {
	// Main Router
	*Router

	// Main Config
	*Config

	/*
		custom auth parser
			app.BasicAuth = (ctx *braza.Ctx) {
				a := ctx.Request.Header.Get("Authorization")
				if a != ""{
					...
					return user,pass, true
				}
				return "","",false
			}
	*/
	BasicAuth func(*Ctx) (user string, pass string, ok bool) // custom func to parse Authorization Header
	/*
		exec after each request (if the application dont crash)
			app.AfterRequest = (ctx *braza.Ctx) {
				h := ctx.Response.Header()
				h.Set("X-Foo","Bar")
				ctx.Response.SetHeader(h)
				...
			}
	*/
	AfterRequest Func

	/*
		exec before each request
			app.BeforeRequest = (ctx *braza.Ctx) {
				db := database.Open()
				ctx.Global["db"] = db
				user,pass,ok := ctx.Request.BasicAuth()
				if ok {
					ctx.Global["user"] = user
				}
			}
	*/
	BeforeRequest Func

	/*
		exec after close each conn ( this dont has effect in response)
			app.TearDownRequest = (ctx *braza.Ctx) {
				database.Close()
				log.Print(...)
				...
			}
	*/
	TearDownRequest Func

	// The Http.Server
	Srv *http.Server
	// contains filtered or unexported fields
}

type Config struct {
	Env                     string           // environmnt (default 'development')
	SecretKey               string           // for sign session (default ”)
	Servername              string           // for build url routes and route match (default ”)
	ListeningInTLS          bool             // UrlFor return a URl with schema in "https:" (default 'false')
	TemplateFolder          string           // for render Templates Html. Default "templates/"
	TemplateFuncs           template.FuncMap `validate:"-"`
	DisableParseFormBody    bool             // Disable default parse of Request.Form -> if true, use Request.ParseForm()
	DisableTemplateReloader bool             // if app in dev mode, disable template's reload (default false)
	StaticFolder            string           // for serve static files (default '/assets')
	StaticUrlPath           string           // url uf request static file (default '/assets')
	DisableStatic           bool             // disable static endpoint for serving static files (default false)
	Silent                  bool             // don't print logs (default false)
	DisableWarnOn405        bool
	LogFile                 string // save log info in file (default ”)
	DisableFileWatcher      bool   // disable autoreload in dev mode (default false)

	SessionExpires          time.Duration `validate:"-"` // (default 30 minutes)
	SessionPermanentExpires time.Duration `validate:"-"` // (default 31 days)

	SessionPublicKey  *rsa.PublicKey  `validate:"-"`
	SessionPrivateKey *rsa.PrivateKey `validate:"-"`
	// contains filtered or unexported fields
}

type Cors struct {
	MaxAge string // Access-Control-Max-Age
	// ex:
	//  []string{"example.com","www.example.com"}
	AllowOrigins []string // Access-Control-Allow-Origin
	// ex:
	// 	[]string{"*","GET","POST"}
	AllowMethods []string // Access-Control-Allow-Methods
	// ex:
	// []string{"Authorization","*"}
	AllowHeaders []string // Access-Control-Allow-Headers
	// ex:
	// []string{"X-Header"}
	ExposeHeaders    []string // Access-Control-Expose-Headers
	RequestMethod    string   // Access-Control-Request-Method
	AllowCredentials bool     // Access-Control-Allow-Credentials
	// contains filtered or unexported fields
}

type Ctx struct {
	// Clone Current App
	App *App

	/*
		global variables of current request
			app.BeforeRequest = (ctx *braza.Ctx){
				db := database.Open().Session()
				ctx.Global["db"] = db
				user := db.FindUser()
				ctx.Global["user"] = user

			}
			func index(ctx *braza.Ctx){
				db := ctx.Global["db"].(database.DB)
				user := ctx.Global["user"].(*User)
				...
			}
	*/
	Global map[string]any

	/*
		Current Cookie Session
		func login(ctx *braza.Ctx){
				db := ctx.Global["db"].(database.DB)
				username,pass,ok := ctx.Request.BasicAuth()
				if ok{
					user := &User{}
					db.Where("username = ?",username).Find(user)
					if user.CompareHashPass(pass){
						ctx.Session.Set("user",user.id)
					}
				}
				ctx.Unauthorized()
			}
	*/
	Session *Session

	/*
		Current Response
			func foo(ctx *braza.Ctx) {
				ctx.JSON(map[string]any{
					"foo":"bar",
				}, 200)
			}
			func foo(ctx *braza.Ctx) {
				ctx.HTML("<h1>Hello</h1>",200)
			}
			func foo(ctx *braza.Ctx) {
				ctx.RenderTemplate("index.html")
		  	}
	*/
	*Response

	/*
		Current Request
	*/
	Request *Request

	/*
		New Schema valid from route schema
			Route{
				Url:"/{foo}/{bar:int}"
				Func: foo,
				Schema: &Schema{}
			}

			type Schema struct {
				Bar int `braza:"in=args"`
				Foo string `braza:"in=args"`
				File *braza.File `braza:"in=files"`
				Files []*braza.File `braza:"in=files"`
				XHeader string `braza:"in=headers"`
				User string `braza:"in=auth,name=username"`
				Pass string `braza:"in=auth,name=password"`
				Limit int `braza:"in=query"` // /path/search?limit=1&offset=2
				Offset int `braza:"in=query"` // /path/search?limit=1&offset=2

				Text string `braza:"in=body"`
				Text2 string  // deafult is 'in=body'.
			}

			func foo(ctx *braza.Ctx) {
				sch := ctx.Schema.(*Schema)
				...
			}
	*/
	Schema        Schema
	SchemaFielder *c3po.Fielder

	/*
		Contains information about the current request, route, etc...

		Can only be accessed if there is a match. otherwise the values ​​will be null
			func xpto(ctx *braza.Ctx) {
				route := ctx.Matchinfo.Route
				router := ctx.Matchinfo.Router
				...
			}
	*/
	MatchInfo *MatchInfo
	// contains filtered or unexported fields
}

type File struct {
	Filename     string
	ContentType  string
	ContentLeght int
	Stream       *bytes.Buffer
}

type Func func(ctx *Ctx)

type Jsonify interface {
	ToJson() any
}

type ManyJsonify[C Jsonify] []C

type ManyMapper[C Mapper] []Mapper

type MapCtrl map[string]*Meth

type Mapper interface {
	ToMap() map[string]any
}

type MatchInfo struct {
	Func
	Match            bool
	Route            *Route
	Router           *Router
	MethodNotAllowed error
	// contains filtered or unexported fields
}

type Meth struct {
	Func          Func
	Schema        Schema
	RespSchema    RespSchema
	SchemaFielder *c3po.Fielder
}

type Request struct {
	Header http.Header

	Body *bytes.Buffer
	Method,
	RemoteAddr,
	RequestURI,
	ContentType string

	ContentLength int

	URL      *url.URL
	Host     string
	Port     string
	Form     map[string]any
	PathArgs map[string]string
	Mime     map[string]string
	Query    url.Values
	Files    map[string][]*File
	Cookies  map[string]*http.Cookie

	TransferEncoding []string

	Proto      string // "HTTP/1.0"
	ProtoMajor int    // 1
	ProtoMinor int    // 0
	// contains filtered or unexported fields
}

type RespSchema map[int]any

type Response struct {
	*bytes.Buffer

	StatusCode int
	// contains filtered or unexported fields
}

type Route struct {
	/*
		# url patterns
			"" is same "/"
			"/batata"	// match literal "/batata"
			"/{name}"	// match any string (ex: batata1234)
			"/{id:int}"	// match on numbers (ex: 12345)
			"/{path:*}"	|| "/{path:path}" // match anything
			"/{var1:int}/{var2}/{var3}" // is allowed
			`/(\d+)` // regex work too
	*/
	Url string

	// # Route Name
	//	ctx.UrlFor("route Name"...
	Name string

	Func Func

	/*
		allow Cors on this route
		&Cors{
			AllowOrigins: []string{"example.com","www.example.com"},
			AllowMethods: []string{"*","GET","POST"},
			AllowHeaders: []string{"Authorization","*"},
			ExposeHeaders: []string{"X-Header"},
			AllowCredentials: true
		}
	*/
	Cors *Cors

	Schema     Schema
	RespSchema RespSchema

	/*
		# a peculiar way of establishing routes
			Route{
				Name:"foo",
				Url:"/foo",
				MapCtrl: braza.MapCtrl{
					"GET": &braza.Meth{
						Func: Foo,
						Schema: &SchemaFoo{}
					},
					"POST": &braza.Meth{
						Func: Bar,
						Schema: &SchemaBar{}
					},
					"DELETE": &braza.Meth{
						Func: Xpto,
						Schema: &SchemaXpto{}
					},
				},
			}
	*/
	MapCtrl MapCtrl

	// HTTP methods allowed on this route
	//		[]string{"GET","POST","PATCH",...
	Methods []string

	// Func wiil exec before this route
	//		[]Func{	GetUser, HasAUth,...
	Middlewares []Func
	// contains filtered or unexported fields
}

type Router struct {
	Cors        *Cors
	Name        string
	Routes      []*Route
	Prefix      string
	Subdomain   string // only {sub} or {sub:int}
	WsUpgrader  *websocket.Upgrader
	Middlewares []Func
	StrictSlash bool
	// contains filtered or unexported fields
}

type Schema any

type Session struct {
	Permanent bool
	// contains filtered or unexported fields
}