const MinAutoLogout = 30 * time.Minute

var (
	ErrAlreadyAuthenticated = errors.New("Already authenticated")
	ErrAuthDisabled         = errors.New("Authentication disabled")
)

var (
	ErrNoMailboxSelected = errors.New("No mailbox selected")
	ErrMailboxReadOnly   = errors.New("Mailbox opened in read-only mode")
)

var (
	ErrNotAuthenticated = errors.New("Not authenticated")
)

type Append struct {
	commands.Append
}

type Authenticate struct {
	commands.Authenticate
}

type Capability struct {
	commands.Capability
}

type Check struct {
	commands.Check
}

type Close struct {
	commands.Close
}

type Conn interface {
	io.Reader

	// Server returns this connection's server.
	Server() *Server
	// Context returns this connection's context.
	Context() *Context
	// Capabilities returns a list of capabilities enabled for this connection.
	Capabilities() []string
	// WriteResp writes a response to this connection.
	WriteResp(res imap.WriterTo) error
	// IsTLS returns true if TLS is enabled.
	IsTLS() bool
	// TLSState returns the TLS connection state if TLS is enabled, nil otherwise.
	TLSState() *tls.ConnectionState
	// Upgrade upgrades a connection, e.g. wrap an unencrypted connection with an
	// encrypted tunnel.
	Upgrade(upgrader imap.ConnUpgrader) error
	// Close closes this connection.
	Close() error
	WaitReady()

	Info() *imap.ConnInfo
	// contains filtered or unexported methods
}

type ConnExtension interface {
	Extension

	// This function will be called when a client connects to the server. It can
	// be used to add new features to the default Conn interface by implementing
	// new methods.
	NewConn(c Conn) Conn
}

type Context struct {
	// This connection's current state.
	State imap.ConnState
	// If the client is logged in, the user.
	User backend.User
	// If the client has selected a mailbox, the mailbox.
	Mailbox backend.Mailbox
	// True if the currently selected mailbox has been opened in read-only mode.
	MailboxReadOnly bool
	// Responses to send to the client.
	Responses chan<- imap.WriterTo
	// Define if the connection is holding for IMAP IDLE updates
	IsIdle bool
	// Closed when the client is logged out.
	LoggedOut <-chan struct{}
}

type Copy struct {
	commands.Copy
}

type Create struct {
	commands.Create
}

type Delete struct {
	commands.Delete
}

type Expunge struct {
	commands.Expunge
}

type Extension interface {
	// Get capabilities provided by this extension for a given connection.
	Capabilities(c Conn) []string
	// Get the command handler factory for the provided command name.
	Command(name string) HandlerFactory
}

type Fetch struct {
	commands.Fetch
}

type Handler interface {
	imap.Parser

	// Handle this command for a given connection.
	//
	// By default, after this function has returned a status response is sent. To
	// prevent this behavior handlers can use imap.ErrStatusResp.
	Handle(conn Conn) error
}

type HandlerFactory func() Handler

type Idle struct {
	commands.Idle
}

type List struct {
	commands.List
}

type Login struct {
	commands.Login
}

type Logout struct {
	commands.Logout
}

type Move struct {
	commands.Move
}

type Noop struct {
	commands.Noop
}

type Rename struct {
	commands.Rename
}

type SASLServerFactory func(conn Conn) sasl.Server

type Search struct {
	commands.Search
}

type Select struct {
	commands.Select
}

type Server struct {

	// Message shown on connection greet
	Greeting string
	// Allow the IMAP IDLE capability to be disabled
	DisableIdle bool
	// Interval to send an "* OK Still here" message when in IDLE
	IdleNotify time.Duration
	// TCP address to listen on.
	Addr string
	// This server's TLS configuration.
	TLSConfig *tls.Config
	// This server's backend.
	Backend backend.Backend
	// Backend updates that will be sent to connected clients.
	Updates <-chan backend.Update
	// Automatically logout clients after a duration. To do not logout users
	// automatically, set this to zero. The duration MUST be at least
	// MinAutoLogout (as stated in RFC 3501 section 5.4).
	AutoLogout time.Duration
	// Allow authentication over unencrypted connections.
	AllowInsecureAuth bool
	// An io.Writer to which all network activity will be mirrored.
	Debug io.Writer
	// ErrorLog specifies an optional logger for errors accepting
	// connections and unexpected behavior from handlers.
	// If nil, logging goes to os.Stderr via the log package's
	// standard logger.
	ErrorLog imap.Logger
	// The maximum literal size, in bytes. Literals exceeding this size will be
	// rejected. A value of zero disables the limit (this is the default).
	MaxLiteralSize uint32
	// contains filtered or unexported fields
}

type StartTLS struct {
	commands.StartTLS
}

type Status struct {
	commands.Status
}

type Store struct {
	commands.Store
}

type Subscribe struct {
	commands.Subscribe
}

type Uid struct {
	commands.Uid
}

type UidHandler interface {
	Handler

	// Handle this command using UIDs for a given connection.
	UidHandle(conn Conn) error
}

type Unselect struct {
	commands.Unselect
}

type Unsubscribe struct {
	commands.Unsubscribe
}

type Upgrader interface {
	// Upgrade the connection. This method should call conn.Upgrade().
	Upgrade(conn Conn) error
}