lesson

type Act struct {
	Scenes      Scenes            `json:"scenes"`                //This should get gorm embedded as json
	RepeatUntil *RepeatUntilLogic `json:"repeatLogic,omitempty"` //This should get gorm embedded as json
}

type Acts []Act

type BoolComparable struct {
	Impl bool
}

type ClientID uuid.UUID

type Comparable interface {
	EqualTo(Comparable) bool
	LessThan(Comparable) bool
}

type ConsoleMessage struct {
	WebsocketMessage
	Type             ConsoleMessageType     `json:"type"`
	ClientOutChannel *chan<- ConsoleMessage //Optional - the output chanel associated with this console message for this client
}

type ConsoleMessageType string

type Controller struct {
	Planner Planner
	Model   Model
	//Channels...
	// Channels for communicating with the event loop
	EventChannelIn <-chan ControllerEvent
	EventLoopOut   chan<- EventLoopEvent
}

type ControllerEvent interface {
	Handle(*Controller) error
}

type CtrlAddPlayerEvent struct {
	PlayerToken ClientID
	PlayerName  string
}

type CtrlMakeTeamsEvent struct{}

type EndRegistrationEvent struct {
}

type EndSceneEvent struct {
	NextRound RoundIdx
}

type EventLoop struct {
	CurrentRound        RoundIdx //Current round index as we understand it. A 0, 0, 0 round = registration
	InactivityTimeout   time.Duration
	LeaderPlayerToken   ClientID
	RegistrationTimeout time.Duration
	// Channels for sending and receiving messages to/from theatre websockets.
	// Go routines handling websockets must convert their respective events to EventLoopEvents
	TheatreChannelIn   <-chan EventLoopEvent
	TheatreChannelOuts []chan<- EventLoopEvent
	// Channels for sending and receiving messages to/from console websockets
	// Go routines handling websockets must convert their respective events to EventLoopEvents
	ConsoleChannelIn   <-chan EventLoopEvent
	ConsoleChannelOuts map[ClientID]chan<- EventLoopEvent
	// Channels for telling the controller about state changes
	ControllerChannelOut chan<- ControllerEvent
	EventLoopChannelIn   <-chan EventLoopEvent
}

type EventLoopEvent interface {
	HandleFromController(*EventLoop) error
	HandleFromConsole(*EventLoop, ClientID) error
	HandleFromTheatre(*EventLoopEvent) error
}

type EventLoopTransformable interface {
	MakeEventLoopEvent() EventLoopEvent
}

type FloatComparable struct {
	Impl float64
}

type InputResponse struct {
	PlayerToken ClientID
}

type JumpToSceneRequest struct {
	TargetRound RoundIdx
}

type Layout string

type LayoutFlag string

type LayoutFlagsStruct map[LayoutFlag]bool

type Lesson struct {
	EventLoop  EventLoop
	Model      Model
	Register   Register
	Controller Controller
}

type Model struct {
	Round     Round
	AllRounds map[RoundIdx]Round
	Players   []Player
	Teams     []Team
	Scores    Scores
}

type Op string

type Plan struct {
	account.UserObject
	Name           string
	Description    string
	TeamStructures TeamStructures //This is embedded
	Acts           []Act          // This is also embedded.
}

type Planner struct {
	PlanID uuid.UUID
	Plan   *Plan

	//A channel for making some of the fetch from the db async
	QuestionRetrievalChannel chan<- QuestionDraw
	// contains filtered or unexported fields
}

type Player struct {
	Name          string
	Avatar        []byte
	Token         ClientID //Generated unique to securely disambiguate players //TODO - align with JWT //TODO (probably in the handler itself)
	ScoreCard     ScoreCard
	AllScoreCards map[RoundIdx]ScoreCard
	Responses     map[RoundIdx]Response //Links the players response to the question for them generated at that round
}

type PlayerRanking struct {
	ScoreName ScoreName
	Player    Player
	Score     float64
}

type PlayerRankings []PlayerRanking

type PlayerResponseEvent struct {
	PlayerToken  uuid.UUID
	QuestionLink QuestionLink
	Data         interface{}
}

type PlayerScores map[ScoreName]PlayerRankings

type PreloadScreen struct {
	Round RoundIdx
	View  RenderedView
}

type Question struct {
	account.UserObject
	Content string         `json:"content"`
	Header  string         `json:"header,omitempty"`
	Image   uuid.UUID      `json:"image,omitempty"`
	ByLine  string         `json:"byline,omitempty"`
	Tags    pq.StringArray `json:"tags" gorm:"type:varchar(64)[]"`
	Rules   QuestionRules  `json:"rules"`
}

type QuestionContentType string

type QuestionDraw map[RoundIdx]map[ClientID]Question

type QuestionFilterLiteral struct {
	Field string //TODO need to json this.
	Op    Op
	Value string
}

type QuestionFilterQuery struct {
	QuestionBanks []string
	CNF           [][]QuestionFilterLiteral
}

type QuestionIDList []uuid.UUID

type QuestionLogic string

type QuestionRules struct {
	Logic        QuestionLogic       `json:"logic,omitempty"`
	ContentType  QuestionContentType `json:"contentType,omitempty"`
	Data         datatypes.JSON      `json:"data,omitempty"` //Extra data - e.g. best answer plus multiple choices
	ScoringRules ScoringRules        `json:"scoringRules,omitempty"`
}

type QuestionSet struct {
	QuestionIds []uuid.UUID         `json:"questionIds,omitempty"` //Either-or
	Query       QuestionFilterQuery `json:"query,omitempty"`       //Either-or
}

type Register struct {
	Timeout      time.Duration
	Done         bool
	RequireLogin bool
	OptDomain    *string
	LessonCode   string
}

type RegisterEvent struct {
	PlayerToken ClientID
	OutChannel  chan<- EventLoopEvent
}

type RenderedView struct {
	View
}

type RepeatCondition struct {
	Op  Op     `json:"op"`
	LHS string `json:"lhs"` //Templates to be resolved
	RHS string `json:"rhs"`
}

type RepeatUntilLogic struct {
	Fixed uint16              `json:"fixed,omitempty"` //65k repeats is enough :)
	CNF   [][]RepeatCondition `json:"cnf,omitempty"`   //Takes precedence if it exists. CNF.
}

type RequestForInput struct {
	InputRequest map[ClientID]ConsoleMessage //TODO ideally this is more processed than that before it hits the controller...
}

type Resolvable interface {
	IsTemplated() bool
	Resolve(*Round, *gorm.DB) *Question
}

type ResolvedQuestion struct {
	Question
}

type ResolvedQuestionFilter struct {
	QuestionSet
}

type Response struct {
	Question *Question
	//TODO! this is gonna need to be pretty generic - make this work some'ow ;) Would be
	Data interface{}
}

type Round struct {
	RoundIdx
	Stats           RoundStats
	PreviousRound   *Round
	LinkedQuestions QuestionDraw
}

type RoundIdx struct {
	ActNumber   uint // Number left-to-right - almost like an Act
	SceneNumber uint // Going down which number
	Repetition  uint // A round may have multiple repetitions of that scene
}

type RoundStats struct {
	QuestionNumber uint // total number of scenes that were also questions
	StartTime      time.Time
	Time           time.Time // the actual time
}

type Scene struct {
	Template          View         `json:"template"`
	OptQuestionFilter *QuestionSet `json:"questionFilter,omitempty"`
}

type Scenes []Scene

type ScoreCard map[ScoreName]float64

type ScoreName string

type Scores struct {
	PlayerScores PlayerScores
	TeamScores   TeamScores
}

type ScoringLogic string

type ScoringRules map[ScoreName]ScoringLogic

type StringComparable struct {
	Impl string
}

type Team struct {
	Name          string
	Avatar        []byte
	Players       []Player
	ScoreCard     ScoreCard
	AllScoreCards map[RoundIdx]ScoreCard
}

type TeamLogic string

type TeamRanking struct {
	ScoreName
	Team  Team
	Score float64
}

type TeamRankings []TeamRanking

type TeamScores map[ScoreName]TeamRankings

type TeamStructure struct {
	TeamLogic TeamLogic `json:"logic"`
	Count     uint8     `json:"count"`
}

type TeamStructures map[string]TeamLogic

type TheatreMessage struct {
	WebsocketMessage
	Type TheatreMessageType `json:"type"`
}

type TheatreMessageType string

type View struct {
	Layout      Layout            `json:"layout"`
	LayoutFlags LayoutFlagsStruct `json:"layoutFlags,omitempty"`
	Title       string            `json:"title"`
	Byline      string            `json:"byline,omitempty"`
	Header      string            `json:"header,omitempty"`
	Footer      string            `json:"footer,omitempty"`
	Image       uuid.UUID         `json:"image,omitempty"`
	Caption     string            `json:"caption,omitempty"`
	Content     []string          `json:"content,omitempty"`
	Logo        uuid.UUID         `json:"logo,omitempty"`
	Gallery     []uuid.UUID       `json:"gallery,omitempty"`
	Classes     []string          `json:"classes,omitempty"` //This is our theming hook
}

type WebsocketMessage struct {
	PlayerToken ClientID        `json:"playerId,omitempty"`
	Round       RoundIdx        `json:"round,omitempty"` //Helps idempotency and avoids races
	Data        json.RawMessage `json:"data,omitempty"`
}