package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "net/url"
    "strings"
    "time"

    client "github.com/influxdata/influxdb1-client/v2"
)

const (
    database = "test"
    username = "admin"
    password = "wombats"
)

var clusters = []string{"public", "private"}

type AlphaSession struct {
    sessionID *http.Cookie
    gAuth     *http.Cookie
    Expiry    *http.Cookie
}

type RTStats struct {
    Status bool       `json:"IsSucceed"`
    Data   RTStatData `json:"data"`
}

type RTStatData struct {
    Id            string  `json:"Id"`
    StateOfCharge float32 `json:"Soc"`
    BatteryDraw   float32 `json:"Pbat"`
    LoadDraw      float32 `json:"Sva"`
    GridDraw      float32 `json:"Ppv1"`
    PanelDraw     float32 `json:"PmeterL1"`
}

func main() {
    c := influxDBClient()

    stats := new(RTStats)
    s := new(AlphaSession)

    go s.apiPoller(c, stats)

    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)

}

func influxDBClient() client.Client {
    c, err := client.NewHTTPClient(client.HTTPConfig{
        Addr:     "http://149.28.176.130:8086",
        Username: username,
        Password: password,
    })
    if err != nil {
        log.Fatalln("Error: ", err)
    }
    return c
}

func (s *AlphaSession) getAuthToken() error {
    client := &http.Client{
        CheckRedirect: func(req *http.Request, via []*http.Request) error {
            return http.ErrUseLastResponse
        }}

    form := url.Values{"Username": {"garry_turner@me.com"}, "Userpwd": {""}}
    req, err := http.NewRequest("POST", "http://www.alphaess.com", strings.NewReader(form.Encode()))
    if err != nil {
        return err
    }
    req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

    resp, err := client.Do(req)
    defer resp.Body.Close()

    // //debugging
    // //fmt.Println(resp.Body)
    // bodyBytes, _ := ioutil.ReadAll(resp.Body)
    // bodyString := string(bodyBytes)
    // fmt.Println(bodyString)

    for _, cookie := range resp.Cookies() {
        switch cookie.Name {
        case "alphacloudsessionid":
            s.sessionID = cookie
            fmt.Println(cookie.String())
        case "alphacloudgauth":
            s.gAuth = cookie
            fmt.Println(cookie.String())
        case "CURRENT_LANGUAGE_SESSION_KEY":
            s.Expiry = cookie
            fmt.Println(cookie.String())
        }
    }

    return err
}

func (s *AlphaSession) getRTStats(target interface{}) error {

    log.Println("Calling RT stats API")

    client := &http.Client{}
    form := url.Values{"SN": {"AL4001019010306"}, "amplifyGain": {"1"}}
    req, err := http.NewRequest("POST", "https://www.alphaess.com/Monitoring/VtColdata/GetSecondDataBySn", strings.NewReader(form.Encode()))
    if err != nil {
        return err
    }
    req.PostForm = form

    asp := new(http.Cookie)
    asp.Raw = "ASP.NET_SessionId=; path=/; domain=.www.alphaess.com;"

    req.AddCookie(s.gAuth)
    req.AddCookie(s.sessionID)
    req.AddCookie(asp)
    req.Header.Add("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")
    req.Header.Add("X-Requested-With", "XMLHttpRequest")

    resp, err := client.Do(req)
    defer resp.Body.Close()
    //debugging

    // bodyBytes, _ := ioutil.ReadAll(resp.Body)
    // bodyString := string(bodyBytes)
    // fmt.Println(bodyString)
    // fmt.Println()

    return json.NewDecoder(resp.Body).Decode(target)

}

func (s *AlphaSession) checkSession() (status bool) {
    t := time.Now()
    if s.Expiry == nil {
        return true
    }
    return s.Expiry.Expires.Before(t)
}

func (s *AlphaSession) apiPoller(client client.Client, stats *RTStats) error {
    for {
        time.Sleep(2 * time.Second)
        if s.checkSession() {
            log.Println("Session not valid, creating new session")
            s.getAuthToken()
        }
        go s.getRTStats(stats)
        go createMetrics(client, stats)
        fmt.Printf("Battery power draw: %f watts\n", stats.Data.BatteryDraw)

    }
}

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])
}

func createMetrics(c client.Client, s *RTStats) {
    bp, err := client.NewBatchPoints(client.BatchPointsConfig{
        Database:  database,
        Precision: "s",
    })

    if err != nil {
        log.Fatalln("Error: ", err)
    }

    eventTime := time.Now().Add(time.Second * -20)

    tags := map[string]string{}

    fields := map[string]interface{}{
        "StateOfCharge": s.Data.StateOfCharge,
        "BatteryDraw":   s.Data.BatteryDraw,
        "LoadDraw":      s.Data.LoadDraw,
        "GridDraw":      s.Data.GridDraw,
        "PanelDraw":     s.Data.PanelDraw,
    }

    point, err := client.NewPoint(
        "batt_stat",
        tags,
        fields,
        eventTime.Add(time.Second*10),
    )
    if err != nil {
        log.Fatalln("Error: ", err)
    }

    bp.AddPoint(point)

    err = c.Write(bp)
    if err != nil {
        log.Fatal(err)
    }
}