core

type Attitude struct {
	Level    int        `json:"level"`              // Attitude const level
	Judgment string     `json:"judgment,omitempty"` // my subjective judgment
	Evidence []*Quantum `json:"evidence,omitempty"` // evidence of my judgment, can be omit but all quantum should come from current individual
}

type Community struct {
	Note         *QContent          `json:"note"`
	Define       Sig                `json:"define"`
	Creator      identity.Address   `json:"creator"`
	MinCosignCnt int                `json:"minCosignCnt"`
	MaxInviteCnt int                `json:"maxInviteCnt"`
	InitMembers  []identity.Address `json:"initMembers"`
}

type Individual struct {
	Address     identity.Address     `json:"address"`
	Profile     map[string]*QContent `json:"profile,omitempty"`
	Communities []*Community         `json:"communities,omitempty"`
	Attitude    *Attitude            `json:"attitude"`
	LastSig     Sig                  `json:"lastSignature,omitempty"`
	LastSeq     int64                `json:"lastSequence,omitempty"`
}

type QContent struct {
	Data   []byte `json:"data,omitempty"`
	Format int    `json:"fmt"`
}

type Quantum struct {
	UnsignedQuantum
	Signature Sig `json:"sig,omitempty"`
}

type Sig []byte

type Universe interface {
	// ReceiveQuantums will proccess quantums, verify the signature of each quantum. reject the quantums
	// from address in blacklist or conflict with quantums already exist. Both accept and wait quantums
	// will be saved. wait quantums usually cause by ref[0] is missing, so can not be broadcast and implement.
	ReceiveQuantums(originQuantums []*Quantum) (accept []Sig, wait []Sig, reject []Sig, err error)

	// ProcessSingleQuantum verify the signature, decide whether to accept or not, process the quantum by QType
	// return err if quantum not accept. casuse of verif-fail, signer in blacklist, conflict or any reason.
	ProcessSingleQuantum(sig Sig) error

	// ProcessQuantums have same function of ReceiveQuantums, but process quantums already in universe, which is
	// quantums from return "wait" of ReceiveQuantums.
	ProcessQuantums(limit, skip int) (accept []Sig, wait []Sig, reject []Sig, err error)

	// JudgeIndividual update the attitude towards Individual and how to process quantums from this signer.
	JudgeIndividual(address identity.Address, level int, judgment string, evidence ...[]Sig) error

	// JudgeCommunity update the attitude towards Community, decide if filter the individual in this community or not
	JudgeCommunity(sig Sig, level int, statement string) error

	// QueryQuantums query quantums from whole accepted quantums if address is nil, not filter by type if qType is 0
	QueryQuantums(address identity.Address, qType int, skip int, limit int, desc bool) ([]*Quantum, error)

	// QueryIndividuals query Individual from whole universe if community sig is nil.
	QueryIndividuals(sig Sig, skip int, limit int, desc bool) ([]*Individual, error)

	// GetCommunity return community by signature of community create signature.
	GetCommunity(sig Sig) (*Community, error)

	// GetIndividual return individual by address.
	GetIndividual(address identity.Address) (*Individual, error)

	// GetQuantum return quantum by signature of quantum.
	GetQuantum(sig Sig) (*Quantum, error)
}

type UnsignedQuantum struct {
	// Contents contain all data in this quantum
	Contents []*QContent `json:"cs,omitempty"`

	// References must from the exist signature or 0x00
	// References[0] is the last signature by user-self, 0x00 if this quantum is the first quantum by user
	// References[1] is the last signature of public or important quantum by user-self, which quantum user
	// want other user to view most. (refs[1] usually contains article and forward, but not comments, like or chat)
	// if References[1] same with References[0], References[1] can be SameQuantumReference(0x01)
	// References[2] ~ References[n] is optional, recommend to use new & valid quantum
	// If two quantums by same user with same References[0], these two quantums will cause conflict, and
	// this user maybe block by others. The reason to do that punishment is user should act like individual,
	// all proactive event from one user should be sequence should be total order (全序关系). References[1~n]
	// do not need follow this restriction, because all other references show the partial order (偏序关系).
	// all the quantums which be reference as References[1] should be total order too.
	References []Sig `json:"refs"`

	// Type specifies the type of this quantum
	Type int `json:"type"`
}