package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"git.ddd.rip/ptrcnull/telegram"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"
)

func GetUberData(uuid string) (*UberDataOrder, error) {
	requestBody := []byte(fmt.Sprintf("{\"orderUuid\":\"%s\"}", uuid))
	req, err := http.NewRequest("POST", "https://www.ubereats.com/api/getActiveOrdersV1", bytes.NewBuffer(requestBody))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("x-csrf-token", "x")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}

	if res.StatusCode != 200 {
		body, err := ioutil.ReadAll(res.Body)
		log.Println(string(body), err)
		return nil, fmt.Errorf("unexpected status code: %d", res.StatusCode)
	}

	var data UberResponse
	err = json.NewDecoder(res.Body).Decode(&data)
	if err != nil {
		return nil, err
	}

	for _, order := range data.Data.Orders {
		if order.UUID == uuid {
			return &order, nil
		}
	}

	return nil, fmt.Errorf("order not found: %s", uuid)
}

type Order struct {
	ChatID   string
	UberData *UberDataOrder
	MessageID string
}

func main() {
	c := telegram.Client{
		Token: os.Getenv("TELEGRAM_TOKEN"),
	}
	sendMessage := func(chatId, body string) *telegram.SendMessageResponse {
		res, err := c.SendMessage(chatId, body)
		if err != nil {
			log.Println("error sending message:", err)
			return nil
		}
		return res
	}
	var orders []*Order
	go func() {
		for {
			time.Sleep(1 * time.Second)
			for i, order := range orders {
				log.Println("Getting data for order", order.UberData.UUID)
				newData, err := GetUberData(order.UberData.UUID)
				if err != nil {
					log.Println(err)
					sendMessage(order.ChatID, "order completed: "+order.UberData.UUID)
					orders = append(orders[:i], orders[i+1:]...)
					continue
				}
				oldStatus := order.UberData.Status()
				newStatus := newData.Status()
				if oldStatus != newStatus {
					_, err := c.EditMessageText(order.ChatID, order.MessageID, newStatus)
					if err != nil {
						log.Println(err)
					}
				}
				order.UberData = newData
			}
		}
	}()
	for {
		time.Sleep(5 * time.Second)

		log.Println("Getting updates...")
		upd, err := c.GetUpdates()
		if err != nil {
			log.Println(err)
			continue
		}

		log.Println("updates:", len(upd.Result))
		for _, update := range upd.Result {
			if update.Message != nil && strings.HasPrefix(update.Message.Text, "/add") {
				chatId := strconv.FormatInt(update.Message.Chat.ID, 10)

				orderId := strings.Split(update.Message.Text, " ")[1]
				data, err := GetUberData(orderId)
				if err != nil {
					log.Println(err)
					sendMessage(chatId, "error: "+err.Error())
					continue
				}
				log.Printf("%#v\n", data)
				sendMessage(chatId, "added new order: "+data.OrderInfo.StoreInfo.Name)
				status := data.Status()
				res := sendMessage(chatId, status)
				if res != nil {
					orders = append(orders, &Order{
						ChatID:    chatId,
						UberData:  data,
						MessageID: strconv.FormatInt(res.Result.MessageID, 10),
					})
				}
			}
			if update.Message != nil && strings.HasPrefix(update.Message.Text, "/contact") {
				chatId := strconv.FormatInt(update.Message.Chat.ID, 10)

				orderId := strings.Split(update.Message.Text, " ")[1]
				data, err := GetUberData(orderId)
				if err != nil {
					log.Println(err)
					sendMessage(chatId, "error: "+err.Error())
					continue
				}
				for _, contact := range data.Contacts {
					sendMessage(chatId, contact.Title + ": " + contact.FormattedPhoneNumber)
				}
			}
		}
	}
}