package fic

import (
	"time"
)

type MCQ struct {
	Id         int64       `json:"id"`
	IdExercice int64       `json:"idExercice"`
	Title      string      `json:"title"`
	Kind       string      `json:"kind"`
	Entries    []MCQ_entry `json:"entries"`
}

type MCQ_entry struct {
	Id       int64  `json:"id"`
	Label    string `json:"label"`
	Response bool   `json:"response"`
}

func (e Exercice) GetMCQ() ([]MCQ, error) {
	if rows, err := DBQuery("SELECT id_mcq, id_exercice, title, kind FROM exercice_mcq WHERE id_exercice = ?", e.Id); err != nil {
		return nil, err
	} else {
		defer rows.Close()

		var mcqs = make([]MCQ, 0)
		for rows.Next() {
			var m MCQ
			m.IdExercice = e.Id

			if err := rows.Scan(&m.Id, &m.IdExercice, &m.Title, &m.Kind); err != nil {
				return nil, err
			}

			if entries_rows, err := DBQuery("SELECT id_mcq_entry, label, response FROM mcq_entries WHERE id_mcq = ?", m.Id); err != nil {
				return nil, err
			} else {
				defer entries_rows.Close()

				for entries_rows.Next() {
					var e MCQ_entry

					if err := entries_rows.Scan(&e.Id, &e.Label, &e.Response); err != nil {
						return nil, err
					}

					m.Entries = append(m.Entries, e)
				}
			}

			mcqs = append(mcqs, m)
		}
		if err := rows.Err(); err != nil {
			return nil, err
		}

		return mcqs, nil
	}
}

func (e Exercice) AddMCQ(title string, kind string) (MCQ, error) {
	if res, err := DBExec("INSERT INTO exercice_mcq (id_exercice, title, kind) VALUES (?, ?, ?)", e.Id, title, kind); err != nil {
		return MCQ{}, err
	} else if qid, err := res.LastInsertId(); err != nil {
		return MCQ{}, err
	} else {
		return MCQ{qid, e.Id, title, kind, []MCQ_entry{}}, nil
	}
}

func (m MCQ) Update() (int64, error) {
	if res, err := DBExec("UPDATE exercice_mcq SET id_exercice = ?, title = ?, kind = ? WHERE id_mcq = ?", m.IdExercice, m.Title, m.Kind, m.Id); err != nil {
		return 0, err
	} else if nb, err := res.RowsAffected(); err != nil {
		return 0, err
	} else {
		return nb, err
	}
}

func (m MCQ) Delete() (int64, error) {
	if res, err := DBExec("DELETE FROM exercice_mcq WHERE id_mcq = ?", m.Id); err != nil {
		return 0, err
	} else if nb, err := res.RowsAffected(); err != nil {
		return 0, err
	} else {
		return nb, err
	}
}

func (m MCQ) AddEntry(label string, response bool) (MCQ_entry, error) {
	if res, err := DBExec("INSERT INTO mcq_entries (id_mcq, label, response) VALUES (?, ?, ?)", m.Id, label, response); err != nil {
		return MCQ_entry{}, err
	} else if nid, err := res.LastInsertId(); err != nil {
		return MCQ_entry{}, err
	} else {
		return MCQ_entry{nid, label, response}, nil
	}
}

func (n MCQ_entry) Update() (int64, error) {
	if res, err := DBExec("UPDATE mcq_entries SET label = ?, response = ? WHERE id_mcq = ?", n.Label, n.Response, n.Id); err != nil {
		return 0, err
	} else if nb, err := res.RowsAffected(); err != nil {
		return 0, err
	} else {
		return nb, err
	}
}

func (n MCQ_entry) Delete() (int64, error) {
	if res, err := DBExec("DELETE FROM mcq_entries WHERE id_mcq_entry = ?", n.Id); err != nil {
		return 0, err
	} else if nb, err := res.RowsAffected(); err != nil {
		return 0, err
	} else {
		return nb, err
	}
}

func (e Exercice) WipeMCQs() (int64, error) {
	if res, err := DBExec("DELETE FROM exercice_mcq, mcq_found, mcq_entries USING exercice_mcq NATURAL JOIN mcq_entries NATURAL JOIN mcq_found WHERE exercice_mcq.id_exercice = ?", e.Id); err != nil {
		return 0, err
	} else if nb, err := res.RowsAffected(); err != nil {
		return 0, err
	} else {
		return nb, err
	}
}

func (m MCQ) Check(vals map[int64]bool) int {
	diff := 0

	for _, n := range m.Entries {
		if v, ok := vals[n.Id]; (ok || !n.Response) && v == n.Response {
			continue
		}
		diff += 1
	}

	return diff
}

func (m MCQ) FoundBy(t Team) {
	DBExec("INSERT INTO mcq_found (id_mcq, id_team, time) VALUES (?, ?, ?)", m.Id, t.Id, time.Now())
}