mqtt

type Applyable interface {
	Apply(ctx *StateContext, pkg *Pkg, data []byte, pos int) (newPos int, err error)
}

type BasePacketBuilder struct {
	PacketIdentifer uint16
	// contains filtered or unexported fields
}

type ClientIdReadable interface {
	GetClientId() string
}

type ClientSubsHolder struct {
	// filters          []SubBlock
	// PacketIdentifier uint16
	Subs map[uint16][]SubBlock
}

type Config struct {
	Peers         string        `yaml:"peers"`
	Username      string        `yaml:"user"`
	Password      string        `yaml:"pass"`
	Db            int           `yaml:"db"`
	ReadonlyRoute bool          `yaml:"readonly-route"`
	DialTimeout   time.Duration `yaml:"dial-timeout"`
	ReadTimeout   time.Duration `yaml:"read-timeout"`
	WriteTimeout  time.Duration `yaml:"write-timeout"`
	EnableCluster bool          `yaml:"enable-cluster"`
	PoolSize      int           `yaml:"pool-size"`
	SubsChannels  []string      `yaml:"subs-channels"`
}

type ConnackBuilderOpt func(*connackBuilder)

type ConnackRetcode int

type ConnackVH struct {
	SessionPresent bool
	ReasonCode     ConnackRetcode
	// contains filtered or unexported fields
}

type ConnectBuilderOpt func(*connectBuilder)

type ConnectParam struct {
	ProtocolLevel     ProtocolLevel
	KeepAlivedSeconds uint16 // in seconds
	CleanSessionFlag  bool

	// WillFlag          bool
	WillQoS        QoSType
	WillRetainFlag bool

	// ClientId may be in or out property
	// For client, it's initialized by NewClient and NewMqttClientContext
	ClientId        string
	ClientIdCreated bool
	WillTopic       string
	WillMessage     []byte

	Username string
	Password string

	RetCode int // in this field, the connect packet errors will be kept and sent to client later
}

type ConnectPayload struct {
	ClientId        string
	ClientIdCreated bool
	WillTopic       string
	WillMessage     []byte
	Username        string
	Password        string

	RetCode int // in this field, the connect packet errors will be kept and sent to client later

	StrictClientId bool // should we verify the user's client id with strict rules?
}

type ConnectVH struct {
	ProtocolLevel ProtocolLevel
	ConnectFlag   byte

	KeepAlivedSeconds uint16 // in seconds
	CleanSessionFlag  bool   // Clean Start Flag for v5.0+
	WillFlag          bool
	WillQoS           QoSType
	WillRetainFlag    bool
	PasswordFlag      bool
	UsernameFlag      bool
	// contains filtered or unexported fields
}

type Contextual interface {
	GetContext() *StateContext
}

type ControlMessage struct {
	Message
}

type DataMessage struct {
	UniqueId          int64
	PackageIdentifier uint16
	Message
}

type DefaultSessionStoreOpt func(store *defaultSessionStore)

type Disconnect50BuilderOpt func(builder *disconnectBuilder)

type Hooker interface {
}

type IdStore interface {
	Has(key uint16) bool
	Get(key uint16, defaultValue ...interface{}) interface{}
	Set(key uint16, value interface{}) (err error)
}

type Message struct {
	QoS    QoSType
	Retain bool
	Topic  string
	Body   []byte
}

type Mode int

type PacketBuilder interface {
	ReportType() ReportType
	Build(ctx *StateContext, pkg *Pkg) (err error)
	Bytes() (bytes []byte)
	AsString() (str string)
	WriteTo(w io.Writer) (n int, err error)
	// NextPktId generate the packet identifier and store it, and return it too
	NextPktId(ctx *StateContext) uint16
	RequestResend()
	IsResending() bool
}

type PacketParser interface {
	GetToState() State
	CreateVH() VariantHeader
	CreatePayload() Payload
	OnAction(ctx *StateContext, pkg *Pkg) (err error)
	OnError(ctx *StateContext, pkg *Pkg, reason error) (err error)
}

type PacketParserMap struct {
	ToList               map[ReportType]PacketParser
	ToStateUnconditional State
}

type PathRW interface {
	Start(opts ...PathRWOpt)
	Stop()

	Load(dst *defaultSessionStore) (err error)
	Save(src *defaultSessionStore, tick time.Time) (err error)

	Get(pathKey string, defaultValue ...interface{}) (ret interface{}, err error)
	Set(pathKey string, value interface{}) (err error)
}

type PathRWOpt func(rw PathRW)

type Payload interface {
	Applyable
}

type Pkg struct {
	ReceivedTime time.Time

	HdrLen     int
	Length     int
	ReportType ReportType
	DUP        bool
	RETAIN     bool
	QoS        QoSType
	Flags      byte

	PacketIdentifier uint16
	VH               VariantHeader
	Payload          Payload

	// Data includes mqtt.VariantHeader + mqtt.Data.
	Data []byte
}

type ProtocolLevel byte

type PubBlock struct {
	TopicName string
	Payload   []byte
}

type PubCompPayload struct {
}

type PubCompVH struct{ Id uint16 }

type PubSubTask struct {
	SendingTask
	PacketIdentifier uint16
	SentTime         time.Time
	OnSent           func(task *PubSubTask, data []byte)
}

type PubackVH struct{ PacketIdentifier uint16 }

type Pubinfo struct {
	// contains filtered or unexported fields
}

type PublishBuilderOpt func(*publishBuilder)

type PublishPayload struct {
	Data []byte // by app
}

type PublishVH struct {

	// DUP, QoS, RETAIN
	Topic            string
	PacketIdentifier uint16 // unless QoS in 1 or 2
	// contains filtered or unexported fields
}

type QoSType int

type ReportType uint

type RiskControl interface {
	Disable(disable bool)
	IsEnabled() bool
}

type SendPayload func(ctx *StateContext, clientId string, qos QoSType, path string, payload []byte, packetIdentifier uint16) (err error)

type SendPayloadVx func(ctx *StateContext, clientId string, builder PacketBuilder, qp *qp) (err error)

type SendingTask struct {
	Builder PacketBuilder
}

type Session interface {
	Close() (err error)

	SetCleanSessionFlag(b bool)
	GetCleanSessionFlag() bool

	// Write write data to the connection associated with this session, in the context
	Write(data []byte) (n int, err error)

	// LinkTo relink the new context 'ctx' to this session
	LinkTo(ctx *StateContext)

	// KeepAlive reset the internal keep-alive timer so that refresh it
	KeepAlive()
}

type SessionStore interface {
	// Close the session store if server stopping, it will flush all sessions to persistent storage.
	Close()

	BeforeServerListening()

	// Has tests the existence of a session via its clientId key
	Has(key string) bool
	Get(key string, defaultValue ...Session) Session
	Set(key string, value Session) (err error)
	Unset(key string) (err error)

	AddWillMessage(clientId string, willQoS QoSType, willRetainFlag bool, willTopic string, willMessage []byte)
	HasWillMessage(clientId string) bool
	// SendWillMessage do publish the will msg to all clients on will topic, and
	// erase the will msg if not retained
	// sendPaylaodVx should be nil so that a default sender can dispatch the
	// payload to all subscribers, see also
	// defaultSessionStore.sendPayloadToClient
	SendWillMessage(ctx *StateContext, clientId string, sendPayloadVx SendPayloadVx) (err error)

	StoreQos1or2Message(ctx *StateContext, pkg *Pkg) (err error)
	PublishByPktId(ctx *StateContext, pktId uint16) (err error)

	PublishByBuilder(ctx *StateContext, builder PacketBuilder) (err error)

	Publish(ctx *StateContext, pkg *Pkg) (err error)
	Subscribe(ctx *StateContext, clientId string, topicFilter TopicFilter, packetIdentifier uint16) (invoked QoSType, err error)
	Unsubscribe(ctx *StateContext, clientId, topicFilter string) (err error)

	EnableSysStats(enabled bool)
	SysStatsEnabled() bool
	EnableSysStatsLog(enabled bool)
	SysStatsLogEnabled() bool
	EnableResetStorage(enabled bool)
	ResetStorageEnabled() bool
}

type State ReportType

type StateContext struct {
	TimeOfConnected time.Time
	ConnectTimeout  time.Duration

	State State

	// ClientId     string
	ConnectParam *ConnectParam
	// contains filtered or unexported fields
}

type StateContextOpt func(ctx *StateContext)

type StateRegistry interface {
	AddSynonyms(from State, synonymy ...State)
	AddState(from State, parsers *PacketParserMap)
	// in testing mode, noOnAction should be true to ignore invoking PacketParser.OnAction
	Advance(out io.Writer, ctx *StateContext, pkg *Pkg, noOnAction bool) (to State, err error)
	Parsers() map[ReportType]PacketParser
	// in testing mode, noOnAction should be true to ignore invoking PacketParser.OnAction
	Parse(ctx *StateContext, pkg *Pkg, noOnAction bool) (to State, err error)
}

type Store interface {
	Has(key string) bool
	Get(key string, defaultValue ...interface{}) interface{}
	Set(key string, value interface{}) (err error)
}

type SubBlock struct {
	TopicFilter string
	RequestQoS  QoSType
	Verbose     bool
	RetCode     QoSType
}

type SubHolder interface {
	Add(packetIdentifier uint16, filters []SubBlock) (err error)
	ApplyRetCodes(ctx *StateContext, packetIdentifier uint16, data []byte, pos int) (newPos int)
}

type Subinfo struct {
	// contains filtered or unexported fields
}

type SubscribeBuilderOpt func(*subBuilder)

type SysPublisher interface {
	SysPublish(topicParts string, payload []byte, opts ...PublishBuilderOpt)
	SysPublishString(topicParts string, payload string, opts ...PublishBuilderOpt)
	SysPublishInt64(topicParts string, payload int64, opts ...PublishBuilderOpt)
	SysPublishUint64(topicParts string, payload uint64, opts ...PublishBuilderOpt)
	SysPublishFloat64(topicParts string, payload float64, opts ...PublishBuilderOpt)

	// IncMessages updates statistics data under $SYS/broker/messages/...
	// The known suffixes must be:
	// "received", "sent", "publish/dropped", "publish/received", "publish/sent", "retained/count",
	IncMessages(suffix string, delta int64)

	// IncLoad updates statistics data under $%SYS/broker/load/...
	// The known suffixes could be:
	// "bytes/received", "bytes/sent", ...
	IncLoad(suffix string, delta int)
}

type TopicFilter struct {
	Filter            string
	Shared            bool
	SharedName        string
	RequestedQoS      QoSType
	NoLocal           bool // v5.0+
	RetainAsPublished bool // v5.0+
	RetainHandling    int  // v5.0+, see also ch. 3.8.3.1
	RetCode           errors.CloseReason
}

type UnsubackBuilderOpt func(*unsubackBuilder)

type UnsubackRetcode int

type UnsubscribeBuilderOpt func(*unsubBuilder)

type VariantHeader interface {
	Applyable
}

type WillMessage struct {
	Message
}

type WrongPacketParser struct{}