package com.dano.test1.data

import androidx.room.*

/*
Room-Entities (Tabellen) der App.
 - Definieren das Schema für Clients, Questionnaires, Questions, Answers und CompletedQuestionnaires.
 - Beziehungen:
     * Question -> Questionnaire (FK, CASCADE)
     * Answer   -> Client (FK, CASCADE)
     * Answer   -> Question (FK, CASCADE)
     * CompletedQuestionnaire -> Client (FK, CASCADE)
     * CompletedQuestionnaire -> Questionnaire (FK, CASCADE)
 - Primärschlüssel:
     * Client: clientCode
     * Questionnaire: id
     * Question: questionId
     * Answer: (clientCode, questionId) – eine Antwort je Client & Frage
     * CompletedQuestionnaire: (clientCode, questionnaireId) – ein Status je Client & Fragebogen
*/

/* Tabelle: clients – Eindeutige Identifikation eines Clients per clientCode. */
@Entity(tableName = "clients")
data class Client(
    @PrimaryKey val clientCode: String,
)

/* Tabelle: questionnaires – Eindeutige Fragebogen-IDs. */
@Entity(tableName = "questionnaires")
data class Questionnaire(
    @PrimaryKey val id: String,
)

/*
Tabelle: questions
 - Jede Frage gehört zu genau einem Fragebogen (questionnaireId).
 - Fremdschlüssel sorgt dafür, dass beim Löschen eines Fragebogens die zugehörigen Fragen mit gelöscht werden.
 - Index auf questionnaireId beschleunigt Abfragen „alle Fragen eines Fragebogens“.
*/
@Entity(
    tableName = "questions",
    foreignKeys = [
        ForeignKey(
            entity = Questionnaire::class,
            parentColumns = ["id"],
            childColumns = ["questionnaireId"],
            onDelete = ForeignKey.CASCADE
        )
    ],
    indices = [Index("questionnaireId")]
)
data class Question(
    @PrimaryKey val questionId: String,
    val questionnaireId: String,
    val question: String = ""
)

/*
Tabelle: answers
 - Zusammengesetzter Primärschlüssel (clientCode, questionId):
     * Pro Client und Frage existiert höchstens eine Antwort.
     * Löscht man den Client oder die Frage, werden die zugehörigen Antworten mit entfernt.
*/
@Entity(
    tableName = "answers",
    primaryKeys = ["clientCode", "questionId"],
    foreignKeys = [
        ForeignKey(
            entity = Client::class,
            parentColumns = ["clientCode"],
            childColumns = ["clientCode"],
            onDelete = ForeignKey.CASCADE
        ),
        ForeignKey(
            entity = Question::class,
            parentColumns = ["questionId"],
            childColumns = ["questionId"],
            onDelete = ForeignKey.CASCADE
        )
    ],
    indices = [Index("clientCode"), Index("questionId")]
)
data class Answer(
    val clientCode: String,
    val questionId: String,
    val answerValue: String = ""
)

/*
Tabelle: completed_questionnaires
 - Zusammengesetzter Primärschlüssel (clientCode, questionnaireId):
     * Hält den Abschluss-Status eines Fragebogens pro Client.
 - FKs mit CASCADE:
     * Beim Löschen eines Clients oder Fragebogens verschwindet der Status-Eintrag ebenfalls.
 - Indizes auf clientCode und questionnaireId für schnelle Lookups.
 - timestamp: Zeitpunkt der Statusänderung (Default: now).
 - isDone: true/false – abgeschlossen oder nicht.
 - sumPoints: optionaler Score des Fragebogens.
*/
@Entity(
    tableName = "completed_questionnaires",
    primaryKeys = ["clientCode", "questionnaireId"],
    foreignKeys = [
        ForeignKey(
            entity = Client::class,
            parentColumns = ["clientCode"],
            childColumns = ["clientCode"],
            onDelete = ForeignKey.CASCADE
        ),
        ForeignKey(
            entity = Questionnaire::class,
            parentColumns = ["id"],
            childColumns = ["questionnaireId"],
            onDelete = ForeignKey.CASCADE
        )
    ],
    indices = [Index("clientCode"), Index("questionnaireId")]
)
data class CompletedQuestionnaire(
    val clientCode: String,
    val questionnaireId: String,
    val timestamp: Long = System.currentTimeMillis(),
    val isDone: Boolean,
    val sumPoints: Int? = null
)
