package main

import (
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"log"
	"net"
	"net/http"
	"net/url"
	"strconv"

	"github.com/hamcha/clessy/tg"
)

// APIEndpoint is Telegram's current Bot API base url endpoint
const APIEndpoint = "https://api.telegram.org/"

// Telegram is the API client for the Telegram Bot API
type Telegram struct {
	Token string
}

// mkAPI creates a Telegram instance from a Bot API token
func mkAPI(token string) *Telegram {
	tg := new(Telegram)
	tg.Token = token
	return tg
}

// SetWebhook sets the webhook address so that Telegram knows where to send updates
func (t Telegram) SetWebhook(webhook string) {
	resp, err := http.PostForm(t.apiURL("setWebhook"), url.Values{"url": {webhook}})
	if !checkerr("SetWebhook", err) {
		defer resp.Body.Close()
		var result tg.APIResponse
		err = json.NewDecoder(resp.Body).Decode(&result)
		if err != nil {
			log.Println("[SetWebhook] Could not read reply: " + err.Error())
			return
		}
		if result.Ok {
			log.Println("Webhook successfully set!")
		} else {
			log.Printf("[SetWebhook] Error setting webhook (errcode %d): %s\n", *(result.ErrCode), *(result.Description))
			panic(errors.New("Cannot set webhook"))
		}
	}
}

// SendTextMessage sends an HTML-styled text message to a specified chat
func (t Telegram) SendTextMessage(data tg.ClientTextMessageData) {
	postdata := url.Values{
		"chat_id":    {strconv.Itoa(data.ChatID)},
		"text":       {data.Text},
		"parse_mode": {"HTML"},
	}
	if data.ReplyID != nil {
		postdata["reply_to_message_id"] = []string{strconv.Itoa(*(data.ReplyID))}
	}

	_, err := http.PostForm(t.apiURL("sendMessage"), postdata)
	checkerr("SendTextMessage", err)
}

// GetFile sends a "getFile" API call to Telegram's servers and fetches the file
// specified afterward. The file will be then send back to the client that requested it
// with the specified callback id.
func (t Telegram) GetFile(data tg.FileRequestData, client net.Conn, callback int) {
	fail := func(msg string) {
		errmsg, _ := json.Marshal(tg.BrokerUpdate{
			Type:     tg.BError,
			Error:    &msg,
			Callback: &callback,
		})
		fmt.Fprintln(client, string(errmsg))
	}

	postdata := url.Values{
		"file_id": {data.FileID},
	}
	resp, err := http.PostForm(t.apiURL("getFile"), postdata)
	if checkerr("GetFile/post", err) {
		fail("Server didn't like my request")
		return
	}
	defer resp.Body.Close()

	var filespecs tg.APIFile
	err = json.NewDecoder(resp.Body).Decode(&filespecs)
	if checkerr("GetFile/json.Decode", err) {
		fail("Server sent garbage (or error)")
		return
	}

	path := "https://api.telegram.org/file/bot" + t.Token + "/" + *filespecs.Path
	fileresp, err := http.Get(path)
	if checkerr("GetFile/get", err) {
		fail("Could not retrieve file from Telegram's servers")
		return
	}
	defer fileresp.Body.Close()

	rawdata, err := ioutil.ReadAll(fileresp.Body)
	if checkerr("GetFile/ioutil.ReadAll", err) {
		fail("Could not read file data")
		return
	}

	rawlen := len(rawdata)
	if rawlen != *filespecs.Size {
		// ???
		log.Printf("[GetFile] WARN ?? Downloaded file does not match provided filesize: %d != %d\n", rawlen, *filespecs.Size)
	}
	b64data := base64.StdEncoding.EncodeToString(rawdata)

	clientmsg, err := json.Marshal(tg.BrokerUpdate{
		Type:     tg.BFile,
		Bytes:    &b64data,
		Callback: &callback,
	})
	if checkerr("GetFile/json.Marshal", err) {
		fail("Could not serialize reply JSON")
		return
	}

	fmt.Fprintln(client, string(clientmsg))
}

func (t Telegram) apiURL(method string) string {
	return APIEndpoint + "bot" + t.Token + "/" + method
}

func checkerr(method string, err error) bool {
	if err != nil {
		log.Printf("[%s] Error: %s\n", method, err.Error())
		return true
	}
	return false
}