package reveil

import (
	"fmt"
	"time"
)

type Date time.Time

func (d *Date) MarshalJSON() (dst []byte, err error) {
	return []byte(fmt.Sprintf("\"%04d-%02d-%02d\"", time.Time(*d).Year(), time.Time(*d).Month(), time.Time(*d).Day())), nil
}

func (d *Date) UnmarshalJSON(src []byte) error {
	tmp, err := time.Parse("\"2006-01-02\"", string(src))
	if err != nil {
		return err
	}
	*d = Date(tmp)

	return nil
}

type Hour time.Time

func (h *Hour) MarshalJSON() (dst []byte, err error) {
	return []byte(fmt.Sprintf("\"%02d:%02d\"", time.Time(*h).Hour(), time.Time(*h).Minute())), nil
}

func (h *Hour) UnmarshalJSON(src []byte) error {
	tmp, err := time.Parse("\"15:04\"", string(src))
	if err != nil {
		return err
	}
	*h = Hour(tmp)

	return nil
}

type AlarmRepeated struct {
	Id                Identifier   `json:"id"`
	Weekday           uint8        `json:"weekday"`
	StartTime         *Hour        `json:"time"`
	FollowingRoutines []Identifier `json:"routines"`
	IgnoreExceptions  bool         `json:"ignore_exceptions"`
	Comment           string       `json:"comment"`
}

func GetAlarmRepeated(db *LevelDBStorage, id Identifier) (alarm *AlarmRepeated, err error) {
	alarm = &AlarmRepeated{}
	err = db.get(fmt.Sprintf("alarm-repeated-%s", id.ToString()), alarm)
	return
}

func GetAlarmsRepeated(db *LevelDBStorage) (alarms []*AlarmRepeated, err error) {
	iter := db.search("alarm-repeated-")
	defer iter.Release()

	for iter.Next() {
		var a AlarmRepeated

		err = decodeData(iter.Value(), &a)
		if err != nil {
			return
		}

		alarms = append(alarms, &a)
	}

	return
}

func PutAlarmRepeated(db *LevelDBStorage, alarm *AlarmRepeated) (err error) {
	var key string
	var id Identifier

	if alarm.Id.IsEmpty() {
		key, id, err = db.findBytesKey("alarm-repeated-", IDENTIFIER_LEN)
		if err != nil {
			return err
		}
	}

	alarm.Id = id

	return db.put(key, alarm)
}

func DeleteAlarmRepeated(db *LevelDBStorage, alarm *AlarmRepeated) (err error) {
	return db.delete(fmt.Sprintf("alarm-repeated-%s", alarm.Id.ToString()))
}

type AlarmSingle struct {
	Id                Identifier   `json:"id"`
	Time              time.Time    `json:"time"`
	FollowingRoutines []Identifier `json:"routines"`
	Comment           string       `json:"comment"`
}

func GetAlarmSingle(db *LevelDBStorage, id Identifier) (alarm *AlarmSingle, err error) {
	alarm = &AlarmSingle{}
	err = db.get(fmt.Sprintf("alarm-single-%s", id.ToString()), alarm)
	return
}

func GetAlarmsSingle(db *LevelDBStorage) (alarms []*AlarmSingle, err error) {
	iter := db.search("alarm-single-")
	defer iter.Release()

	for iter.Next() {
		var a AlarmSingle

		err = decodeData(iter.Value(), &a)
		if err != nil {
			return
		}

		alarms = append(alarms, &a)
	}

	return
}

func PutAlarmSingle(db *LevelDBStorage, alarm *AlarmSingle) (err error) {
	var key string
	var id Identifier

	if alarm.Id.IsEmpty() {
		key, id, err = db.findBytesKey("alarm-single-", IDENTIFIER_LEN)
		if err != nil {
			return err
		}
	}

	alarm.Id = id

	return db.put(key, alarm)
}

func DeleteAlarmSingle(db *LevelDBStorage, alarm *AlarmSingle) (err error) {
	return db.delete(fmt.Sprintf("alarm-single-%s", alarm.Id.ToString()))
}

type AlarmException struct {
	Id      Identifier `json:"id"`
	Start   *Date      `json:"start"`
	End     *Date      `json:"end"`
	Comment string     `json:"comment"`
}

func GetAlarmException(db *LevelDBStorage, id Identifier) (alarm *AlarmException, err error) {
	alarm = &AlarmException{}
	err = db.get(fmt.Sprintf("alarm-exception-%s", id.ToString()), alarm)
	return
}

func GetAlarmExceptions(db *LevelDBStorage) (alarms []*AlarmException, err error) {
	iter := db.search("alarm-exception-")
	defer iter.Release()

	for iter.Next() {
		var a AlarmException

		err = decodeData(iter.Value(), &a)
		if err != nil {
			return
		}

		alarms = append(alarms, &a)
	}

	return
}

func PutAlarmException(db *LevelDBStorage, alarm *AlarmException) (err error) {
	var key string
	var id Identifier

	if alarm.Id.IsEmpty() {
		key, id, err = db.findBytesKey("alarm-exception-", IDENTIFIER_LEN)
		if err != nil {
			return err
		}
	}

	alarm.Id = id

	return db.put(key, alarm)
}

func DeleteAlarmException(db *LevelDBStorage, alarm *AlarmException) (err error) {
	return db.delete(fmt.Sprintf("alarm-exception-%s", alarm.Id.ToString()))
}