package telegram

import (
	"crypto/sha1"
	"crypto/sha256"
	"fmt"
	"github.com/pkg/errors"
	"io"
	"os"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"
	"time"

	"dev.narayana.im/narayana/telegabber/telegram/cache"
	"dev.narayana.im/narayana/telegabber/telegram/formatter"
	"dev.narayana.im/narayana/telegabber/xmpp/gateway"

	log "github.com/sirupsen/logrus"
	"github.com/soheilhy/args"
	"github.com/godcong/go-tdlib/client"
)

var errOffline = errors.New("TDlib instance is offline")

var spaceRegex = regexp.MustCompile(`\s+`)
var replyRegex = regexp.MustCompile("> ?([0-9]{10,})")

const newlineChar string = "\n"

// GetContactByUsername resolves username to user id retrieves user and chat information
func (c *Client) GetContactByUsername(username string) (*client.Chat, *client.User, error) {
	if !c.Online() {
		return nil, nil, errOffline
	}

	chat, err := c.client.SearchPublicChat(&client.SearchPublicChatRequest{
		Username: username,
	})

	if err != nil {
		return nil, nil, err
	}

	return c.GetContactByID(chat.ID, chat)
}

// GetContactByID gets user and chat information from cache (or tries to retrieve it, if missing)
func (c *Client) GetContactByID(id int64, chat *client.Chat) (*client.Chat, *client.User, error) {
	if !c.Online() {
		return nil, nil, errOffline
	}

	var user *client.User
	var cacheChat *client.Chat
	var ok bool
	var err error

	user, ok = c.cache.GetUser(id)
	if !ok && id > 0 {
		user, err = c.client.GetUser(&client.GetUserRequest{
			UserID: id,
		})
		if err == nil {
			c.cache.SetUser(id, user)
		}
	}

	cacheChat, ok = c.cache.GetChat(id)
	if !ok {
		if chat == nil {
			cacheChat, err = c.client.GetChat(&client.GetChatRequest{
				ChatID: id,
			})
			if err != nil {
				// error is irrelevant if the user was found successfully
				if user != nil {
					return nil, user, nil
				}

				return nil, nil, err
			}

			c.cache.SetChat(id, cacheChat)
		} else {
			c.cache.SetChat(id, chat)
		}
	}
	if chat == nil {
		chat = cacheChat
	}

	return chat, user, nil
}

func (c *Client) userStatusToText(status client.UserStatus) (string, string) {
	var show, textStatus string

	switch status.UserStatusType() {
	case client.TypeUserStatusOnline:
		textStatus = "Online"
	case client.TypeUserStatusRecently:
		show, textStatus = "dnd", "Last seen recently"
	case client.TypeUserStatusLastWeek:
		show, textStatus = "unavailable", "Last seen last week"
	case client.TypeUserStatusLastMonth:
		show, textStatus = "unavailable", "Last seen last month"
	case client.TypeUserStatusEmpty:
		show, textStatus = "unavailable", "Last seen a long time ago"
	case client.TypeUserStatusOffline:
		offlineStatus, _ := status.(*client.UserStatusOffline)
		// this will stop working in 2038 O\
		elapsed := time.Now().Unix() - int64(offlineStatus.WasOnline)
		if elapsed < 3600 {
			show = "away"
		} else {
			show = "xa"
		}
		textStatus = time.Unix(int64(offlineStatus.WasOnline), 0).
			In(c.Session.TimezoneToLocation()).
			Format("Last seen at 15:04 02/01/2006")
	}

	return show, textStatus
}

// ProcessStatusUpdate sets contact status
func (c *Client) ProcessStatusUpdate(chatID int64, status string, show string, args ...args.V) error {
	if !c.Online() {
		return nil
	}

	log.WithFields(log.Fields{
		"chat_id": chatID,
	}).Info("Status update for")

	chat, user, err := c.GetContactByID(chatID, nil)
	if err != nil {
		return err
	}

	var photo string
	if chat != nil && chat.Photo != nil {
		path := chat.Photo.Small.Local.Path
		file, err := os.Open(path)
		if err == nil {
			defer file.Close()

			hash := sha1.New()
			_, err = io.Copy(hash, file)
			if err == nil {
				photo = fmt.Sprintf("%x", hash.Sum(nil))
			} else {
				log.Errorf("Error calculating hash: %v", path)
			}
		} else if path != "" {
			log.Errorf("Photo does not exist: %v", path)
		}
	}

	if status == "" {
		if user != nil {
			show, status = c.userStatusToText(user.Status)
		} else {
			show, status = "chat", chat.Title
		}
	}

	c.cache.SetStatus(chatID, show, status)

	gateway.SendPresence(
		c.xmpp,
		c.jid,
		gateway.SPFrom(strconv.FormatInt(chatID, 10)),
		gateway.SPShow(show),
		gateway.SPStatus(status),
		gateway.SPPhoto(photo),
		gateway.SPImmed(gateway.SPImmed.Get(args)),
	)

	return nil
}

func (c *Client) formatContact(chatID int64) string {
	if chatID == 0 {
		return ""
	}

	chat, user, err := c.GetContactByID(chatID, nil)
	if err != nil {
		return "unknown contact: " + err.Error()
	}

	var str string
	if chat != nil {
		str = fmt.Sprintf("%s (%v)", chat.Title, chat.ID)
	} else if user != nil {
		username := user.Username
		if username == "" {
			username = strconv.FormatInt(user.ID, 10)
		}

		str = fmt.Sprintf("%s %s (%v)", user.FirstName, user.LastName, username)
	} else {
		str = strconv.FormatInt(chatID, 10)
	}

	str = spaceRegex.ReplaceAllString(str, " ")

	return str
}

func (c *Client) formatMessage(chatID int64, messageID int64, preview bool, message *client.Message) string {
	var err error
	if message == nil {
		message, err = c.client.GetMessage(&client.GetMessageRequest{
			ChatID:    chatID,
			MessageID: messageID,
		})
		if err != nil {
			return fmt.Sprintf("<error fetching message: %s>", err.Error())
		}
	}

	if message == nil {
		return ""
	}

	var str strings.Builder
	var senderId int64
	switch message.Sender.MessageSenderType() {
	case client.TypeMessageSenderUser:
		senderUser, _ := message.Sender.(*client.MessageSenderUser)
		senderId = senderUser.UserID
	case client.TypeMessageSenderChat:
		senderChat, _ := message.Sender.(*client.MessageSenderChat)
		senderId = senderChat.ChatID
	}
	str.WriteString(fmt.Sprintf("%v | %s | ", message.ID, c.formatContact(senderId)))
	if !preview {
		str.WriteString(
			time.Unix(int64(message.Date), 0).
				In(c.Session.TimezoneToLocation()).
				Format("02 Jan 2006 15:04:05 | "),
		)
	}

	var text string
	if message.Content != nil {
		switch message.Content.MessageContentType() {
		case client.TypeMessageText:
			messageText, _ := message.Content.(*client.MessageText)
			text = messageText.Text.Text
			// TODO: handle other message types with labels (not supported in Zhabogram!)
		}
	}
	if text != "" {
		if !preview {
			str.WriteString(text)
		} else {
			newlinePos := strings.Index(text, newlineChar)
			if !preview || newlinePos == -1 {
				str.WriteString(text)
			} else {
				str.WriteString(text[0:newlinePos])
			}
		}
	}

	return str.String()
}

func (c *Client) formatContent(file *client.File, filename string) string {
	if file == nil {
		return ""
	}

	return fmt.Sprintf(
		"%s (%v kbytes) | %s/%s%s",
		filename,
		file.Size/1024,
		c.content.Link,
		fmt.Sprintf("%x", sha256.Sum256([]byte(file.Remote.ID))),
		filepath.Ext(filename),
	)
}

func (c *Client) messageToText(message *client.Message) string {
	if message.Content == nil {
		log.Warnf("Unknown message (big emoji?): %#v", message)
		return "<BIG EMOJI>"
	}

	markupFunction := formatter.EntityToXEP0393
	switch message.Content.MessageContentType() {
	case client.TypeMessageSticker:
		sticker, _ := message.Content.(*client.MessageSticker)
		return sticker.Sticker.Emoji
	case client.TypeMessageBasicGroupChatCreate, client.TypeMessageSupergroupChatCreate:
		return "has created chat"
	case client.TypeMessageChatJoinByLink:
		return "joined chat via invite link"
	case client.TypeMessageChatAddMembers:
		addMembers, _ := message.Content.(*client.MessageChatAddMembers)

		text := "invited "
		if len(addMembers.MemberUserIDs) > 0 {
			text += c.formatContact(addMembers.MemberUserIDs[0])
		}

		return text
	case client.TypeMessageChatDeleteMember:
		deleteMember, _ := message.Content.(*client.MessageChatDeleteMember)
		return "kicked " + c.formatContact(deleteMember.UserID)
	case client.TypeMessagePinMessage:
		pinMessage, _ := message.Content.(*client.MessagePinMessage)
		return "pinned message: " + c.formatMessage(message.ChatID, pinMessage.MessageID, false, nil)
	case client.TypeMessageChatChangeTitle:
		changeTitle, _ := message.Content.(*client.MessageChatChangeTitle)
		return "chat title set to: " + changeTitle.Title
	case client.TypeMessageLocation:
		location, _ := message.Content.(*client.MessageLocation)
		return fmt.Sprintf(
			"coordinates: %v,%v | https://www.google.com/maps/search/%v,%v/",
			location.Location.Latitude,
			location.Location.Longitude,
			location.Location.Latitude,
			location.Location.Longitude,
		)
	case client.TypeMessagePhoto:
		photo, _ := message.Content.(*client.MessagePhoto)
		return formatter.Format(
			photo.Caption.Text,
			formatter.SortEntities(photo.Caption.Entities),
			markupFunction,
		)
	case client.TypeMessageAudio:
		audio, _ := message.Content.(*client.MessageAudio)
		return formatter.Format(
			audio.Caption.Text,
			formatter.SortEntities(audio.Caption.Entities),
			markupFunction,
		)
	case client.TypeMessageVideo:
		video, _ := message.Content.(*client.MessageVideo)
		return formatter.Format(
			video.Caption.Text,
			formatter.SortEntities(video.Caption.Entities),
			markupFunction,
		)
	case client.TypeMessageDocument:
		document, _ := message.Content.(*client.MessageDocument)
		return formatter.Format(
			document.Caption.Text,
			formatter.SortEntities(document.Caption.Entities),
			markupFunction,
		)
	case client.TypeMessageText:
		text, _ := message.Content.(*client.MessageText)
		return formatter.Format(
			text.Text.Text,
			formatter.SortEntities(text.Text.Entities),
			markupFunction,
		)
	case client.TypeMessageVoiceNote:
		voice, _ := message.Content.(*client.MessageVoiceNote)
		return formatter.Format(
			voice.Caption.Text,
			formatter.SortEntities(voice.Caption.Entities),
			markupFunction,
		)
	case client.TypeMessageVideoNote:
		return ""
	case client.TypeMessageAnimation:
		animation, _ := message.Content.(*client.MessageAnimation)
		return formatter.Format(
			animation.Caption.Text,
			formatter.SortEntities(animation.Caption.Entities),
			markupFunction,
		)
	}

	return fmt.Sprintf("unknown message (%s)", message.Content.MessageContentType())
}

func (c *Client) contentToFilename(content client.MessageContent) (*client.File, string) {
	if content == nil {
		return nil, ""
	}

	switch content.MessageContentType() {
	case client.TypeMessageSticker:
		sticker, _ := content.(*client.MessageSticker)
		return sticker.Sticker.Sticker, "sticker.webp"
	case client.TypeMessageVoiceNote:
		voice, _ := content.(*client.MessageVoiceNote)
		return voice.VoiceNote.Voice, fmt.Sprintf("voice note (%v s.).oga", voice.VoiceNote.Duration)
	case client.TypeMessageVideoNote:
		video, _ := content.(*client.MessageVideoNote)
		return video.VideoNote.Video, fmt.Sprintf("video note (%v s.).mp4", video.VideoNote.Duration)
	case client.TypeMessageAnimation:
		animation, _ := content.(*client.MessageAnimation)
		return animation.Animation.Animation, "animation.mp4"
	case client.TypeMessagePhoto:
		photo, _ := content.(*client.MessagePhoto)
		sizes := photo.Photo.Sizes
		if len(sizes) > 1 {
			file := sizes[len(sizes)-1].Photo
			return file, strconv.FormatInt(file.ID, 10) + ".jpg"
		}
		return nil, ""
	case client.TypeMessageAudio:
		audio, _ := content.(*client.MessageAudio)
		return audio.Audio.Audio, audio.Audio.FileName
	case client.TypeMessageVideo:
		video, _ := content.(*client.MessageVideo)
		return video.Video.Video, video.Video.FileName
	case client.TypeMessageDocument:
		document, _ := content.(*client.MessageDocument)
		return document.Document.Document, document.Document.FileName
	}

	return nil, ""
}

func (c *Client) messageToPrefix(message *client.Message, fileString string) string {
	prefix := []string{}
	// message direction
	var directionChar string
	if message.IsOutgoing {
		directionChar = "⇾ "
	} else {
		directionChar = "⇽ "
	}
	prefix = append(prefix, directionChar+strconv.FormatInt(message.ID, 10))
	// show sender in group chats
	if message.ChatID < 0 && message.Sender != nil {
		var senderId int64
		switch message.Sender.MessageSenderType() {
		case client.TypeMessageSenderUser:
			senderUser, _ := message.Sender.(*client.MessageSenderUser)
			senderId = senderUser.UserID
		case client.TypeMessageSenderChat:
			senderChat, _ := message.Sender.(*client.MessageSenderChat)
			senderId = senderChat.ChatID
		}
		prefix = append(prefix, c.formatContact(senderId))
	}
	if message.ForwardInfo != nil {
		switch message.ForwardInfo.Origin.MessageForwardOriginType() {
		case client.TypeMessageForwardOriginUser:
			originUser := message.ForwardInfo.Origin.(*client.MessageForwardOriginUser)
			prefix = append(prefix, "fwd: "+c.formatContact(originUser.SenderUserID))
		case client.TypeMessageForwardOriginChat:
			originChat := message.ForwardInfo.Origin.(*client.MessageForwardOriginChat)
			var signature string
			if originChat.AuthorSignature != "" {
				signature = fmt.Sprintf(" (%s)", originChat.AuthorSignature)
			}
			prefix = append(prefix, "fwd: "+c.formatContact(originChat.SenderChatID)+signature)
		case client.TypeMessageForwardOriginHiddenUser:
			originUser := message.ForwardInfo.Origin.(*client.MessageForwardOriginHiddenUser)
			prefix = append(prefix, fmt.Sprintf("fwd: anonymous (%s)", originUser.SenderName))
		case client.TypeMessageForwardOriginChannel:
			channel := message.ForwardInfo.Origin.(*client.MessageForwardOriginChannel)
			var signature string
			if channel.AuthorSignature != "" {
				signature = fmt.Sprintf(" (%s)", channel.AuthorSignature)
			}
			prefix = append(prefix, "fwd: "+c.formatContact(channel.ChatID)+signature)
		}
	}
	// reply to
	if message.ReplyToMessageID != 0 {
		prefix = append(prefix, "reply: "+c.formatMessage(message.ChatID, message.ReplyToMessageID, true, nil))
	}
	if fileString != "" {
		prefix = append(prefix, "file: "+fileString)
	}

	return strings.Join(prefix, " | ")
}

// ProcessOutgoingMessage executes commands or sends messages to mapped chats
func (c *Client) ProcessOutgoingMessage(chatID int64, text string, messageID int64, returnJid string) {
	if messageID == 0 && strings.HasPrefix(text, "/") {
		// try to execute a command
		response, isCommand := c.ProcessChatCommand(chatID, text)
		if response != "" {
			gateway.SendMessage(returnJid, strconv.FormatInt(chatID, 10), response, c.xmpp)
		}
		// do not send on success
		if isCommand {
			return
		}
	}

	if !c.Online() {
		// we're offline
		return
	}

	log.Warnf("Send message to chat %v", chatID)

	if messageID != 0 {
		formattedText := &client.FormattedText{
			Text: text,
		}

		// compile our message
		message := &client.InputMessageText{
			Text: formattedText,
		}

		c.client.EditMessageText(&client.EditMessageTextRequest{
			ChatID:              chatID,
			MessageID:           messageID,
			InputMessageContent: message,
		})
	} else {
		// quotations
		var reply int64
		replySlice := replyRegex.FindStringSubmatch(text)
		if len(replySlice) > 1 {
			reply, _ = strconv.ParseInt(replySlice[1], 10, 64)
		}

		// attach a file
		var file *client.InputFileRemote
		if c.content.Upload != "" && strings.HasPrefix(text, c.content.Upload) {
			file = &client.InputFileRemote{
				ID: text,
			}
		}

		// remove first line from text
		if file != nil || reply != 0 {
			newlinePos := strings.Index(text, newlineChar)
			if newlinePos != -1 {
				text = text[newlinePos+1:]
			}
		}

		formattedText := &client.FormattedText{
			Text: text,
		}

		var message client.InputMessageContent
		if file != nil {
			// we can try to send a document
			message = &client.InputMessageDocument{
				Document: file,
				Caption:  formattedText,
			}
		} else {
			// compile our message
			message = &client.InputMessageText{
				Text: formattedText,
			}
		}

		_, err := c.client.SendMessage(&client.SendMessageRequest{
			ChatID:              chatID,
			ReplyToMessageID:    reply,
			InputMessageContent: message,
		})
		if err != nil {
			gateway.SendMessage(
				returnJid,
				strconv.FormatInt(chatID, 10),
				fmt.Sprintf("Message not sent: %s", err.Error()),
				c.xmpp,
			)
		}
	}
}

// StatusesRange proxies the following function from unexported cache
func (c *Client) StatusesRange() chan *cache.Status {
	return c.cache.StatusesRange()
}

func (c *Client) addResource(resource string) {
	if resource == "" {
		return
	}
	c.locks.resourcesLock.Lock()
	defer c.locks.resourcesLock.Unlock()

	c.resources[resource] = true
}

func (c *Client) deleteResource(resource string) {
	c.locks.resourcesLock.Lock()
	defer c.locks.resourcesLock.Unlock()

	if _, ok := c.resources[resource]; ok {
		delete(c.resources, resource)
	}
}

// refresh roster
func (c *Client) refresh(resource string) {
	if _, ok := c.resources[resource]; ok {
		return
	}

	log.Warnf("Refreshing roster for resource %v", resource)

	for _, chat := range c.cache.ChatsKeys() {
		c.ProcessStatusUpdate(chat, "", "")
	}

	c.addResource(resource)
}