domain

type CreateInterpretationArgs struct {
	Range        [2]float64
	Translations []InterpretationTranslation
}

type CreateItemArgs struct {
	Code         string
	Steps        int
	Reverse      bool
	Translations []ItemTranslation
}

type CreateQuestionArgs struct {
	Code         string
	Type         string
	Order        int
	Translations []QuestionTranslation
	Items        []CreateItemArgs
}

type CreateScaleArgs struct {
	Type            string
	Code            string
	Translations    []ScaleTranslation
	Items           []CreateItemArgs
	Interpretations []CreateInterpretationArgs
}

type CreateTagArgs struct {
	Code         string
	Type         string
	Translations []TagTranslation
}

type CreateTestArgs struct {
	Code             string
	Published        bool
	AvailableLocales []string `yaml:"availableLocales"`
	ForceUpdate      bool     `yaml:"forceUpdate"`
	Generate         GenerateQuestionsArgs
	Image            string
	Tags             []string
	Translations     []TestTranslation
	Questions        []CreateQuestionArgs
	Scales           []CreateScaleArgs
	Display          CreateTestDisplayArgs
}

type CreateTestDisplayArgs struct {
	QuestionsPerPage int  `yaml:"questionsPerPage"`
	RandomizeOrder   bool `yaml:"randomizeOrder"`
}

type Event struct {
	Name      string
	StartTime time.Time
	EndTime   time.Time
	Elapsed   time.Duration
}

type GenerateQuestionsArgs struct {
	Method   string
	Template CreateQuestionArgs
}

type Interpretation struct {
	ID      uuid.UUID
	Content template.HTML // translatable
	Range   [2]float64
}

type InterpretationTranslation struct {
	Locale  string
	Content string
}

type Item struct {
	ID         uuid.UUID
	TestID     uuid.UUID
	ScaleID    uuid.UUID
	QuestionID uuid.UUID
	Code       string
	Content    string // translatable
	Steps      int    // number of steps in response scale
	Reverse    bool
	// Type       string
	Response *Response // for use in handler, not for saving
}

type ItemTranslation struct {
	Locale  string
	Content string
}

type Norm struct {
	ID       uuid.UUID
	SampleID uuid.UUID
	ScaleID  uuid.UUID
	Name     string
	Base     int
	Mean     float64
	Sigma    float64
	Rank     int
	Meta     map[string]interface{}
}

type NormCalculationData struct {
	ScaleID   uuid.UUID
	ScaleCode string
	Results   []float64
}

type PrepareTestArgs struct {
	UserID  uuid.UUID
	Session string
}

type QueryTestsArgs struct {
	Locale        string
	Tags          []*Tag
	TagIDs        []uuid.UUID
	FilterModeAny bool
}

type Question struct {
	ID            uuid.UUID
	TestID        uuid.UUID
	Code          string
	Order         int
	Content       string // translatable
	HeaderContent string // translatable
	FooterContent string // translatable
	Items         []*Item
}

type QuestionTranslation struct {
	Locale        string
	Content       string
	HeaderContent string
	FooterConent  string
}

type Response struct {
	ID         uuid.UUID
	ItemID     uuid.UUID
	TakeID     uuid.UUID
	Value      int
	CreateTime time.Time
	UpdateTime time.Time
	Meta       map[string]interface{}
}

type Result struct {
	ID         uuid.UUID
	TakeID     uuid.UUID
	ScaleID    uuid.UUID
	RawScore   float64
	FinalScore float64
	CreateTime time.Time
	UpdateTime time.Time
	Meta       map[string]interface{}
}

type Sample struct {
	ID       uuid.UUID
	Code     string
	Criteria SampleCriteria
}

type SampleCriteria struct {
	NotSuspicious bool   `json:"notSuspicious,omitempty"`
	Locale        string `json:"locale,omitempty"`
}

type Scale struct {
	ID              uuid.UUID
	Code            string
	Type            string
	Title           string // translatable
	Description     string // translatable
	Abbreviation    string // translatable
	Global          bool   // if scale can be used by more than one test
	Items           []*Item
	Interpretations []*Interpretation
	Result          *ScaleResult // not save in db as yet
	Norm            *Norm        // to use in calculation
}

type ScaleResult struct {
	RawScore       float64
	Score          float64
	Min            float64
	Max            float64
	Interpretation *Interpretation
	Formula        string
	Elapsed        time.Duration
	Unit           string
	Meta           map[string]interface{}
}

type ScaleTranslation struct {
	Locale       string
	Title        string
	Description  string
	Abbreviation string
}

type SystemSummary struct {
	ID            int
	Users         int
	Tests         int
	FinishedTakes int
	Responses     int
	CreateTime    time.Time
}

type Tag struct {
	ID      uuid.UUID
	Code    string
	Type    string
	Content string
}

type TagTranslation struct {
	Locale  string
	Content string
}

type Take struct {
	ID         uuid.UUID
	UserID     uuid.UUID
	TestID     uuid.UUID
	Seed       int64
	StartTime  *time.Time
	EndTime    *time.Time
	Suspicious bool
	InLocale   string
	CreateTime time.Time
	UpdateTime time.Time
	Page       int
	Status     string
	Progress   int
	Mark       *int
	Meta       map[string]interface{}
}

type Test struct {
	ID                uuid.UUID
	Code              string        // unique code for url
	Title             string        // translatable
	Description       string        // translatable
	Details           template.HTML // translatable
	Instruction       template.HTML // translatable
	ResultPreambule   template.HTML // translatable
	Locale            string
	AvailableLocales  []string
	GenerateQuestions string
	Published         bool
	Questions         []*Question
	Scales            []*Scale
	Tags              []*Tag
	Image             string
	Display           TestDisplay
	Mark              float64
	Duration          time.Duration
	QuestionCount     int     // for display (and less joins in requests)
	Take              *Take   // for use in handler
	Takes             []*Take // for calculations
}

type TestDisplay struct {
	RandomizeOrder   bool
	QuestionsPerPage int
}

type TestTranslation struct {
	Locale      string
	Title       string
	Description string
	Details     string
	Instruction string
	Preambule   string
}

type User struct {
	ID           uuid.UUID
	Name         string
	Email        string
	Admin        bool
	Picture      string
	Password     string
	PasswordHash string
	Locale       string
	Anonymous    bool
	UseDarkTheme bool
	AnonymousID  []uuid.UUID
	Meta         map[string]interface{}
}

type UserSession struct {
	ID           int    // probably uuid not needed here, sessions are temporary anyways
	SID          string // code to identify the session
	UserID       uuid.UUID
	IP           string
	UserAgent    string
	CreateTime   time.Time
	UpdateTime   time.Time
	LastActivity time.Time
	Meta         map[string]interface{}
	Active       bool
}

type UserSummary struct {
	UserID uuid.UUID
}