/*
* @Author: Amalvy Arthur
 */

// This module uses a property named "subscribed_chats" in the shared Users structure.
// It consists of a list of chatID as a string, chatID are separated by ":" (unix PATH style)

// This module uses a property named "saved_messages" in the shared Chats structure
// It consists of a slice of string

package commands

import (
	"strconv"
	"strings"

	"../shared"
	tb "gopkg.in/tucnak/telebot.v2"
)

// Subscribe user sending the command to the current chat
// Command syntax : /subscribe
func Subscribe(m *tb.Message) {
	if m.Chat.Type != tb.ChatGroup && m.Chat.Type != tb.ChatSuperGroup {
		shared.Bot.Send(m.Chat, "Cette commande n'est pas authorisée pour ce type de chat")
		return
	}
	userSubscribedChats, exists := shared.Users.Get(m.Sender.Username, "subscribed_chats")
	if !exists {
		shared.Bot.Send(m.Chat, "Abonnement au chat : "+m.Chat.Title)
		shared.Users.Set(m.Sender.Username, "subscribed_chats", strconv.FormatInt(m.Chat.ID, 10))
		return
	}
	splittedChats := strings.Split(userSubscribedChats, ":")
	for _, chatID := range splittedChats {
		if chatID == strconv.FormatInt(m.Chat.ID, 10) {
			shared.Bot.Send(m.Chat, "Vous êtes déjà abonné à ce chat : "+m.Chat.Title)
			return
		}
	}
	shared.Bot.Send(m.Chat, "Abonnement au chat : "+m.Chat.Title)
	if len(userSubscribedChats) != 0 {
		shared.Users.Set(m.Sender.Username, "subscribed_chats", userSubscribedChats+":"+strconv.FormatInt(m.Chat.ID, 10))
	} else {
		shared.Users.Set(m.Sender.Username, "subscribed_chats", strconv.FormatInt(m.Chat.ID, 10))
	}
}

// Unsubscribe user sending the command from the current chat
// Command syntax : /unsubscribe
func Unsubscribe(m *tb.Message) {
	if m.Chat.Type != tb.ChatGroup && m.Chat.Type != tb.ChatSuperGroup {
		shared.Bot.Send(m.Chat, "Cette commande n'est pas authorisée pour ce type de chat")
		return
	}
	userSubscribedChats, exists := shared.Users.Get(m.Sender.Username, "subscribed_chats")
	if !exists || len(userSubscribedChats) == 0 {
		shared.Bot.Send(m.Chat, "Vous n'êtes abonné à aucun chat")
		return
	}
	splittedChats := strings.Split(userSubscribedChats, ":")
	for i, chatID := range splittedChats {
		if chatID == strconv.FormatInt(m.Chat.ID, 10) {
			shared.Bot.Send(m.Chat, "désabonnement du chat : "+m.Chat.Title)
			splittedChats = append(splittedChats[:i], splittedChats[i+1:]...)
			break
		}
	}
	shared.Users.Set(m.Sender.Username, "subscribed_chats", strings.Join(splittedChats, ":"))
}

// ListSubscribers List all subscribers of the current chat
// Command syntax : /listsubscribers
func ListSubscribers(m *tb.Message) {
	if m.Chat.Type != tb.ChatGroup && m.Chat.Type != tb.ChatSuperGroup {
		shared.Bot.Send(m.Chat, "Cette commande n'est pas authorisée pour ce type de chat")
		return
	}
	subscribers := m.Chat.Title + " subscribers : \n\n"
	for _, subscriber := range getSubscribers(m.Chat.ID) {
		subscribers = subscribers + "- " + subscriber + "\n"
	}
	shared.Bot.Send(m.Chat, subscribers)
}

// Publish a message from the current chat
// Command syntax (while repying to a message) : /publish
func Publish(m *tb.Message) {
	if m.ReplyTo == nil {
		shared.Bot.Send(m.Chat, "Veuillez répondre à un message pour le publier")
		return
	}

	defer shared.Bot.Send(m.Chat, "Message publié : "+m.ReplyTo.Text)
	savedMessages, exists := shared.ChatData.Get(m.Chat.ID, "published_messages")
	if !exists {
		messageList := []tb.Message{*m.ReplyTo}
		shared.ChatData.Set(m.Chat.ID, "published_messages", messageList)
		return
	}
	shared.ChatData.Set(
		m.Chat.ID,
		"published_messages",
		append(savedMessages.([]interface{}), *m.ReplyTo),
	)

}

// Unpublish remove a message from published messages in the current chat
// Command syntax : /unpublish [publication ID]
func Unpublish(m *tb.Message) {
	parsedCommand := strings.Split(m.Text, " ")
	if len(parsedCommand) < 2 {
		shared.Bot.Send(m.Chat, "syntaxe : /unpublish [publication ID]")
		return
	}
	index, err := strconv.Atoi(parsedCommand[1])
	if err != nil {
		shared.Bot.Send(m.Chat, "ID de publication invalide")
		return
	}
	savedMessages, exists := shared.ChatData.Get(m.Chat.ID, "published_messages")
	if !exists || len(savedMessages.([]interface{})) == 0 {
		shared.Bot.Send(m.Chat, "Aucun message publié")
		return
	}
	if len(savedMessages.([]interface{})) <= index || index < 0 {
		shared.Bot.Send(m.Chat, "Aucun message avec cet ID de publication n'existe")
		return
	}
	savedMessages = append(savedMessages.([]interface{})[:index], savedMessages.([]interface{})[index+1:]...)
	shared.ChatData.Set(m.Chat.ID, "published_messages", savedMessages)
	shared.Bot.Send(m.Chat, "Message supprimé des publication")
}

// Retrieve If performed in MP : retrieve all messages from all subscribed sources for the user
// If performed in Group Chat : retrieved all published messages for this chat
// Command syntax : /retrieve
func Retrieve(m *tb.Message) {
	chatList := []int64{}
	messageList := []tb.Message{}

	if m.Chat.Type != tb.ChatGroup && m.Chat.Type != tb.ChatSuperGroup && m.Chat.Type != tb.ChatPrivate {
		shared.Bot.Send(m.Chat, "Cette commande n'est pas autorisée pour ce type de chat")
		return
	}

	if m.Chat.Type == tb.ChatPrivate {
		userSubscribedChats, exists := shared.Users.Get(m.Sender.Username, "subscribed_chats")
		if !exists || len(userSubscribedChats) == 0 {
			shared.Bot.Send(m.Chat, "Aucun abonnements")
			return
		}

		for _, chat := range strings.Split(userSubscribedChats, ":") {
			chatID, err := strconv.ParseInt(chat, 10, 64)
			if err != nil {
				shared.Bot.Send(m.Chat, "Erreur lors de la récupération de vos évènements")
				return
			}
			chatList = append(chatList, chatID)
		}
	}

	if m.Chat.Type == tb.ChatGroup || m.Chat.Type == tb.ChatSuperGroup {
		chatList = append(chatList, m.Chat.ID)
	}

	for _, chatID := range chatList {
		if savedMessages, exists := shared.ChatData.Get(chatID, "published_messages"); exists {
			for _, message := range savedMessages.([]interface{}) {
				if message, ok := message.(tb.Message); ok {
					messageList = append(messageList, message)
				}
			}
		}
	}

	if len(messageList) == 0 {
		shared.Bot.Send(m.Chat, "Aucun message publié")
		return
	}

	shared.Bot.Send(m.Chat, "--- Messages publiés ---")
	for _, message := range messageList {
		shared.Bot.Forward(m.Chat, &message)
	}
	shared.Bot.Send(m.Chat, "--- Messages publiés ---")
}

// Get all users subscribed to the provided channel
func getSubscribers(chatID int64) []string {
	var subscribers []string
	for _, username := range shared.Users.GetUsernames() {
		userSubscribedChats, exists := shared.Users.Get(username, "subscribed_chats")
		if exists {
			splittedChats := strings.Split(userSubscribedChats, ":")
			for _, splittedChatID := range splittedChats {
				if splittedChatID == strconv.FormatInt(chatID, 10) {
					subscribers = append(subscribers, username)
				}
			}
		}
	}
	return subscribers
}