package models

import (
	"errors"
	"log"
	"time"
)

type AbsenceType struct {
	Id   int8
	Name string
}

type Absence struct {
	CounterId      int
	CardUID        string
	AbwesenheitTyp AbsenceType
	Datum          time.Time
	// Comment        string
}

func NewAbsence(card_uid string, abwesenheit_typ int, datum time.Time) (Absence, error) {
	if abwesenheit_typ < 0 {
		return Absence{
			CardUID:        card_uid,
			AbwesenheitTyp: AbsenceType{0, "Custom absence"},
			Datum:          datum,
		}, nil
	}
	_absenceType, ok := GetAbsenceTypesCached()[int8(abwesenheit_typ)]
	if !ok {
		return Absence{}, errors.New("Invalid absencetype")
	}
	return Absence{
		CardUID:        card_uid,
		AbwesenheitTyp: _absenceType,
		Datum:          datum,
	}, nil
}

func (a *Absence) Insert() error {
	qStr, err := DB.Prepare(`INSERT INTO abwesenheit (card_uid, abwesenheit_typ, datum) VALUES ($1, $2, $3) RETURNING counter_id;`)
	if err != nil {
		log.Println("Error preparing sql Statement", err)
		return err
	}
	err = qStr.QueryRow(a.CardUID, a.AbwesenheitTyp.Id, a.Datum).Scan(&a.CounterId)
	if err != nil {
		log.Println("Error executing insert statement", err)
		return err
	}
	return nil
}

// func (a *Absence) GetStringType() string {
// 	return AbsenceTypesLabel[a.AbwesenheitTyp]
// }

func GetAbsenceTypes() (map[int8]AbsenceType, error) {
	var types = make(map[int8]AbsenceType)
	qStr, err := DB.Prepare("SELECT abwesenheit_id, abwesenheit_name FROM s_abwesenheit_typen;")
	if err != nil {
		return types, err
	}
	defer qStr.Close()
	rows, err := qStr.Query()
	if err != nil {
		log.Println("Error getting abwesenheit rows!", err)
		return types, err
	}
	defer rows.Close()
	for rows.Next() {
		var absenceType AbsenceType
		if err := rows.Scan(&absenceType.Id, &absenceType.Name); err != nil {
			log.Println("Error scanning absence row!", err)
		}
		types[absenceType.Id] = absenceType
	}
	return types, nil
}

func GetAbsenceTypesCached() map[int8]AbsenceType {
	types, err := definedTypes.Get("s_abwesenheit_typen")
	if err != nil {
		return map[int8]AbsenceType{}
	}
	return types.(map[int8]AbsenceType)
}