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

func InitDB() {
	const dbPath string = "data/db/notify.db"
	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().Str("dbpath", dbPath).Msg("Database prepared and connected")
}

func sqlDeleteReminder(updateID int) {
	_, err := notifyDeleteReminder.Exec(updateID)
	if err != nil {
		log.Error().Err(err).Msg("Failed to execute SQL Query. Can't delete Reminder")
		return
	}

	log.Trace().Int("ID", updateID).Msg(("SQL: deleted 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 Query. Can't add Reminder")
		return
	}
	log.Trace().Interface("Reminder", reminder).Msg(("SQL: added Reminder"))
}

func sqlGetReminders() (reminders map[int]int64) {
	rows, err := notifyGetReminders.Query()
	if err != nil {
		log.Error().Err(err).Msg("Failed to execute SQL Query. Can't get Reminders")
		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 Result. Can't get Reminders")
			return

		}
	}

	log.Trace().Interface("Reminders", reminders).Msg(("SQL: got 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 Query. Can't get Reminder Details")
		return

	}
	log.Trace().Interface("Reminder", reminder).Msg(("SQL: got Reminder Details"))
	return reminder
}