package models

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

type AbsenceType struct {
	Id       int8
	Name     string
	WorkTime float32
}

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

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", 100},
			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
	}
	defer qStr.Close()
	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 GetAbsenceById(counterId int) (Absence, error) {
	var absence Absence = Absence{CounterId: counterId}
	qStr, err := DB.Prepare("SELECT card_uid, abwesenheit_typ, datum FROM abwesenheit WHERE counter_id = $1;")
	if err != nil {
		return absence, err
	}
	defer qStr.Close()
	err = qStr.QueryRow(counterId).Scan(&absence.CardUID, &absence.AbwesenheitTyp.Id, &absence.Datum)
	if err != nil {
		return absence, err
	}
	return absence, nil
}

func GetAbsencesByCardUID(card_uid string, tsFrom time.Time, tsTo time.Time) ([]Absence, error) {
	var absences []Absence
	qStr, err := DB.Prepare("SELECT counter_id, abwesenheit_typ, datum FROM abwesenheit WHERE card_uid = $1 AND datum BETWEEN $2::DATE AND $3::DATE ORDER BY datum;")
	if err != nil {
		return absences, err
	}
	defer qStr.Close()
	rows, err := qStr.Query(card_uid, tsFrom, tsTo)
	if err != nil {
		return absences, err
	}
	defer rows.Close()
	for rows.Next() {
		var absence Absence
		if err := rows.Scan(&absence.CounterId, &absence.AbwesenheitTyp.Id, &absence.Datum); err != nil {
			return absences, err
		}
		absence.AbwesenheitTyp, err = GetAbsenceTypeById(absence.AbwesenheitTyp.Id)
		if err == nil {
			absences = append(absences, absence)
		} else {
			log.Println("Cannot populate absence type!", err)
		}
	}
	if err = rows.Err(); err != nil {
		return absences, err
	}
	return absences, nil
}

func GetAbsenceTypes() (map[int8]AbsenceType, error) {
	var types = make(map[int8]AbsenceType)
	qStr, err := DB.Prepare("SELECT abwesenheit_id, abwesenheit_name, arbeitszeit_equivalent 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, &absenceType.WorkTime); 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)
}

func GetAbsenceTypeById(absenceTypeId int8) (AbsenceType, error) {
	var absenceType AbsenceType = AbsenceType{Id: absenceTypeId}

	qStr, err := DB.Prepare("SELECT abwesenheit_name, arbeitszeit_equivalent FROM s_abwesenheit_typen WHERE abwesenheit_id = $1;")
	if err != nil {
		return absenceType, err
	}
	defer qStr.Close()
	err = qStr.QueryRow(absenceTypeId).Scan(&absenceType.Name, &absenceType.WorkTime)
	if err != nil {
		return absenceType, err
	}
	return absenceType, nil
}