package gateway

import (
	"sort"
	"strings"

	"dev.narayana.im/narayana/telegabber/persistence"

	"github.com/zelenin/go-tdlib/client"
	"gosrc.io/xmpp/stanza"
)

// HashedAvatar stores a SHA-1 hash and a Telegram file ID
type HashedAvatar struct {
	Hash string
	File int32
}

type command struct {
	RequiredArgs int
	Arguments    []string
	Description  string
	LoginOnly    bool
	NotFor       *[]ChatType
	OnlineOnly   bool
}

// ChatType is an enum of chat types, roughly corresponding to TDLib's one but better
type ChatType int

const (
	ChatTypeUnknown ChatType = iota
	ChatTypePrivate
	ChatTypeBasicGroup
	ChatTypeSupergroup
	ChatTypeSecret
	ChatTypeChannel
)

var TransportCommands = map[string]command{
	"help":        command{0, []string{}, "help", false, nil, false},
	"login":       command{1, []string{"phone"}, "sign in", false, nil, false},
	"logout":      command{0, []string{}, "sign out", true, nil, true},
	"cleanup":     command{0, []string{}, "unsubscribe from all known chats", false, nil, false},
	"cancelauth":  command{0, []string{}, "quit the signin wizard", false, nil, false},
	"code":        command{1, []string{"xxxxx"}, "check one-time code", false, nil, false},
	"password":    command{1, []string{"********"}, "check 2fa password", false, nil, false},
	"setusername": command{0, []string{"@username"}, "update @username", true, nil, true},
	"setname":     command{1, []string{"first", "last"}, "update name", true, nil, false},
	"setbio":      command{0, []string{"Lorem ipsum"}, "update about", true, nil, true},
	"setpassword": command{0, []string{"old", "new"}, "set or remove password", true, nil, true},
	"config":      command{0, []string{"param", "value"}, "view or update configuration options", false, nil, false},
	"status":      command{0, []string{}, "display current login stage", false, nil, false},
	"report":      command{2, []string{"chat", "comment"}, "report a chat by id or @username", true, nil, true},
	"add":         command{1, []string{"@username"}, "add @username to your chat list", true, nil, true},
	"join":        command{1, []string{"https://t.me/invite_link"}, "join to chat via invite link or @publicname", true, nil, true},
	"supergroup":  command{1, []string{"title", "description"}, "create new supergroup «title» with «description»", true, nil, true},
	"channel":     command{1, []string{"title", "description"}, "create new channel «title» with «description»", true, nil, true},
	"preset":      command{1, []string{"modern|classic|pass"}, "apply a config preset", false, nil, false},
	"pass":        command{0, []string{}, "proceed to next login stage", false, nil, false},
	"finish":      command{0, []string{}, "skip post-login configuration", false, nil, false},
}

var notForGroups = []ChatType{ChatTypeBasicGroup, ChatTypeSupergroup, ChatTypeChannel}
var notForPM = []ChatType{ChatTypePrivate, ChatTypeSecret}
var notForPMAndBasic = []ChatType{ChatTypePrivate, ChatTypeSecret, ChatTypeBasicGroup}
var onlyForSecret = []ChatType{ChatTypePrivate, ChatTypeBasicGroup, ChatTypeSupergroup, ChatTypeChannel}

var ChatCommands = map[string]command{
	"help":       command{0, []string{}, "help", false, nil, false},
	"d":          command{0, []string{"n"}, "delete your last message(s)", true, nil, true},
	"s":          command{1, []string{"edited message"}, "edit your last message", true, nil, true},
	"silent":     command{1, []string{"message"}, "send a message without sound", true, nil, true},
	"schedule":   command{2, []string{"{online | 2006-01-02T15:04:05 | 15:04:05}", "message"}, "schedules a message either to timestamp or to whenever the user goes online", true, nil, true},
	"raw":        command{1, []string{"message"}, "send a raw message not interpeted as a transport command (e.g. a bot command)", true, nil, true},
	"forward":    command{2, []string{"message_id", "target_chat"}, "forwards a message", true, nil, true},
	"vcard":      command{0, []string{}, "print vCard as text", true, nil, true},
	"add":        command{1, []string{"@username"}, "add @username to your chat list", true, nil, true},
	"join":       command{1, []string{"https://t.me/invite_link"}, "join to chat via invite link or @publicname", true, nil, true},
	"group":      command{1, []string{"title"}, "create groupchat «title» with current user", true, &notForGroups, true},
	"supergroup": command{1, []string{"title", "description"}, "create new supergroup «title» with «description»", true, nil, true},
	"channel":    command{1, []string{"title", "description"}, "create new channel «title» with «description»", true, nil, true},
	"secret":     command{0, []string{}, "create secretchat with current user", true, &notForGroups, true},
	"search":     command{0, []string{"string", "[limit]"}, "search <string> in current chat", true, nil, true},
	"history":    command{0, []string{"limit"}, "get last [limit] messages from current chat", true, nil, true},
	"block":      command{0, []string{}, "blacklist current user", true, &notForGroups, true},
	"unblock":    command{0, []string{}, "unblacklist current user", true, &notForGroups, true},
	"invite":     command{1, []string{"id or @username"}, "add user to current chat", true, &notForPM, true},
	"link":       command{0, []string{}, "get invite link for current chat", true, &notForPM, true},
	"kick":       command{1, []string{"id or @username"}, "remove user from current chat", true, &notForPM, true},
	"mute":       command{0, []string{"id or @username", "hours"}, "mute the whole chat or a user in current chat", true, &notForPMAndBasic, true},
	"unmute":     command{0, []string{"id or @username"}, "unmute the whole chat or a user in the current chat", true, &notForPMAndBasic, true},
	"ban":        command{1, []string{"id or @username", "hours"}, "restrict @username from current chat for [hours] or forever", true, &notForPM, true},
	"unban":      command{1, []string{"id or @username"}, "unbans @username in current chat (and devotes from admins)", true, &notForPM, true},
	"promote":    command{1, []string{"id or @username", "title"}, "promote user to admin in current chat", true, &notForPM, true},
	"leave":      command{0, []string{}, "leave current chat", true, &notForPM, true},
	"leave!":     command{0, []string{}, "leave current chat (for owners)", true, &notForPM, true},
	"ttl":        command{0, []string{"seconds"}, "set secret chat messages TTL before self-destroying", true, &onlyForSecret, true},
	"close":      command{0, []string{}, "close current secret chat", true, &onlyForSecret, true},
	"delete":     command{0, []string{}, "delete current chat from chat list", true, nil, true},
	"members":    command{0, []string{"query"}, "search members [by optional query] in current chat (requires admin rights)", true, nil, true},
}

// CommandType distinguishes command sets by chat
type CommandType int

const (
	CommandTypeTransport CommandType = iota
	CommandTypeChat
)

// OnlineFilter is a tri-state condition for commands selection
type OnlineFilter int

const (
	OnlineFilterOnline OnlineFilter = iota
	OnlineFilterNotOnline
	OnlineFilterAny
)

// SortedCommandKeys sorts a slice with command keys
func SortedCommandKeys(commandMap map[string]command, onlineFilter OnlineFilter) []string {
	keys := make([]string, len(commandMap))

	i := 0
	for k := range commandMap {
		command := commandMap[k]
		if (onlineFilter == OnlineFilterOnline && !command.OnlineOnly) || (onlineFilter == OnlineFilterNotOnline && command.OnlineOnly) {
			continue
		}

		keys[i] = k
		i++
	}
	keys = keys[:i]

	sort.Strings(keys)

	return keys
}

func CommandsToHelpString(str *strings.Builder, chatType ChatType, onlineFilter OnlineFilter, commandMap map[string]command) {
	for _, name := range SortedCommandKeys(commandMap, onlineFilter) {
		command := commandMap[name]
		if !IsCommandForChatType(command, chatType) {
			continue
		}
		str.WriteString(CommandToHelpString(name, command))
		str.WriteString("\n")
	}
}

// GetCommands exposes the set of commands
func GetCommands(typ CommandType) map[string]command {
	var commandMap map[string]command

	switch typ {
	case CommandTypeTransport:
		commandMap = TransportCommands
	case CommandTypeChat:
		commandMap = ChatCommands
	}

	return commandMap
}

// GetCommand obtains one command
func GetCommand(typ CommandType, cmd string) (command, bool) {
	commands := GetCommands(typ)
	command, ok := commands[cmd]
	return command, ok
}

// CommandToHelpString builds a text description of a command
func CommandToHelpString(name string, cmd command) string {
	var str strings.Builder

	str.WriteString("/")
	str.WriteString(name)
	for i, arg := range cmd.Arguments {
		optional := i >= cmd.RequiredArgs
		str.WriteString(" ")
		if optional {
			str.WriteString("[")
		}
		str.WriteString(arg)
		if optional {
			str.WriteString("]")
		}
	}
	str.WriteString(" — ")
	str.WriteString(cmd.Description)

	return str.String()
}

// IsCommandFor checks the suitability of a command for a chat type
func IsCommandForChatType(cmd command, chatType ChatType) bool {
	if cmd.NotFor != nil {
		for _, typ := range *cmd.NotFor {
			if chatType == typ {
				return false
			}
		}
	}

	return true
}

// TelegramSession exists merely to circumvent a circular dependency
type TelegramSession interface {
	GetPersistenceSession() *persistence.Session
	GetContactByID(int64, *client.Chat, bool) (*client.Chat, *client.User, error)
	IsGroup(*client.Chat) bool
	GetChatDescription(*client.Chat) string
	GetChatMemberCount(*client.Chat) int32
	GetHashedAvatar(int64) *HashedAvatar
	CanBeCalled(int64) bool
	GetMUCNickname(int64) string
	GetChatType(int64, bool) (ChatType, *client.Chat, error)
	GetVerDisco(string) (*stanza.DiscoInfo, bool)
}