codec

type Codec interface {
	// MarshalErrors marshals given errors.
	MarshalErrors(w io.Writer, errors ...*Error) error
	// UnmarshalErrors unmarshal provided errors.
	UnmarshalErrors(r io.Reader) (MultiError, error)
	// MimeType returns the mime type that this codec is defined for.
	MimeType() string
}

type Error struct {
	// ID is a unique identifier for this particular occurrence of a problem.
	ID string `json:"id,omitempty"`
	// Title is a short, human-readable summary of the problem that SHOULD NOT change from occurrence to occurrence of the problem, except for purposes of localization.
	Title string `json:"title,omitempty"`
	// Detail is a human-readable explanation specific to this occurrence of the problem. Like title, this field’s value can be localized.
	Detail string `json:"detail,omitempty"`
	// Status is the status code applicable to this problem, expressed as a string value.
	Status string `json:"status,omitempty"`
	// Code is an application-specific error code, expressed as a string value.
	Code string `json:"code,omitempty"`
	// Meta is an object containing non-standard meta-information about the error.
	Meta Meta `json:"meta,omitempty"`
}

type FieldAnnotations struct {
	Name        string
	IsHidden    bool
	IsOmitEmpty bool
	Custom      []*mapping.FieldTag
}

type LinkOptions struct {
	// Type defines link type.
	Type LinkType
	// BaseURL should be the common base url for all the links.
	BaseURL string
	// Collection is the link root collection name.
	Collection string
	// RootID is the root collection primary value.
	RootID string
	// RelatedField is the related field name used in the relationship link type.
	RelationField string
}

type LinkType int

type MarshalOptions struct {
	Link         LinkOptions
	SingleResult bool
}

type Meta map[string]interface{}

type ModelMarshaler interface {
	// MarshalModels marshal provided models into given codec encoding type. The function should
	// simply encode only provided models without any additional payload like metadata.
	MarshalModels(models []mapping.Model, options MarshalOptions) ([]byte, error)
}

type ModelUnmarshaler interface {
	// UnmarshalModels unmarshals provided data into mapping.Model slice. The data should simply be only encoded models.
	UnmarshalModels(data []byte, options UnmarshalOptions) ([]mapping.Model, error)
}

type MultiError []*Error

type PaginationLinks struct {
	// Self should be just a query too
	Self  string `json:"self,omitempty"`
	First string `json:"first,omitempty"`
	Prev  string `json:"prev,omitempty"`
	Next  string `json:"next,omitempty"`
	Last  string `json:"last,omitempty"`

	Total int64 `json:"total"`
}

type ParameterExtractor interface {
	ExtractParameters(c *controller.Controller, q *query.Scope) (query.Parameters, error)
}

type ParameterParser interface {
	ParseParameters(c *controller.Controller, q *query.Scope, parameters query.Parameters) error
}

type Payload struct {
	// Payload defined model structure.
	ModelStruct *mapping.ModelStruct
	// Data contains models data.
	Data []mapping.Model
	// FieldSets is the index based field sets that maps it's indexes with the data.
	FieldSets []mapping.FieldSet
	// Meta is an object containing non-standard meta-information about the error.
	Meta Meta
	// IncludedRelations is the information about included relations in the payload.
	IncludedRelations []*query.IncludedRelation
	// Options are the options for the codecs how to treat the payload.
	PaginationLinks *PaginationLinks
	// MarshalLinks are the links used to marshal for specific codecs.
	MarshalLinks LinkOptions
	// MarshalSingularFormat marshals single model in a singular format for given codec.
	MarshalSingularFormat bool
}

type PayloadMarshaler interface {
	MarshalPayload(w io.Writer, payload *Payload) error
}

type PayloadUnmarshaler interface {
	UnmarshalPayload(r io.Reader, options UnmarshalOptions) (*Payload, error)
}

type UnmarshalOptions struct {
	StrictUnmarshal   bool
	IncludedRelations []*query.IncludedRelation
	ModelStruct       *mapping.ModelStruct
}