package telegram

import (
	"strconv"
	"strings"

	"dev.narayana.im/narayana/telegabber/xmpp/gateway"

	log "github.com/sirupsen/logrus"
)

const notEnoughArguments string = "Not enough arguments"
const telegramNotInitialized string = "Telegram connection is not initialized yet"

var transportCommands = map[string]command{
	"login":    command{"phone", "sign in"},
	"logout":   command{"", "sign out"},
	"code":     command{"", "check one-time code"},
	"password": command{"", "check 2fa password"},
	//"setusername": command{"", "update @username"},
	//"setname":     command{"first last", "update name"},
	//"setbio":      command{"", "update about"},
	//"setpassword": command{"[old] [new]", "set or remove password"},
	//"config":      command{"[param] [value]", "view or update configuration options"},
}

var chatCommands = map[string]command{
	//"d":          command{"[n]", "delete your last message(s)"},
	//"s":          command{"regex replace", "edit your last message"},
	//"add":        command{"@username", "add @username to your chat list"},
	//"join":       command{"https://t.me/invite_link", "join to chat via invite link"},
	//"group":      command{"title", "create groupchat «title» with current user"},
	//"supergroup": command{"title description", "create new supergroup «title» with «description»"},
	//"channel":    command{"title description", "create new channel «title» with «description»"},
	//"secret":     command{"", "create secretchat with current user"},
	//"search":     command{"string [limit]", "search <string> in current chat"},
	//"history":    command{"[limit]", "get last [limit] messages from current chat"},
	//"block":      command{"", "blacklist current user"},
	//"unblock":    command{"", "unblacklist current user"},
	//"invite":     command{"id or @username", "add user to current chat"},
	//"kick":       command{"id or @username", "remove user to current chat"},
	//"ban":        command{"id or @username [hours]", "restrict @username from current chat for [hours] or forever"},
	//"leave":      command{"", "leave current chat"},
	//"close":      command{"", "close current secret chat"},
	//"delete":     command{"", "delete current chat from chat list"},
	//"members":    command{"[query]", "search members [by optional query] in current chat (requires admin rights)"},
}

var transportConfigurationOptions = map[string]configurationOption{
	//"timezone": configurationOption{"00:00", "adjust timezone for Telegram user statuses"}
}

type command struct {
	arguments   string
	description string
}
type configurationOption command

type helpType int

const (
	helpTypeTransport helpType = iota
	helpTypeChat
)

func helpString(ht helpType) string {
	var str strings.Builder
	var commandMap map[string]command

	switch ht {
	case helpTypeTransport:
		commandMap = transportCommands
	case helpTypeChat:
		commandMap = chatCommands
	}

	str.WriteString("Available commands:\n")
	for name, command := range commandMap {
		str.WriteString("/")
		str.WriteString(name)
		if command.arguments != "" {
			str.WriteString(" ")
			str.WriteString(command.arguments)
		}
		str.WriteString(" — ")
		str.WriteString(command.description)
		str.WriteString("\n")
	}

	if ht == helpTypeTransport {
		str.WriteString("Configuration options\n")
		for name, option := range transportConfigurationOptions {
			str.WriteString(name)
			str.WriteString(" ")
			str.WriteString(option.arguments)
			str.WriteString(" — ")
			str.WriteString(option.description)
			str.WriteString("\n")
		}
	}

	return str.String()
}

func parseCommand(cmdline string) (string, []string) {
	bodyFields := strings.Fields(cmdline)
	return bodyFields[0][1:], bodyFields[1:]
}

// ProcessTransportCommand executes a command sent directly to the component
// and returns a response
func (c *Client) ProcessTransportCommand(cmdline string) string {
	cmd, args := parseCommand(cmdline)
	switch cmd {
	case "login", "code", "password":
		if cmd == "login" && c.Session.Login != "" {
			return ""
		}

		if len(args) < 1 {
			return notEnoughArguments
		}
		if c.authorizer == nil {
			return telegramNotInitialized
		}

		switch cmd {
		// sign in
		case "login":
			c.authorizer.PhoneNumber <- args[0]
			c.Session.Login = args[0]
		// check auth code
		case "code":
			c.authorizer.Code <- args[0]
		// check auth password
		case "password":
			c.authorizer.Password <- args[0]
		}
	// sign out
	case "logout":
		_, err := c.client.LogOut()
		if err != nil {
			log.Errorf("Logout error: %v", err)
		}

		for id := range c.cache.chats {
			gateway.SendPresence(
				c.xmpp,
				c.jid,
				gateway.SPFrom(strconv.FormatInt(id, 10)),
				gateway.SPType("unsubscribed"),
			)
		}

		c.Session.Login = ""
	case "help":
		return helpString(helpTypeTransport)
	}

	return ""
}

// ProcessChatCommand executes a command sent in a mapped chat
// and returns a response and the status of command support
func (c *Client) ProcessChatCommand(cmdline string) (string, bool) {
	cmd, _ := parseCommand(cmdline)
	switch cmd {
	case "help":
		return helpString(helpTypeChat), true
	}

	return "", false
}