package telegram

import (
	"testing"
	"time"

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

	"github.com/zelenin/go-tdlib/client"
)

const testTimeFormat string = "15:04 02/01/2006"

func TestOnlineStatus(t *testing.T) {
	c := Client{
		DelayedStatuses: make(map[int64]*DelayedStatus),
	}
	show, status, presenceType := (&c).userStatusToText(client.UserStatus(&client.UserStatusOnline{}), 0)
	if show != "" || status != "Online" || presenceType != "" {
		t.Errorf("Wrong online status: %v, %v", show, status)
	}
}

func TestOnlineRecently(t *testing.T) {
	show, status, presenceType := (&Client{}).userStatusToText(client.UserStatus(&client.UserStatusRecently{}), 0)
	if show != "dnd" || status != "Last seen recently" || presenceType != "" {
		t.Errorf("Wrong recently status: %v, %v", show, status)
	}
}

func TestOnlineOfflineAway(t *testing.T) {
	location := time.FixedZone("UTC+1", 3600)
	timestamp := time.Now().In(location).Unix() - 3599
	tm := time.Unix(timestamp, 0).In(location)
	c := &Client{
		Session: &persistence.Session{
			Timezone: "+01:00",
		},
	}
	show, status, presenceType := c.userStatusToText(client.UserStatus(&client.UserStatusOffline{WasOnline: int32(timestamp)}), 0)
	trueStatus := "Last seen at " + tm.Format(testTimeFormat)
	if show != "away" || status != trueStatus || presenceType != "" {
		t.Errorf("Wrong away status: %v, %v, should be %v", show, status, trueStatus)
	}
}

func TestOnlineOfflineXa(t *testing.T) {
	timestamp := time.Now().Unix() - 3601
	tm := time.Unix(timestamp, 0).UTC()
	c := &Client{
		Session: &persistence.Session{},
	}
	show, status, presenceType := c.userStatusToText(client.UserStatus(&client.UserStatusOffline{WasOnline: int32(timestamp)}), 0)
	trueStatus := "Last seen at " + tm.Format(testTimeFormat)
	if show != "xa" || status != trueStatus || presenceType != "" {
		t.Errorf("Wrong xa status: %v, %v, should be %v", show, status, trueStatus)
	}
}

func TestFormatMessageOneline(t *testing.T) {
	message := client.Message{
		Id: 42,
		Content: &client.MessageText{
			Text: &client.FormattedText{
				Text: "tist",
			},
		},
	}

	text := (&Client{}).formatMessage(0, 0, true, &message)
	if text != "42 |  | tist" {
		t.Errorf("Wrong oneline message formatting: %v", text)
	}
}

func TestFormatMessageMultiline(t *testing.T) {
	message := client.Message{
		Id: 42,
		Content: &client.MessageText{
			Text: &client.FormattedText{
				Text: "tist\nziz",
			},
		},
	}

	text := (&Client{}).formatMessage(0, 0, true, &message)
	if text != "42 |  | tist" {
		t.Errorf("Wrong multiline message formatting: %v", text)
	}
}

func TestFormatMessageOnelinePreview(t *testing.T) {
	message := client.Message{
		Id:   42,
		Date: 1200000000,
		Content: &client.MessageText{
			Text: &client.FormattedText{
				Text: "tist",
			},
		},
	}

	c := &Client{
		Session: &persistence.Session{},
	}
	text := c.formatMessage(0, 0, false, &message)
	if text != "42 |  | 10 Jan 2008 21:20:00 | tist" {
		t.Errorf("Wrong oneline preview message formatting: %v", text)
	}
}

func TestFormatMessageMultilinePreview(t *testing.T) {
	message := client.Message{
		Id:   42,
		Date: 1200000000,
		Content: &client.MessageText{
			Text: &client.FormattedText{
				Text: "tist\nziz",
			},
		},
	}

	c := &Client{
		Session: &persistence.Session{},
	}
	text := c.formatMessage(0, 0, false, &message)
	if text != "42 |  | 10 Jan 2008 21:20:00 | tist\nziz" {
		t.Errorf("Wrong multiline preview message formatting: %v", text)
	}
}

func TestFormatFile(t *testing.T) {
	file := client.File{
		Size: 23899,
		Local: &client.LocalFile{
			Path: "c:/Documents and Settings/blabla.jpg",
		},
		Remote: &client.RemoteFile{
			UniqueId: "tist",
		},
	}
	c := Client{
		content: &config.TelegramContentConfig{
			Link: "localhvost",
		},
	}

	content, link := c.formatFile(&file, false)
	if content != ". (23 kbytes) | " {
		t.Errorf("Wrong file label: %v", content)
	}
	if link != "" {
		t.Errorf("Wrong file link: %v", link)
	}
}

func TestFormatPreview(t *testing.T) {
	file := client.File{
		Size: 23899,
		Local: &client.LocalFile{
			Path: "c:/pron/smokovnica_vhsrip.mov",
		},
		Remote: &client.RemoteFile{
			UniqueId: "aZaZaZ",
		},
	}
	c := Client{
		content: &config.TelegramContentConfig{
			Link: "localhvost",
		},
	}

	content, link := c.formatFile(&file, true)
	if content != "" {
		t.Errorf("Wrong preview label: %v", content)
	}
	if link != "" {
		t.Errorf("Wrong preview link: %v", link)
	}
}

func TestMessageToTextSticker(t *testing.T) {
	sticker := client.Message{
		Content: &client.MessageSticker{
			Sticker: &client.Sticker{
				Emoji: "💩",
			},
		},
	}
	text := (&Client{}).messageToText(&sticker, false)
	if text != "💩" {
		t.Errorf("Not poop")
	}
}

func TestMessageToTextGroup(t *testing.T) {
	group := client.Message{
		Content: &client.MessageBasicGroupChatCreate{},
	}
	text := (&Client{}).messageToText(&group, false)
	if text != "has created chat" {
		t.Errorf("Who created the group?")
	}
}

func TestMessageToTextSupergroup(t *testing.T) {
	supergroup := client.Message{
		Content: &client.MessageSupergroupChatCreate{},
	}
	text := (&Client{}).messageToText(&supergroup, false)
	if text != "has created chat" {
		t.Errorf("Who created the supergroup?")
	}
}

func TestMessageChatJoin(t *testing.T) {
	join := client.Message{
		Content: &client.MessageChatJoinByLink{},
	}
	text := (&Client{}).messageToText(&join, false)
	if text != "joined chat via invite link" {
		t.Errorf("Non-joined")
	}
}

func TestMessageChatAddNoMembers(t *testing.T) {
	add := client.Message{
		Content: &client.MessageChatAddMembers{},
	}
	text := (&Client{}).messageToText(&add, false)
	if text != "invited " {
		t.Errorf("Invited someone anyway")
	}
}

func TestMessageChatChangeTitle(t *testing.T) {
	title := client.Message{
		Content: &client.MessageChatChangeTitle{
			Title: "Anime",
		},
	}
	text := (&Client{}).messageToText(&title, false)
	if text != "chat title set to: Anime" {
		t.Errorf("How to patch KDE2 for FreeBSD?")
	}
}

func TestMessageLocation(t *testing.T) {
	location := client.Message{
		Content: &client.MessageLocation{
			Location: &client.Location{
				Latitude:  50.8,
				Longitude: 42.0167,
			},
		},
	}
	text := (&Client{}).messageToText(&location, false)
	if text != "coordinates: 50.8,42.0167 | https://www.google.com/maps/search/50.8,42.0167/" {
		t.Errorf("Excuse me, I'm lost")
	}
}

func TestMessagePhoto(t *testing.T) {
	photo := client.Message{
		Content: &client.MessagePhoto{
			Caption: &client.FormattedText{
				Text: "tist",
			},
		},
	}
	text := (&Client{}).messageToText(&photo, false)
	if text != "tist" {
		t.Errorf("Wrong photo label")
	}
}

func TestMessageAudio(t *testing.T) {
	audio := client.Message{
		Content: &client.MessageAudio{
			Caption: &client.FormattedText{
				Text: "tist",
			},
		},
	}
	text := (&Client{}).messageToText(&audio, false)
	if text != "tist" {
		t.Errorf("Wrong audio label")
	}
}

func TestMessageVideo(t *testing.T) {
	video := client.Message{
		Content: &client.MessageVideo{
			Caption: &client.FormattedText{
				Text: "tist",
			},
		},
	}
	text := (&Client{}).messageToText(&video, false)
	if text != "tist" {
		t.Errorf("Wrong video label")
	}
}

func TestMessageDocument(t *testing.T) {
	document := client.Message{
		Content: &client.MessageDocument{
			Caption: &client.FormattedText{
				Text: "tist",
			},
		},
	}
	text := (&Client{}).messageToText(&document, false)
	if text != "tist" {
		t.Errorf("Wrong document label")
	}
}

func TestMessageText(t *testing.T) {
	textMessage := client.Message{
		Content: &client.MessageText{
			Text: &client.FormattedText{
				Text: "tist",
			},
		},
	}
	text := (&Client{}).messageToText(&textMessage, false)
	if text != "tist" {
		t.Errorf("Wrong text message")
	}
}

func TestMessageVoice(t *testing.T) {
	voice := client.Message{
		Content: &client.MessageVoiceNote{
			Caption: &client.FormattedText{
				Text: "tist",
			},
		},
	}
	text := (&Client{}).messageToText(&voice, false)
	if text != "tist" {
		t.Errorf("Wrong voice label")
	}
}

func TestMessageVideoNote(t *testing.T) {
	videoNote := client.Message{
		Content: &client.MessageVideoNote{},
	}
	text := (&Client{}).messageToText(&videoNote, false)
	if text != "" {
		t.Errorf("Wrong video note label")
	}
}

func TestMessageAnimation(t *testing.T) {
	animation := client.Message{
		Content: &client.MessageAnimation{
			Caption: &client.FormattedText{
				Text: "tist",
			},
		},
	}
	text := (&Client{}).messageToText(&animation, false)
	if text != "tist" {
		t.Errorf("Wrong animation label")
	}
}

func TestMessageTtl1(t *testing.T) {
	ttl := client.Message{
		Content: &client.MessageChatSetMessageAutoDeleteTime{},
	}
	text := (&Client{}).messageToText(&ttl, false)
	if text != "The self-destruct timer was disabled" {
		t.Errorf("Wrong anonymous off ttl label: %v", text)
	}
}

func TestMessageTtl2(t *testing.T) {
	ttl := client.Message{
		Content: &client.MessageChatSetMessageAutoDeleteTime{
			MessageAutoDeleteTime: 3,
		},
	}
	text := (&Client{}).messageToText(&ttl, false)
	if text != "The self-destruct timer was set to 3 seconds" {
		t.Errorf("Wrong anonymous ttl label: %v", text)
	}
}

func TestMessageTtl3(t *testing.T) {
	ttl := client.Message{
		Content: &client.MessageChatSetMessageAutoDeleteTime{
			FromUserId: 3,
		},
	}
	text := (&Client{}).messageToText(&ttl, false)
	if text != "unknown contact: TDlib instance is offline disabled the self-destruct timer" {
		t.Errorf("Wrong off ttl label: %v", text)
	}
}

func TestMessageTtl4(t *testing.T) {
	ttl := client.Message{
		Content: &client.MessageChatSetMessageAutoDeleteTime{
			FromUserId:            3,
			MessageAutoDeleteTime: 3,
		},
	}
	text := (&Client{}).messageToText(&ttl, false)
	if text != "unknown contact: TDlib instance is offline set the self-destruct timer to 3 seconds" {
		t.Errorf("Wrong ttl label: %v", text)
	}
}

func TestMessageUnknown(t *testing.T) {
	unknown := client.Message{
		Content: &client.MessageExpiredPhoto{},
	}
	text := (&Client{}).messageToText(&unknown, false)
	if text != "unknown message (messageExpiredPhoto)" {
		t.Errorf("Wrong label for unknown message")
	}
}

func TestMessageToPrefix1(t *testing.T) {
	message := client.Message{
		Id:         42,
		IsOutgoing: true,
		ForwardInfo: &client.MessageForwardInfo{
			Origin: &client.MessageOriginHiddenUser{
				SenderName: "ziz",
			},
		},
	}
	prefix, gatewayReply := (&Client{Session: &persistence.Session{}}).messageToPrefix(&message, "", "", false)
	if prefix != "➡ 42 | fwd: ziz" {
		t.Errorf("Wrong prefix: %v", prefix)
	}
	if gatewayReply != nil {
		t.Errorf("Reply is not nil: %v", gatewayReply)
	}
}

func TestMessageToPrefix2(t *testing.T) {
	message := client.Message{
		Id: 56,
		ForwardInfo: &client.MessageForwardInfo{
			Origin: &client.MessageOriginChannel{
				AuthorSignature: "zaz",
			},
		},
	}
	prefix, gatewayReply := (&Client{Session: &persistence.Session{}}).messageToPrefix(&message, "y.jpg", "", false)
	if prefix != "⬅ 56 | fwd:  (zaz) | preview: y.jpg" {
		t.Errorf("Wrong prefix: %v", prefix)
	}
	if gatewayReply != nil {
		t.Errorf("Reply is not nil: %v", gatewayReply)
	}
}

func TestMessageToPrefix3(t *testing.T) {
	message := client.Message{
		Id: 56,
		ForwardInfo: &client.MessageForwardInfo{
			Origin: &client.MessageOriginChannel{
				AuthorSignature: "zuz",
			},
		},
	}
	prefix, gatewayReply := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "", "a.jpg", false)
	if prefix != "< 56 | fwd:  (zuz) | file: a.jpg" {
		t.Errorf("Wrong prefix: %v", prefix)
	}
	if gatewayReply != nil {
		t.Errorf("Reply is not nil: %v", gatewayReply)
	}
}

func TestMessageToPrefix4(t *testing.T) {
	message := client.Message{
		Id:         23,
		IsOutgoing: true,
	}
	prefix, gatewayReply := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "", "", false)
	if prefix != "> 23" {
		t.Errorf("Wrong prefix: %v", prefix)
	}
	if gatewayReply != nil {
		t.Errorf("Reply is not nil: %v", gatewayReply)
	}
}

func TestMessageToPrefix5(t *testing.T) {
	message := client.Message{
		Id: 560,
		ForwardInfo: &client.MessageForwardInfo{
			Origin: &client.MessageOriginChat{
				AuthorSignature: "zyz",
			},
		},
	}
	prefix, gatewayReply := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "h.jpg", "a.jpg", false)
	if prefix != "< 560 | fwd:  (zyz) | preview: h.jpg | file: a.jpg" {
		t.Errorf("Wrong prefix: %v", prefix)
	}
	if gatewayReply != nil {
		t.Errorf("Reply is not nil: %v", gatewayReply)
	}
}

func TestMessageToPrefix6(t *testing.T) {
	message := client.Message{
		Id:         23,
		ChatId:     25,
		IsOutgoing: true,
		ReplyTo: &client.MessageReplyToMessage{
			ChatId: 41,
			Quote: &client.TextQuote{
				Text: &client.FormattedText{
					Text: "tist\nuz\niz",
				},
			},
			Origin: &client.MessageOriginHiddenUser{
				SenderName: "ziz",
			},
		},
	}
	prefix, gatewayReply := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "", "", false)
	if prefix != "> 23 | reply: ziz @ unknown contact: TDlib instance is offline | tist uz iz" {
		t.Errorf("Wrong prefix: %v", prefix)
	}
	if gatewayReply != nil {
		t.Errorf("Reply is not nil: %v", gatewayReply)
	}
}

func TestMessageToPrefix7(t *testing.T) {
	message := client.Message{
		Id:         23,
		ChatId:     42,
		IsOutgoing: true,
		ReplyTo: &client.MessageReplyToMessage{
			ChatId: 41,
			Content: &client.MessageText{
				Text: &client.FormattedText{
					Text: "tist",
				},
			},
			Origin: &client.MessageOriginChannel{
				AuthorSignature: "zaz",
			},
		},
	}
	prefix, gatewayReply := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "", "", false)
	if prefix != "> 23 | reply:  (zaz) @ unknown contact: TDlib instance is offline | tist" {
		t.Errorf("Wrong prefix: %v", prefix)
	}
	if gatewayReply != nil {
		t.Errorf("Reply is not nil: %v", gatewayReply)
	}
}

func TestMessageToPrefix8(t *testing.T) {
	message := client.Message{
		Id:         23,
		ChatId:     42,
		IsOutgoing: true,
		ReplyTo: &client.MessageReplyToMessage{
			ChatId: 41,
			Content: &client.MessageText{
				Text: &client.FormattedText{
					Text: "tist",
				},
			},
			Origin: &client.MessageOriginChannel{
				AuthorSignature: "zuz",
			},
		},
	}
	prefix, gatewayReply := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "", "", true)
	if prefix != "> 23" {
		t.Errorf("Wrong prefix: %v", prefix)
	}
	if gatewayReply != nil {
		t.Errorf("Reply is not nil: %v", gatewayReply)
	}
}

func GetSenderIdEmpty(t *testing.T) {
	message := client.Message{}
	senderId := (&Client{}).getSenderId(&message)
	if senderId != 0 {
		t.Errorf("Wrong sender id: %v", senderId)
	}
}

func GetSenderIdUser(t *testing.T) {
	message := client.Message{
		SenderId: &client.MessageSenderUser{
			UserId: 42,
		},
	}
	senderId := (&Client{}).getSenderId(&message)
	if senderId != 42 {
		t.Errorf("Wrong sender id: %v", senderId)
	}
}

func GetSenderIdChat(t *testing.T) {
	message := client.Message{
		SenderId: &client.MessageSenderChat{
			ChatId: -42,
		},
	}
	senderId := (&Client{}).getSenderId(&message)
	if senderId != -42 {
		t.Errorf("Wrong sender id: %v", senderId)
	}
}