package remind

import (
	"fmt"
	"git.fromouter.space/hamcha/tg"
	"log"
	"sort"
	"time"
)

func (m *Module) cmdReminder(message *tg.APIMessage) {

	// Should only work in private chats
	if message.Chat.Type != tg.ChatTypePrivate {

		m.client.SendTextMessage(tg.ClientTextMessageData{
			ChatID:  message.Chat.ChatID,
			Text:    "Per favore chiedimi in privato dei reminder",
			ReplyID: &message.MessageID,
		})
		return
	}

	reminders := remindersOfUser(message.User.UserID)

	if len(reminders) == 0 {
		m.client.SendTextMessage(tg.ClientTextMessageData{
			ChatID:  message.Chat.ChatID,
			Text:    "Non ci sono reminder in coda per te",
			ReplyID: &message.MessageID,
		})
	} else {
		m.client.SendTextMessage(tg.ClientTextMessageData{
			ChatID:  message.Chat.ChatID,
			Text:    renderReminderEntry(0, reminders, defaultLocation),
			ReplyID: &message.MessageID,
			ReplyMarkup: &tg.APIInlineKeyboardMarkup{
				InlineKeyboard: [][]tg.APIInlineKeyboardButton{makeReminderInlineKeyboard(0, reminders)},
			},
		})
	}
}

func (m *Module) handleCallback(callback *tg.APICallbackQuery) {
	if callback.Data == nil {
		return
	}

	var command, reminderID string
	_, err := fmt.Sscan(*callback.Data, &command, &reminderID)
	if err != nil {
		log.Println("[remind] WARN: weird callback received: " + err.Error())
		return
	}

	reminders := remindersOfUser(callback.User.UserID)

	switch command {
	case "GET":
		current := 0
		for index, reminder := range reminders {
			if reminder.ReminderID == reminderID {
				current = index
				break
			}
		}
		// Modify message with requested reminder
		m.client.EditText(tg.ClientEditTextData{
			ChatID:    callback.Message.Chat.ChatID,
			MessageID: callback.Message.MessageID,
			Text:      renderReminderEntry(current, reminders, defaultLocation),
			ReplyMarkup: &tg.APIInlineKeyboardMarkup{
				InlineKeyboard: [][]tg.APIInlineKeyboardButton{makeReminderInlineKeyboard(current, reminders)},
			},
		})
	}
}

func remindersOfUser(userID int64) (reminders []Reminder) {
	for _, reminder := range pending.Copy() {
		if reminder.TargetID == userID {
			reminders = append(reminders, reminder)
		}
	}
	if len(reminders) > 0 {
		sort.Slice(reminders, func(a, b int) bool { return reminders[a].When < reminders[b].When })
	}
	return
}

func renderReminderEntry(current int, reminders []Reminder, loc *time.Location) string {
	reminder := reminders[current]
	when := time.Unix(reminder.When, 0)
	message := reminder.Text
	if reminder.Reference != nil {
		if message != "" {
			message += ", "
		}
		message += fmt.Sprintf("https://t.me/c/%d/%d", reminder.Reference.Chat, reminder.Reference.Message)
	}

	return fmt.Sprintf("<b>Reminder %d</b> (/%d):\n%s\n<b>Quando:</b> %s", current+1, len(reminders), message, formatWhen(when, loc))
}

func makeReminderInlineKeyboard(current int, reminders []Reminder) (buttons []tg.APIInlineKeyboardButton) {
	if current > 0 {
		buttons = append(buttons, tg.APIInlineKeyboardButton{
			Text:         "⬅",
			CallbackData: fmt.Sprintf("GET %s", reminders[current-1].ReminderID),
		})
	}
	buttons = append(buttons, tg.APIInlineKeyboardButton{
		Text:         "❌",
		CallbackData: fmt.Sprintf("DELETE %s", reminders[current].ReminderID),
	})
	if current < len(reminders)-1 {
		buttons = append(buttons, tg.APIInlineKeyboardButton{
			Text:         "➡",
			CallbackData: fmt.Sprintf("GET %s", reminders[current+1].ReminderID),
		})
	}
	return
}