package main

import (
    "bytes"
    "database/sql"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "os"
    "path/filepath"
    "strings"

    _ "github.com/go-sql-driver/mysql"
    "github.com/gorilla/mux"
    "github.com/ivahaev/amigo"
    "github.com/tidwall/gjson"
)

//Config настройки
type Config struct {
    Database struct {
        User string `json:"user"`
        Pass string `json:"pass"`
        Host string `json:"host"`
        Name string `json:"name"`
    } `json:"database"`
    Manager struct {
        User string `json:"user"`
        Pass string `json:"pass"`
        Host string `json:"host"`
    } `json:"manager"`
    Bot struct {
        Art  string `json:"bot"`
        Auth string `json:"auth"`
        Url  string `json:"url"`
    } `json:"bot"`
}

var (
    db     *sql.DB
    config Config
    a      *amigo.Amigo
)

func art(w http.ResponseWriter, r *http.Request) {

    if match := r.Header.Get("Authorization"); match != "" {
        if strings.Contains(match, ""); match == "W7Vw}7Rj}_er]nSCvM" {

            body, err := ioutil.ReadAll(r.Body)
            CheckErr(err, "Ошибка боди")
            var cont, n string
            //----распарс json из dialogflow
            ra := gjson.GetBytes(body, "result.action")
            action := ra.String()

            rs := gjson.GetBytes(body, "result.fulfillment.speech")
            speech := rs.String()

            ss := gjson.GetBytes(body, "sessionId")
            session := ss.String()

            r := gjson.GetBytes(body, "result.fulfillment.messages.1.payload.redirect")
            redirect := r.String()

            //----распарс json из dialogflow

            log.Printf("Action %v\n", action)

            switch action {
            case "get_data":
                {
                    //log.Printf("Start%v\n",action)
                    tel := phone(session)
                    //tel := "79789998899"
                    status, err, b := JSON(action, tel, "")
                    log.Printf("Ошибка от JSON %v\n",err)


                    if status != "ok" {
                        speak("Назовите ваш номер договора состоящий из пяти цифр. говорите по одной цифре", w)
                        long(session)

                    } else {
                        u := gjson.GetBytes(b, "response.street")
                        street := u.String()

                        h := gjson.GetBytes(b, "response.house")
                        home := h.String()

                        k := gjson.GetBytes(b, "response.flat")
                        flat := k.String()

                        c := gjson.GetBytes(b, "response.id")
                        cont = c.String()

                        if flat != "" {
                            speak(speech+` `+street+` дом `+home+`. квартира `+flat+`. Скажите, адрес вашего подключения правильный или нет?`, w)

                        } else {
                            speak(speech+` `+street+` дом `+home+`. Скажите адрес вашего подключения правильный или нет?`, w)
                        }
                    }

                }
            case "contract":
                {
                    //Распарсиваем номер договора и переводим из массива в строку
                    r := gjson.GetBytes(body, `result.contexts.#[name="contract"].parameters.number1`)
                    var stringList []string
                    for _, name := range r.Array() {
                        stringList = append(stringList,name.String())
                    }
                    n = strings.Join(stringList,"")
                    log.Printf("Тип %T переменная %v",n,n)
                    //--------------------------------------------------------------
                    if len(n) != 5 {
                        speak("Вы назвали не правильное количество цифр, повторите 5 цифр вашего договора", w)
                        long(session)
                    }else{
                        speak(speech,w)
                    }
                }
            case "yes":{
                speak(speech,w)
                log.Printf("Тип %T переменная %v",n,n)
                cont = n
            }

            case "activate":
                {
                    tel := phone(session)
                    status, err, _ := JSON(action, tel, cont)

                    log.Printf("Статус %v\n, Ошибка %v\n", status, err)
                    //Три попытки подключения услуги
                    if status != "ok" {
                        for i := 1; i < 4; i++ {
                            log.Printf("Попытка номер %v\n", i)
                            status, _, _ := JSON(action, tel, cont)
                            if status == "ok" {
                                speak(speech, w)
                                hangup(session)
                                break
                            }
                        }
                        //Три попытки подключения услуги
                        redir(session, redirect, "Подключение услуги в данный момент не возможно. Соединяю вас с оператором ", w)
                    } else {
                        speak(speech, w)
                        hangup(session)
                    }

                }
            case "no":
                {
                    var count int

                    res, err := db.Exec(`Update ziax set fallback_attempts = fallback_attempts + 1 where id_chat = ?`, session)
                    CheckErr(err, "Ошибка записи в базу(Update)")

                    affect, err := res.RowsAffected()
                    CheckErr(err, "Ошибка RowsAffected")
                    fmt.Printf("RowsAffected %v\n", affect)

                    err = db.QueryRow(`select fallback_attempts from ziax where id_chat=?`, session).Scan(&count)

                    switch {
                    case err == sql.ErrNoRows:
                        log.Printf("No channel with that ID.")
                    case err != nil:
                        log.Printf("Error of QueryRow for count %v\n", err)
                    default:
                        log.Printf("count is %v\n", count)
                        log.Printf("count is %s\n", speech)
                    }
                    if count < 2 {
                        speak(speech, w)
                        long(session)

                    } else {
                        redir(session, redirect, "Извините я не понимаю Вас. Соединяю с оператором", w)
                    }
                }


            case "hangup":
                {
                    speak(speech, w)
                    hangup(session)

                }
            case "redirect":
                {
                    redir(session, redirect, speech, w)
                }

            case "input.unknown":
                {
                    var count int

                    res, err := db.Exec(`Update ziax set fallback_attempts = fallback_attempts + 1 where id_chat = ?`, session)
                    CheckErr(err, "Ошибка записи в базу(Update)")

                    affect, err := res.RowsAffected()
                    CheckErr(err, "Ошибка RowsAffected")
                    fmt.Printf("RowsAffected %v\n", affect)

                    err = db.QueryRow("select fallback_attempts from ziax where id_chat=?", session).Scan(&count)

                    switch {
                    case err == sql.ErrNoRows:
                        log.Printf("No channel with that ID.")
                    case err != nil:
                        log.Printf("Error of QueryRow for count %v\n", err)
                    default:
                        log.Printf("count is %v\n", count)
                        log.Printf("count is %s\n", speech)
                    }

                    if count < 2 {
                        speak(speech, w)

                    } else {
                        redir(session, redirect, "Извините я не понимаю Вас. Соединяю с оператором", w)
                    }
                }
            }
        } else {
            log.Printf("Не верный ключ")
            w.WriteHeader(http.StatusUnauthorized)
        }
    }
}
func long(session string)  {
    channel := channels(session)
    _, err := a.Action(map[string]string{"Action": "Setvar", "Channel": channel, "Variable": "answer", "Value": "long"})
    CheckErr(err, "Ошибка отправки данных в канала")
}
func speak(speech string, w http.ResponseWriter) {
    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, `{"speech":"`+speech+`","data":"","source":"","contextOut":[]}`)
}

func redir(session, redirect, speech string, w http.ResponseWriter) {
    channel := channels(session)
    speak(speech, w)
    _, err := a.Action(map[string]string{"Action": "Setvar", "Channel": channel, "Variable": "redirect", "Value": redirect})
    CheckErr(err, "Ошибка отправки данных в канал (redirect)")
}
func hangup(session string) {
    channel := channels(session)
    _, err := a.Action(map[string]string{"Action": "Setvar", "Channel": channel, "Variable": "hangup", "Value": "yes"})
    CheckErr(err, "Ошибка отправки данных в канала")
}

func channels(session string) (channel string) {

    err := db.QueryRow(`select channel from ziax where id_chat=?`, session).Scan(&channel)
    switch {
    case err == sql.ErrNoRows:
        log.Printf("No channel with that ID.")
    case err != nil:
        log.Printf("%v\n", err)
    default:
        log.Printf("channels is %s\n", channel)
    }
    return channel
}

func phone(ses string) (tel string) {
    err := db.QueryRow(`select tel from ziax where id_chat=?`, ses).Scan(&tel)
    switch {
    case err == sql.ErrNoRows:
        log.Printf("No tel with that ID.")
    case err != nil:
        log.Printf("%v\n", err)
    default:
        log.Printf("tel is %s\n", tel)
    }
    return tel
}

// JSON для отправки eventbus
func JSON(cmd, phone, contract string) (string, string, []byte) {

    vid := map[string]interface{}{
        "auth": config.Bot.Auth,
        "cmd":  cmd,
        "params": map[string]string{
            "phone":    phone,
            "contract": contract,
        },
    }
    log.Printf("VID %s\n", vid)
    vidEvent, err := json.Marshal(vid)
    if err != nil {
        log.Printf("JSON не отправлен %v\n", err)
        return "", "", nil
    }
    body := httpPOST(vidEvent)

    log.Printf("%s\n", vidEvent)

    st := gjson.GetBytes(body, "status")
    no := gjson.GetBytes(body, "errno")

    return st.String(), no.String(), body

}

func httpPOST(data []byte) []byte {
    req, err := http.NewRequest("POST", config.Bot.Url, bytes.NewBuffer(data))
    req.Header.Set("Content-Type", "application/json")
    if err != nil {
        log.Printf("Ошибка Header%v\n", err)
    }
    client := &http.Client{}
    res, err := client.Do(req)
    if err != nil {
        log.Printf("Ошибка Do%v\n", err)
        return nil
    }
    defer func() {
        if err = res.Body.Close(); err != nil {
            log.Printf("defer error%v\n", err)
        }
    }()
    //Забираем ответ
    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
        log.Printf("Error httpPost answer:%v\n", err)
        return nil
    }
    return body
}

//Conf Загружаем файл с настройками
func Conf() {
    configFile, err := ioutil.ReadFile("/var/www/html/ziaxlk/config/config.json")
    if err != nil {
        log.Printf("Конфиг не найден")
        panic(err)
    }
    err = json.Unmarshal(configFile, &config)
    CheckErr(err, "Ошибка JSON(9)")

}
func CheckErr(err error, s string) {
    if err != nil {
        log.Printf(s+":%v\n", err)
    }
}
func main() {

    Conf()
    pwd, err := filepath.Abs(filepath.Dir(os.Args[0]))
    if err != nil {
        panic(err)
    }
    //Настройки записи логов
    f, err := os.OpenFile(pwd+"/art.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0600)
    CheckErr(err, "error opening file")
    defer func() {
        if err = f.Close(); err != nil {
            log.Printf("defer error%v\n", err)
        }
    }()

    log.SetOutput(f)

    //Подключаемя к AMI
    settings := &amigo.Settings{Username: config.Manager.User, Password: config.Manager.Pass, Host: config.Manager.Host}
    a = amigo.New(settings)
    a.Connect()
    // Listen for connection events
    a.On("connect", func(message string) {
        log.Printf("Connected %v\n", message)
    })
    a.On("error", func(message string) {
        println("Connection error: %v\n", message)
    })
    log.Printf("into!")
    //Подключение к DB
    db, err = sql.Open("mysql", config.Database.User+":"+config.Database.Pass+"@tcp("+config.Database.Host+")/"+config.Database.Name)
    if err != nil {
        log.Printf("Ошибка подключения к DB %v\n", err)
        panic(err)
    }
    defer func() {
        if err = db.Close(); err != nil {
            panic(err)
        }
    }()

    r := mux.NewRouter()
    r.HandleFunc("/", art)
    err = http.ListenAndServe(":"+config.Bot.Art, r)
    CheckErr(err, "Ошибка подключения к порту")
}