lesson2

type Act struct {
	Scenes          []Scene
	ActRepeaterExpr ActRepeaterExpr
}

type ActRepeaterExpr string

type Acts []Act

type Checkpoint struct {
	MaxAccumulatedScores map[ScoreName]float64
	SumAccumulatedScores map[ScoreName]float64
	Round                Round
}

type ClientID string

type ClientModel struct {
	Model
	CurrentPlayer Player
	CurrentRound  Round
}

type Controller struct {
	//Note: Controller doesn't own the current round any more - event loop does that
	PlanID   uuid.UUID
	Plan     *Plan // This is the fixed recipe for the lesson
	Model    Model // This is the dynamically evaluated model as questions are answered etc.
	LeaderID uuid.UUID
	Leader   *account.User //Runs the show
	Players  map[ClientID]Player
	Teams    map[ClientID]TeamName
	Rounds   []Round
	Draw     Draw
	// contains filtered or unexported fields
}

type Draw map[*QuestionSet]map[Round][]Question

type EventLoop struct {
	Ctrl               Controller
	CurrentRound       Round
	ConsoleInChannel   <-chan EventLoopEvent
	TheatreInChannel   <-chan EventLoopEvent
	CtrlInChannel      <-chan EventLoopEvent //TODO rarely used - really just for serious async
	ConsoleOutChannels map[ClientID]chan<- EventLoopEvent
	TheatreOutChannels map[ClientID]chan<- EventLoopEvent
}

type EventLoopEvent interface {
	HandleFromConsole(*EventLoop, string) error //Second argument is clientID
	HandleFromTheatre(*EventLoopEvent) error
}

type LessonServer struct {
	Opts struct {
		// contains filtered or unexported fields
	}
	//TODO I'm very convinced now that controller shouldn't have it's
	//TODO own go-routine. Should just listen on event loop
	//TODO then controller should have async channels made out that we can listen to
	//TODO (or be passed to!) TODO TODO
	Controller Controller
	Register   struct {
		// contains filtered or unexported fields
	}
	EventLoop EventLoop
	// contains filtered or unexported fields
}

type Model map[Round]map[TeamName]map[Player]Record

type Plan struct {
	account.UserObject
	Name             string
	Description      string
	Tags             Tags             //TODO jsonify
	TeamRules        TeamRules        //TODO embed
	ScoreDefinitions ScoreDefinitions //TODO jsonify
	Acts             Acts             //TODO jsonify
}

type Player struct {
	ClientID ClientID
	Name     string
}

type Question struct {
	account.UserObject
	Content          string         `json:"content" gorm:"column:content"`
	Header           string         `json:"header,omitempty" gorm:"column:header"`
	Media            string         `json:"media,omitempty" gorm:"column:media"`
	MediaContentType string         `json:"mediaContentType,omitempty" gorm:"column:media_content_type"`
	ByLine           string         `json:"byline,omitempty" gorm:"column:by_line"`
	Tags             pq.StringArray `json:"tags" gorm:"type:varchar(64)[];column:tags"`
	Rules            QuestionRules  `json:"rules" gorm:"column:rules"`
}

type QuestionLogic string

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

type QuestionSet struct {
	Logic          QuestionSetLogic `json:"logic"`
	WhereCondition WhereCondition   `json:"whereCondition,omitempty"`
}

type QuestionSetLogic string

type Record struct {
	Player     Player
	Round      Round
	ScoreCards ScoreCards
	Question   *Question //Optional
	Team       TeamName
	Response   *Response //TODO need to fold this through model
}

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

type Response struct {
	Player      Player
	ContentType ResponseContentType
	Data        interface{}
	Logic       QuestionLogic
}

type ResponseContentType string

type Round struct {
	Act   uint
	Scene uint
	Rep   uint
}

type RoundScore struct {
	ScoreName ScoreName
	Score     float64
	Ranking   uint64
}

type Scene struct {
	Template     string
	ScoresActive []ScoreName
	QuestionSet  *QuestionSet //TODO add these filters across.
}

type ScoreAccumulatorExpr string

type ScoreCard struct {
	RoundScore
	AccumulatedScore   float64
	AccumulatedRanking uint64
}

type ScoreCards map[ScoreName]ScoreCard

type ScoreDefinitions map[ScoreName]ScoreAccumulatorExpr

type ScoreName string

type Tags []string

type TeamLogic string

type TeamName string

type TeamRules struct {
	TeamLogic TeamLogic
	Count     int
}

type WebsocketMessage struct {
	Type     string
	ClientID ClientID
	Data     json.RawMessage
}

type WhereCondition map[string]interface{}