interfaces

type Channel interface {
	Send(interface{})
	Get() []interface{}
	GetFirst() interface{}
	// Returns the Xth element in the channel.
	GetX(int) interface{}
	HasData() bool
	// Returns true if the channel has an Xth element in it.
	HasX(int) bool
}

type Channels interface {
	Select(string) Channel
}

type Client interface {
	StoreEncrypted(string, interface{}) error
	Store(string, interface{}) error
	Get(string) (interface{}, error)
	GetDecrypted(string) (interface{}, error)
	Unstore(string) error
	Languages() []string
}

type Conducting interface {
	Hooks() Hooks
	Events() Events
}

type Context interface {
	Conducting() Conducting
	FileSys() FileSys
	User() User
	Client() Client
	Db() Db
	Channels() Channels
	ViewContext() ViewContext
	NonPortable() NonPortable
	Display() Display
	Options() Options
}

type Db interface {
	NewFilter(string, map[string]interface{}) (Filter, error)
	ToId(string) (Id, error)
	NewId() Id
	Session() (Session, error)
}

type Directory interface {
	File(...string) File
	Directory(...string) Directory
	Remove() error
	Exists() (bool, error)
	List() ([]FileInfo, error)
	Create() error
	Rename(string) error
	Name() string
	Path() string
}

type Display interface {
	Writer() Writer
	Write([]byte) error
	Type(string) Display
}

type Document interface {
	Data() map[string]interface{}
	Id() Id
	Update(map[string]interface{}) error
	Remove() error
}

type DocumentPointer interface {
	Get() (Document, error)
	Update(map[string]interface{}) error
	Remove() error
	Id() Id
}

type Event interface {
	Publish([]byte) error
	Subscribe() error
	Unsubscribe() error
	Read() ([]byte, error)
}

type Events interface {
	Select(string) Event
}

type File interface {
	Create() error
	Exists() (bool, error)
	Write([]byte) error
	Read() ([]byte, error)
	Remove() error
	Rename(string) error
	Name() string
	Path() string // This is mostly here to be compatible with http.ServeFile
}

type FileInfo interface {
	Name() string
	IsDir() bool
	File() File
	Directory() Directory
}

type FileSys interface {
	// With the help of the SelectPlace one can (only) access
	// predefined places in the filesystem, eg: "modules" is mapped to /modules,
	// "template" is mapped to the current template in use, etc...
	SelectPlace(string) (Directory, error)
	Temporaries() Temporaries
}

type Filter interface {
	// Returns the Ids of the documents in the filtered set.
	Ids() ([]Id, error)
	// AddQuery will further filter the already filtered set. A filter should never refer to a larger subset of the set after the
	// AddQuery operation than before it.
	AddQuery(map[string]interface{}) Filter
	// Cloning a filter allows you to "branch" your filters.
	// Eg: (pseudocode)
	// fa := Filter{a:2}
	// fb := fa.Clone().AddQuery({b:3}) (equals: Filter{a:2,b:3})
	// fc := fa.Clone().AddQuery({d:4})	(equals: Filter{a:2,d:4})
	Clone() Filter
	// Reducing filters is a way to query foreign key relationships.
	Reduce(...Filter) (Filter, error)
	// Subject returns you the collectionname the filter refers to.
	Subject() string
	AddParents(string, []Id)
	Modifiers() Modifiers
	Count() (int, error)
	Iterate(func(Document) error) error
	// --
	FindOne() (map[string]interface{}, error)
	Find() ([]map[string]interface{}, error)
	SelectOne() (Document, error)
	Insert(map[string]interface{}) error
	// InsertAll([]map[string]interface{}) errors
	Update(map[string]interface{}) error
	UpdateAll(map[string]interface{}) (int, error)
	Remove() error
	RemoveAll() (int, error)
}

type Hook interface {
	Subscribers() []Subscriber
	HasSubscribers() bool
	SubscriberCount() int
	Fire(params ...interface{})
	Iterate(stopfunc interface{}, params ...interface{})
}

type Hooks interface {
	Select(string) Hook
	Module(string) Module
}

type Id interface {
	IAmAnId()
	String() string
}

type Instance interface {
	HasMethod(string) bool // Returns true if the Instance has a method with the name supplied.
	MethodNames() []string // Returns all public method names of Instance.
	Method(string) Method
}

type Method interface {
	Call(interface{}, ...interface{}) error // First param is the return reciever function, others are input arguments for the Method.
	Matches(interface{}) bool               // Returns true if the Method matches the signature of the supplied function.
	InputTypes() []reflect.Type
	OutputTypes() []reflect.Type
}

type Modifiers interface {
	Sort() []string
	Limit() int
	Skip() int
}

type Module interface {
	Instance() Instance
	Exists() bool
}

type NestedData interface {
	Get(...string) (interface{}, bool)
	GetI(...string) (int64, bool)
	GetF(...string) (float64, bool)
	GetM(...string) (map[string]interface{}, bool)
	GetS(...string) ([]interface{}, bool)
	GetStr(...string) (string, bool)
	Exists(...string) bool
	All() interface{}
}

type NonPortable interface {
	Resource() string
	Params() map[string]interface{}
	Redirect(string) // Not sure about this.
	ComingFrom() string
	View() bool
	RawParams() string
	ServeFile(File) error
	ServeDir(Directory) error
}

type Options interface {
	Document() NestedData
	Modifiers() NestedData
}

type QueryMod interface {
	Skip(int)
	Limit(int)
	Sort(...string)
}

type ReadableFile interface {
	Read() ([]byte, error)
	Name() string
}

type Session interface {
	// Select database.
	Db(string) (Db, error)
}

type Set interface {
	QueryMod
	Count(map[string]interface{}) (int, error)
	FindOne(map[string]interface{}) (map[string]interface{}, error)
	Find(map[string]interface{}) ([]map[string]interface{}, error)
	Insert(map[string]interface{}) error
	// InsertAll([]map[string]interface{}) errors
	Update(map[string]interface{}, map[string]interface{}) error
	UpdateAll(map[string]interface{}, map[string]interface{}) (int, error)
	Remove(map[string]interface{}) error
	RemoveAll(map[string]interface{}) (int, error)
	Name() string
}

type Speaker interface {
	IsNoun(string) bool
	NounHasVerb(string, string) bool
}

type Subscriber interface {
	Name() string
	Method() string
}

type Temporaries interface {
	Select(string) []ReadableFile
	Exists(string) bool
	Keys() []string
}

type User interface {
	Document
	Level() int
	Languages() []string
}

type ViewContext interface {
	Publish(string, interface{}) ViewContext
	Get() map[string]interface{}
}

type Writer interface {
	Write([]byte) (int, error)
}