package notify

import (
	"database/sql"
	"github.com/rs/zerolog/log"
	_ "modernc.org/sqlite"
)

var notifySetReminder *sql.Stmt
var notifyGetReminders *sql.Stmt
var notifyGetReminderDetails *sql.Stmt
var notifyDeleteReminder *sql.Stmt

// TODO logging
// TODO switch to SQL
func InitDB() {
	const dbPath string = "data/db/notify.db"
	log.Info().Str("dbpath", dbPath).Msg("init database")
	db, err := sql.Open("sqlite", dbPath)
	if err != nil {
		log.Panic().Err(err).Msg("failed to open sqlite database")
	}

	_, err = db.Exec("CREATE TABLE IF NOT EXISTS notify (updateID INTEGER,notifyTime INTEGER,chatID INTEGER, userID INTEGER,messageToReplyToID INTEGER,notifyText TEXT)")
	if err != nil {
		log.Panic().Err(err).Msg("failed to create table")
	}

	notifySetReminder, err = db.Prepare("INSERT OR REPLACE INTO notify (updateID,notifyTime,chatID, userID,messageToReplyToID,notifyText) values (?,?,?,?,?,?)")

	if err != nil {
		log.Panic().Err(err).Msg("failed to create sql statement")
	}

	notifyGetReminders, err = db.Prepare("SELECT updateID,notifyTime FROM notify")

	if err != nil {
		log.Panic().Err(err).Msg("failed to create sql statement")
	}

	notifyGetReminderDetails, err = db.Prepare("SELECT chatID, userID,messageToReplyToID,notifyText FROM notify WHERE updateID=?")

	if err != nil {
		log.Panic().Err(err).Msg("failed to create sql statement")
	}

	notifyDeleteReminder, err = db.Prepare("DELETE FROM notify WHERE updateID=?")

	if err != nil {
		log.Panic().Err(err).Msg("failed to create sql statement")
	}

	log.Info().Msg("init database: done")
}

func sqlDeleteReminder(updateID int) {
	_, err := notifyDeleteReminder.Exec(updateID)
	if err != nil {
		log.Error().Err(err).Msg("failed to execute SQL to delete reminder")
		return
	}

	log.Debug().Msg("executed SQL to delete reminder")
}

func sqlAddReminder(reminder reminderConfig) {
	_, err := notifySetReminder.Exec(reminder.updateID, reminder.notifyTime, reminder.chatID, reminder.userID, reminder.messageToReplyToID, reminder.reminderText)
	if err != nil {
		log.Error().Err(err).Msg("failed to execute SQL to add reminder")
		return
	}

	log.Debug().Msg("executed SQL to add reminder")
}

func sqlGetReminders() (reminders map[int]int64) {
	rows, err := notifyGetReminders.Query()
	if err != nil {
		log.Error().Err(err).Msg("failed to execute SQL to get reminder")
		return
	}

	reminders = make(map[int]int64)
	var c int
	var b int64
	for rows.Next() {
		switch err := rows.Scan(&c, &b); err {
		case nil:
			reminders[c] = b
		default:
			log.Error().Err(err).Msg("failed to parse SQL to get reminder")
			return

		}
	}

	log.Debug().Msg("executed SQL to get reminders")
	return reminders
}

func sqlGetReminderDetails(updateID int) (reminder reminderConfig) {
	row := notifyGetReminderDetails.QueryRow(updateID)

	switch err := row.Scan(&reminder.chatID, &reminder.userID, &reminder.messageToReplyToID, &reminder.reminderText); err {
	case nil:
		break
	default:
		log.Error().Err(err).Msg("failed to execute SQL to get reminder details")
		return

	}
	log.Debug().Msg("executed SQL to get reminder details")
	return reminder
}