package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"strconv"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/go-telegram-bot-api/telegram-bot-api"
	"github.com/retailcrm/api-client-go/v5"
	"github.com/retailcrm/mg-transport-api-client-go/v1"
)

func connectHandler(c *gin.Context) {
	res := struct {
		Conn   Connection
		Locale map[string]interface{}
		Year   int
	}{
		c.MustGet("account").(Connection),
		getLocale(),
		time.Now().Year(),
	}

	c.HTML(http.StatusOK, "home", &res)
}

func addBotHandler(c *gin.Context) {
	b := c.MustGet("bot").(Bot)
	cl, err := getBotByToken(b.Token)
	if err != nil {
		c.Error(err)
		return
	}

	if cl.ID != 0 {
		c.AbortWithStatusJSON(BadRequest("bot_already_created"))
		return
	}

	bot, err := tgbotapi.NewBotAPI(b.Token)
	if err != nil {
		c.AbortWithStatusJSON(BadRequest("incorrect_token"))
		logger.Error(b.Token, err.Error())
		return
	}

	bot.Debug = config.Debug

	wr, err := bot.SetWebhook(tgbotapi.NewWebhook("https://" + config.HTTPServer.Host + "/telegram/" + bot.Token))
	if err != nil || !wr.Ok {
		c.AbortWithStatusJSON(BadRequest("error_creating_webhook"))
		logger.Error(b.Token, err.Error(), wr)
		return
	}

	b.Name = bot.Self.FirstName
	conn := getConnectionById(b.ConnectionID)
	client := v1.New(conn.MGURL, conn.MGToken)

	data, status, err := client.ActivateTransportChannel(getChannelSettings())
	if status != http.StatusCreated {
		c.AbortWithStatusJSON(BadRequest("error_activating_channel"))
		logger.Error(conn.APIURL, status, err.Error(), data)
		return
	}

	b.Channel = data.ChannelID

	err = conn.createBot(b)
	if err != nil {
		c.Error(err)
		return
	}

	c.JSON(http.StatusCreated, b)
}

func deleteBotHandler(c *gin.Context) {
	b := c.MustGet("bot").(Bot)
	conn := getConnectionById(b.ConnectionID)
	if conn.MGURL == "" || conn.MGToken == "" {
		c.AbortWithStatusJSON(BadRequest("not_found_account"))
		return
	}

	var client = v1.New(conn.MGURL, conn.MGToken)

	data, status, err := client.DeactivateTransportChannel(getBotChannelByToken(b.Token))
	if status > http.StatusOK {
		c.AbortWithStatusJSON(BadRequest("error_deactivating_channel"))
		logger.Error(b.ID, status, err.Error(), data)
		return
	}

	err = b.deleteBot()
	if err != nil {
		c.Error(err)
		return
	}

	c.JSON(http.StatusOK, gin.H{})
}

func settingsHandler(c *gin.Context) {
	uid := c.Param("uid")

	p := getConnection(uid)
	if p.ID == 0 {
		c.Redirect(http.StatusFound, "/")
		return
	}

	bots := p.getBotsByClientID()

	res := struct {
		Conn     *Connection
		Bots     Bots
		Locale   map[string]interface{}
		Year     int
		LangCode []string
	}{
		p,
		bots,
		getLocale(),
		time.Now().Year(),
		[]string{"en", "ru", "es"},
	}

	c.HTML(http.StatusOK, "form", &res)
}

func saveHandler(c *gin.Context) {
	conn := c.MustGet("connection").(Connection)
	_, err, code := getAPIClient(conn.APIURL, conn.APIKEY)
	if err != nil {
		if code == http.StatusInternalServerError {
			c.Error(err)
		} else {
			c.AbortWithStatusJSON(BadRequest(err.Error()))
		}
		return
	}

	err = conn.saveConnectionByClientID()
	if err != nil {
		c.Error(err)
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": getLocalizedMessage("successful")})
}

func createHandler(c *gin.Context) {
	conn := c.MustGet("connection").(Connection)

	cl := getConnectionByURL(conn.APIURL)
	if cl.ID != 0 {
		c.AbortWithStatusJSON(BadRequest("connection_already_created"))
		return
	}

	client, err, code := getAPIClient(conn.APIURL, conn.APIKEY)
	if err != nil {
		if code == http.StatusInternalServerError {
			c.Error(err)
		} else {
			c.AbortWithStatusJSON(code, gin.H{"error": err.Error()})
		}
		return
	}

	conn.ClientID = GenerateToken()
	data, status, errr := client.IntegrationModuleEdit(getIntegrationModule(conn.ClientID))
	if errr.RuntimeErr != nil {
		c.Error(errr.RuntimeErr)
		return
	}

	if status >= http.StatusBadRequest {
		c.AbortWithStatusJSON(BadRequest("error_activity_mg"))
		logger.Error(conn.APIURL, status, errr.ApiErr, data)
		return
	}

	conn.MGURL = data.Info.MgTransportInfo.EndpointUrl
	conn.MGToken = data.Info.MgTransportInfo.Token
	conn.Active = true

	err = conn.createConnection()
	if err != nil {
		c.Error(err)
		return
	}

	c.JSON(
		http.StatusCreated,
		gin.H{
			"url":     "/settings/" + conn.ClientID,
			"message": getLocalizedMessage("successful"),
		},
	)
}

func activityHandler(c *gin.Context) {
	var (
		activity  v5.Activity
		systemUrl = c.PostForm("systemUrl")
		clientId  = c.PostForm("clientId")
	)

	conn := getConnection(clientId)
	if conn.ID == 0 {
		c.AbortWithStatusJSON(http.StatusBadRequest,
			gin.H{
				"success": false,
				"error":   "Wrong data",
			},
		)
		return
	}

	err := json.Unmarshal([]byte(c.PostForm("activity")), &activity)
	if err != nil {
		c.AbortWithStatusJSON(http.StatusBadRequest,
			gin.H{
				"success": false,
				"error":   "Wrong data",
			},
		)
		return
	}

	conn.Active = activity.Active && !activity.Freeze

	if systemUrl != "" {
		conn.APIURL = systemUrl
	}

	if err := conn.saveConnection(); err != nil {
		c.Error(err)
		return
	}

	c.JSON(http.StatusOK, gin.H{"success": true})
}

func setLangBotHandler(c *gin.Context) {
	b := c.MustGet("bot").(Bot)
	cl, err := getBotByToken(b.Token)
	if err != nil {
		c.Error(err)
		return
	}

	cl.Lang = b.Lang

	err = cl.save()
	if err != nil {
		c.Error(err)
		return
	}

	c.JSON(http.StatusOK, gin.H{})
}

func getIntegrationModule(clientId string) v5.IntegrationModule {
	return v5.IntegrationModule{
		Code:            config.TransportInfo.Code,
		IntegrationCode: config.TransportInfo.Code,
		Active:          true,
		Name:            config.TransportInfo.Name,
		ClientID:        clientId,
		Logo: fmt.Sprintf(
			"https://%s%s",
			config.HTTPServer.Host,
			config.TransportInfo.LogoPath,
		),
		BaseURL: fmt.Sprintf(
			"https://%s",
			config.HTTPServer.Host,
		),
		AccountURL: fmt.Sprintf(
			"https://%s/settings/%s",
			config.HTTPServer.Host,
			clientId,
		),
		Actions: map[string]string{"activity": "/actions/activity"},
		Integrations: &v5.Integrations{
			MgTransport: &v5.MgTransport{
				WebhookUrl: fmt.Sprintf(
					"https://%s/webhook/",
					config.HTTPServer.Host,
				),
			},
		},
	}
}

func getChannelSettings(cid ...uint64) v1.Channel {
	var channelID uint64

	if len(cid) > 0 {
		channelID = cid[0]
	}

	return v1.Channel{
		ID:   channelID,
		Type: Type,
		Settings: v1.ChannelSettings{
			SpamAllowed: false,
			Status: v1.Status{
				Delivered: v1.ChannelFeatureSend,
				Read:      v1.ChannelFeatureNone,
			},
			Text: v1.ChannelSettingsText{
				Creating: v1.ChannelFeatureBoth,
				Editing:  v1.ChannelFeatureBoth,
				Quoting:  v1.ChannelFeatureBoth,
				Deleting: v1.ChannelFeatureReceive,
			},
			Product: v1.Product{
				Creating: v1.ChannelFeatureReceive,
				Editing:  v1.ChannelFeatureReceive,
			},
			Order: v1.Order{
				Creating: v1.ChannelFeatureReceive,
				Editing:  v1.ChannelFeatureReceive,
			},
		},
	}
}

func updateChannelsSettings() {
	hashSettings, err := getChannelSettingsHash()
	if err != nil {
		logger.Error(err.Error())
		return
	}

	connections := getConnections()
	if len(connections) > 0 {
		for _, conn := range connections {
			if !conn.Active {
				logger.Infof(
					"updateChannelsSettings connection %s deactivated",
					conn.APIURL,
				)
				continue
			}
			updateBots(conn, hashSettings)
		}
	}

	return
}

func updateBots(conn *Connection, hashSettings string) {
	bots := conn.getBotsByClientID()
	if len(bots) > 0 {
		client := v1.New(conn.MGURL, conn.MGToken)
		for _, bot := range bots {
			if bot.ChannelSettingsHash == hashSettings {
				continue
			}

			data, status, err := client.UpdateTransportChannel(getChannelSettings(bot.Channel))
			if config.Debug {
				logger.Infof(
					"updateChannelsSettings apiURL: %s, ChannelID: %d, Data: %v, Status: %d, err: %v",
					conn.APIURL, bot.Channel, data, status, err,
				)
			}

			if err == nil {
				bot.ChannelSettingsHash = hashSettings
				err = bot.save()
				if err != nil {
					logger.Error(
						"updateChannelsSettings bot.save apiURL: %s, bot.Channel: %d , err: %v",
						conn.APIURL, bot.Channel, err,
					)
				}
			}

		}
	}

	return
}

func telegramWebhookHandler(c *gin.Context) {
	token := c.Param("token")
	b, err := getBotByToken(token)
	if err != nil {
		c.Error(err)
		return
	}

	if b.ID == 0 {
		c.AbortWithStatus(http.StatusOK)
		return
	}

	conn := getConnectionById(b.ConnectionID)
	if !conn.Active {
		c.AbortWithStatus(http.StatusOK)
		return
	}

	var update tgbotapi.Update
	if err := c.ShouldBindJSON(&update); err != nil {
		c.Error(err)
		return
	}

	if config.Debug {
		logger.Debugf("mgWebhookHandler request: %v", update)
	}

	var client = v1.New(conn.MGURL, conn.MGToken)

	if update.Message != nil {
		if update.Message.Text == "" {
			setLocale(update.Message.From.LanguageCode)
			update.Message.Text = getLocalizedMessage(getMessageID(update.Message))
		}

		nickname := update.Message.From.UserName
		user := getUserByExternalID(update.Message.From.ID)

		if update.Message.From.UserName == "" {
			nickname = update.Message.From.FirstName
		}

		if user.Expired(config.UpdateInterval) || user.ID == 0 {
			fileID, fileURL, err := GetFileIDAndURL(b.Token, update.Message.From.ID)
			if err != nil {
				c.Error(err)
				return
			}

			if fileID != user.UserPhotoID && fileURL != "" {
				picURL, err := UploadUserAvatar(fileURL)
				if err != nil {
					c.Error(err)
					return
				}

				user.UserPhotoID = fileID
				user.UserPhotoURL = picURL
			}

			if user.ExternalID == 0 {
				user.ExternalID = update.Message.From.ID
			}

			err = user.save()
			if err != nil {
				c.Error(err)
				return
			}
		}

		lang := update.Message.From.LanguageCode

		if len(update.Message.From.LanguageCode) > 2 {
			lang = update.Message.From.LanguageCode[:2]
		}

		if config.Debug {
			logger.Debugf("telegramWebhookHandler user %v", user)
		}

		snd := v1.SendData{
			Message: v1.Message{
				ExternalID: strconv.Itoa(update.Message.MessageID),
				Type:       "text",
				Text:       update.Message.Text,
			},
			User: v1.User{
				ExternalID: strconv.Itoa(update.Message.From.ID),
				Nickname:   nickname,
				Firstname:  update.Message.From.FirstName,
				Avatar:     user.UserPhotoURL,
				Lastname:   update.Message.From.LastName,
				Language:   lang,
			},
			Channel:        b.Channel,
			ExternalChatID: strconv.FormatInt(update.Message.Chat.ID, 10),
		}

		if update.Message.ReplyToMessage != nil {
			snd.Quote = &v1.SendMessageRequestQuote{ExternalID: strconv.Itoa(update.Message.ReplyToMessage.MessageID)}
		}

		data, st, err := client.Messages(snd)
		if err != nil {
			logger.Error(b.Token, err.Error(), st, data)
			c.Error(err)
			return
		}

		if config.Debug {
			logger.Debugf("telegramWebhookHandler Type: SendMessage, Bot: %v, Message: %v, Response: %v", b.ID, snd, data)
		}
	}

	if update.EditedMessage != nil {
		if update.EditedMessage.Text == "" {
			setLocale(update.EditedMessage.From.LanguageCode)
			update.EditedMessage.Text = getLocalizedMessage(getMessageID(update.Message))
		}

		snd := v1.UpdateData{
			Message: v1.UpdateMessage{
				Message: v1.Message{
					ExternalID: strconv.Itoa(update.EditedMessage.MessageID),
					Type:       "text",
					Text:       update.EditedMessage.Text,
				},
			},
			Channel: b.Channel,
		}

		data, st, err := client.UpdateMessages(snd)
		if err != nil {
			logger.Error(b.Token, err.Error(), st, data)
			c.Error(err)
			return
		}

		if config.Debug {
			logger.Debugf("telegramWebhookHandler Type: UpdateMessage, Bot: %v, Message: %v, Response: %v", b.ID, snd, data)
		}
	}

	c.JSON(http.StatusOK, gin.H{})
}

func mgWebhookHandler(c *gin.Context) {
	clientID := c.GetHeader("Clientid")
	if clientID == "" {
		c.AbortWithStatus(http.StatusBadRequest)
		return
	}

	conn := getConnection(clientID)
	if !conn.Active {
		c.AbortWithStatus(http.StatusBadRequest)
		return
	}

	var msg v1.WebhookRequest
	if err := c.ShouldBindJSON(&msg); err != nil {
		c.Error(err)
		return
	}

	if config.Debug {
		logger.Debugf("mgWebhookHandler request: %v", msg)
	}

	uid, _ := strconv.Atoi(msg.Data.ExternalMessageID)
	cid, _ := strconv.ParseInt(msg.Data.ExternalChatID, 10, 64)

	b := getBot(conn.ID, msg.Data.ChannelID)
	if b.ID == 0 {
		c.AbortWithStatus(http.StatusBadRequest)
		return
	}

	bot, err := tgbotapi.NewBotAPI(b.Token)
	if err != nil {
		logger.Error(b, err)
		c.AbortWithStatus(http.StatusBadRequest)
		return
	}

	setLocale(b.Lang)

	switch msg.Type {
	case "message_sent":
		var mb string
		switch msg.Data.Type {
		case v1.MsgTypeProduct:
			mb = fmt.Sprintf("%s\n", msg.Data.Product.Name)

			if msg.Data.Product.Cost != nil && msg.Data.Product.Cost.Value != 0 {
				mb += fmt.Sprintf(
					"\n%s: %s\n",
					getLocalizedMessage("item_cost"),
					getLocalizedTemplateMessage(
						"cost_currency",
						map[string]interface{}{
							"Amount":   msg.Data.Product.Cost.Value,
							"Currency": currency[strings.ToLower(msg.Data.Product.Cost.Currency)],
						},
					),
				)
			}

			if msg.Data.Product.Url != "" {
				mb += msg.Data.Product.Url
			} else {
				mb += msg.Data.Product.Img
			}
		case v1.MsgTypeOrder:
			mb = getOrderMessage(msg.Data.Order)
		case v1.MsgTypeText:
			mb = msg.Data.Content
		}

		m := tgbotapi.NewMessage(cid, mb)
		if msg.Data.QuoteExternalID != "" {
			qid, err := strconv.Atoi(msg.Data.QuoteExternalID)
			if err != nil {
				c.Error(err)
				return
			}
			m.ReplyToMessageID = qid
		}

		msgSend, err := bot.Send(m)
		if err != nil {
			logger.Error(err)
			c.AbortWithStatus(http.StatusBadRequest)
			return
		}

		if config.Debug {
			logger.Debugf("mgWebhookHandler sent %v", msgSend)
		}

		c.JSON(http.StatusOK, gin.H{"external_message_id": strconv.Itoa(msgSend.MessageID)})

	case "message_updated":
		msgSend, err := bot.Send(tgbotapi.NewEditMessageText(cid, uid, msg.Data.Content))
		if err != nil {
			logger.Error(err)
			c.AbortWithStatus(http.StatusBadRequest)
			return
		}

		if config.Debug {
			logger.Debugf("mgWebhookHandler update %v", msgSend)
		}

		c.AbortWithStatus(http.StatusOK)

	case "message_deleted":
		msgSend, err := bot.Send(tgbotapi.NewDeleteMessage(cid, uid))
		if err != nil {
			logger.Error(err)
			c.AbortWithStatus(http.StatusBadRequest)
			return
		}

		if config.Debug {
			logger.Debugf("mgWebhookHandler delete %v", msgSend)
		}

		c.JSON(http.StatusOK, gin.H{})

	}
}

func getOrderMessage(dataOrder *v1.MessageDataOrder) string {
	mb := getLocalizedMessage("order")

	if dataOrder.Number != "" {
		mb += " " + dataOrder.Number
	}

	if dataOrder.Date != "" {
		mb += fmt.Sprintf(" (%s)", dataOrder.Date)
	}
	mb += "\n"
	if len(dataOrder.Items) > 0 {
		mb += "\n"
		for k, v := range dataOrder.Items {
			mb += fmt.Sprintf(
				"%d. %s",
				k+1,
				v.Name,
			)

			if v.Quantity != nil {
				if v.Quantity.Value != 0 {
					mb += fmt.Sprintf(
						" %v",
						v.Quantity.Value,
					)
				}
			}

			if v.Price != nil {
				if val, ok := currency[strings.ToLower(v.Price.Currency)]; ok {
					mb += fmt.Sprintf(
						" x %s\n",
						getLocalizedTemplateMessage(
							"cost_currency",
							map[string]interface{}{
								"Amount":   v.Price.Value,
								"Currency": val,
							},
						),
					)
				}
			} else {
				mb += "\n"
			}
		}
	}

	if dataOrder.Delivery != nil {
		if dataOrder.Delivery.Name != "" {
			mb += fmt.Sprintf(
				"\n%s:\n%s",
				getLocalizedMessage("delivery"),
				dataOrder.Delivery.Name,
			)
		}

		if dataOrder.Delivery.Amount != nil {
			if val, ok := currency[strings.ToLower(dataOrder.Delivery.Amount.Currency)]; ok && dataOrder.Delivery.Amount.Value != 0 {
				mb += fmt.Sprintf(
					"; %s",
					getLocalizedTemplateMessage(
						"cost_currency",
						map[string]interface{}{
							"Amount":   dataOrder.Delivery.Amount.Value,
							"Currency": val,
						},
					),
				)
			}
		}

		if dataOrder.Delivery.Address != "" {
			mb += ";\n" + dataOrder.Delivery.Address
		}

		mb += "\n"
	}

	if len(dataOrder.Payments) > 0 {
		mb += fmt.Sprintf(
			"\n%s:\n",
			getLocalizedMessage("payment"),
		)
		for _, v := range dataOrder.Payments {
			mb += v.Name

			if v.Amount != nil {
				if val, ok := currency[strings.ToLower(v.Amount.Currency)]; ok && v.Amount.Value != 0 {
					mb += fmt.Sprintf(
						"; %s",
						getLocalizedTemplateMessage(
							"cost_currency",
							map[string]interface{}{
								"Amount":   v.Amount.Value,
								"Currency": val,
							},
						),
					)
				}
			}

			if v.Status != nil && v.Status.Name != "" {
				mb += fmt.Sprintf(
					" (%s)",
					v.Status.Name,
				)
			}

			mb += "\n"
		}
	}

	if dataOrder.Cost != nil {
		if val, ok := currency[strings.ToLower(dataOrder.Cost.Currency)]; ok && dataOrder.Cost.Value != 0 {
			mb += fmt.Sprintf(
				"\n%s: %s",
				getLocalizedMessage("order_total"),
				getLocalizedTemplateMessage(
					"cost_currency",
					map[string]interface{}{
						"Amount":   dataOrder.Cost.Value,
						"Currency": val,
					},
				),
			)
		}
	}

	return mb
}