package main

import (
    "net/http"
    "net/url"
    "io/ioutil"
    "fmt"
    "encoding/json"
    "log"
    "strconv"
    "io"
    "bytes"
    "mime/multipart"
    "time"
    "math/rand"
)

const (
    accessToken = "11s9bd8ad4f07a3df320cf21d589bbf09aeacd7d372d30f0443603b3db189a0a8520552cc1a679010779"
    groupId = "135209264"
    apiV = "5.80"
    maxAttempt = 10
    maxLength = 500
)

type (
    LongPoll struct {
        Response struct {
            Key    string `json:"key"`
            Server string `json:"server"`
            Ts     int64 `json:"ts"`
        }
    }

    Event struct {
        Ts string `json:"ts"`
        Updates []Update `json:"updates"`
    }

    Update struct {
        Type string `json:"type"`
        Object Message `json:"object"`
        GroupId int64 `json:"group_id"`
    }

    Message struct {
        Date int64 `json:"date"`
        Out int8 `json:"out"`
        UserId int64 `json:"user_id"`
        Body string `json:"body"`
        Attachments *[]Attachment `json:"attachments"`
        Emoji *int `json:"emoji"`
    }

    Attachment struct {
        Type string `json:"type"`
        Doc *Doc `json:"doc"`
    }

    Doc struct {
        Id int64 `json:"id"`
        OwnerId int64 `json:"owner_id"`
        Title string `json:"title"`
        Size int64 `json:"size"`
        Ext string `json:"ext"`
        Url string `json:"url"`
        Date int64 `json:"date"`
        Type int `json:"type"`
    }

    SendMessage struct {
        Response int `json:"response"`
    }

    /* Uploads */
    UploadURL struct {
        Response struct {
            UploadUrl string `json:"upload_url"`
        }
    }

    DocUploaded struct {
        File string `json:"file"`
    }
)

func main() {
    rand.Seed(time.Now().Unix())
    startLongPoll()
}

/* Long Poll */
func startLongPoll() {
    longPollParams := getLongPollServer()
    log.Print("get long poll server")
    for {
        serverURL := fmt.Sprintf("%s?act=a_check&key=%s&ts=%d&wait=25", longPollParams.Response.Server, longPollParams.Response.Key, longPollParams.Response.Ts)
        resp, err := http.Get(serverURL)
        if err != nil {
            log.Print("error connect to longPoll server")
            break
        }
        bodyBuf, err := ioutil.ReadAll(resp.Body)
        if err != nil {
            log.Print("error read from longPoll server")
            break
        }
        event:= Event{}
        // log.Print(string(bodyBuf))
        if err := json.Unmarshal(bodyBuf, &event); err != nil {
            fmt.Print("error parse json from longPoll server: " + string(bodyBuf))
            break
        }
        longPollParams.Response.Ts, _ = strconv.ParseInt(event.Ts, 0, 64)
        go processEvent(event)
        // break
    }
    startLongPoll()
}

func processEvent(event Event)  {
    // log.Print(len(event.Updates))
    for i := range event.Updates {
        update:= event.Updates[i]
        switch update.Type {
            case "message_new":
                TextLength := len([]rune(update.Object.Body))
                if TextLength > maxLength {
                    sendMessage(update.Object.UserId, fmt.Sprintf("new code: В одном сообщении можно озвучить только %d символов. У тебя %s", maxLength, declOfNum(TextLength, [3]string{
                        "символ",
                        "символа",
                        "символов",
                    })))
                } else {
                    go typing(update.Object.UserId)
                    go processMessage(update.Object)
                }
                break
        }
    }
}

func processMessage(message Message)  {
    /* if message.UserId == 383520740 {
        log.Print(message)
    } */
    sendVoice(message.UserId, message.Body, 0)
}

func getLongPollServer() LongPoll {
    data := url.Values{}
    data.Add("group_id", groupId)
    longPoll:= LongPoll{}
    if err := json.Unmarshal(_api("groups.getLongPollServer", data), &longPoll); err != nil {
        log.Fatal("unmarshal response json failed:", err)
    }
    return longPoll
}


/* VK API */
func _api(method string, data url.Values) []byte {
    data.Add("user_ids", "1")
    data.Add("v", apiV)
    data.Add("access_token", accessToken)
    resp, err := http.PostForm("https://api.vk.com/method/" + method, data)
    if err != nil {
        return nil
    }
    defer resp.Body.Close()
    bodyBuf, err := ioutil.ReadAll(resp.Body)
    return bodyBuf
}

func typing(PeerID int64) {
    data := url.Values{}
    data.Add("peer_id", toString(PeerID))
    data.Add("type", "typing")
    _api("messages.setActivity", data)
}

func sendMessage(UserID int64, Text string) {
    data := url.Values{}
    data.Add("peer_id", toString(UserID))
    data.Add("message", Text)
    _api("messages.send", data)
}

func sendVoice(peerID int64, Text string, attempt int) bool {
    attempt++
    if attempt > maxAttempt {
        sendMessage(peerID, "Не получилось озвучить :(")
        return false
    }
    data := url.Values{}
    data.Add("peer_id", toString(peerID))
    data.Add("type", "audio_message")
    uploadURL:= UploadURL{}
    if err := json.Unmarshal(_api("docs.getMessagesUploadServer", data), &uploadURL); err != nil {
        return sendVoice(peerID, Text, attempt)
    }
    if uploadURL.Response.UploadUrl == "" {
        return sendVoice(peerID, Text, attempt)
    }
    bodyBuf := &bytes.Buffer{}
    bodyWriter := multipart.NewWriter(bodyBuf)
    fileWriter, err := bodyWriter.CreateFormFile("file", "bot_maxim.mp3")
    if err != nil {
        log.Print("SendVoice #1", err)
        return sendVoice(peerID, Text, attempt)
    }
    data = url.Values{}
    data.Add("text", Text)
    data.Add("voice", "max")
    resp, err := http.PostForm(getVoiceServer(), data)
    if err != nil {
        log.Print("SendVoice #2", err)
        return sendVoice(peerID, Text, attempt)
    }
    defer resp.Body.Close()
    _, err = io.Copy(fileWriter, resp.Body)
    if err != nil {
        log.Print("SendVoice #3", err)
        return sendVoice(peerID, Text, attempt)
    }
    contentType := bodyWriter.FormDataContentType()
    bodyWriter.Close()
    resp, err = http.Post(uploadURL.Response.UploadUrl, contentType, bodyBuf)
    if err != nil {
        log.Print("SendVoice #4", err)
        return sendVoice(peerID, Text, attempt)
    }
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Print("SendVoice #5", err)
        return sendVoice(peerID, Text, attempt)
    }
    uploaded := DocUploaded{}
    err = json.Unmarshal(body, &uploaded)
    if err != nil || uploaded.File == "" {
        return sendVoice(peerID, Text, attempt)
    }
    data = url.Values{}
    data.Add("peer_id", toString(peerID))
    data.Add("file", uploaded.File)
    data.Add("code", "" +
        "var peer_id = Args.peer_id;" +
        "var doc = API.docs.save({file: Args.file, title: \"bot_maxim.mp3\", tags: \"bot_maxim\"})[0];" +
        "if (parseInt(doc.owner_id) == 0) {" +
        "   return -1;" +
        "}" +
        "var isMember = API.groups.isMember({group_id: 135209264, user_id: peer_id});" +
        "var message_text = \"\";" +
        "var last_send_id = -1;" +
        "if (isMember == 0) {" +
        "   message_text = \"Нравится? 👉 [club135209264|Подпишись!] 💙 И расскажи друзьям 👌\";" +
        "}" +
        "last_send_id = API.messages.send({peer_id: peer_id, message: message_text, attachment: \"doc\" + doc.owner_id + \"_\" + doc.id});" +
        "if (isMember == 0) {" +
        "   last_send_id = API.messages.send({peer_id: peer_id, message: \"vk.com/bot_maxim\"});" +
        "}" +
        "return last_send_id;")
    sendMessage := SendMessage{}
    executeAPI := _api("execute", data)
    if err := json.Unmarshal(executeAPI, &sendMessage); err != nil {
        log.Print("SendVoice #7", err)
        return sendVoice(peerID, Text, attempt)
    }
    if sendMessage.Response != 0 {
        return sendVoice(peerID, Text, attempt)
    }
    return true
}

func declOfNum(number int, titles [3]string) string {
    cases := [6]int{2, 0, 1, 1, 1, 2}
    index := 0
    if number % 100 > 4 && number % 100 < 20 {
        index = 2
    } else if number % 10 < 5 {
        index = cases[number % 10]
    } else {
        index = cases[5]
    }
    return fmt.Sprintf("%d %s", number, titles[index])
}

func getVoiceServer() string {
    // n := rand.Int() % len(voiceServers)
    return "http://localhost/voice" // fmt.Sprintf("http://%s/voice", voiceServers[n])
}

func toString(value int64) string {
    return fmt.Sprintf("%v", value)
}