package main

import (
    "bufio"
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net"
    "net/http"
    "runtime"
    "sort"
    "strconv"
    "strings"
    "sync"
    "time"
)

const (
    Conn_timeout    time.Duration = time.Second * 3
    Default_timeout time.Duration 
 
= time.Second * 3
)

type Connection struct {
    conn   net.Conn
    lock   *sync.RWMutex
    Reader *bufio.Reader
    Writer *bufio.Writer
}

func NewConn(address string) (*Connection, error) {
    _, err := net.ResolveTCPAddr("tcp", address)
    if err != nil {
        return nil, err
    }

    conn, err :
 
= net.DialTimeout("tcp", address, Conn_timeout)
    if err != nil {
        return nil, err
    }

    return &Connection{
        conn:   conn,
        lock:   new(sync.RWMutex),
        Reader: bufio.NewReader(conn),
        Writer: bufio.NewWriter(conn),
    }, nil
}

func (conn *Connection) Send(data []byte
 
) error {
    //conn.lock.Lock()
    conn.conn.SetWriteDeadline(time.Now().Add(Default_timeout))
    _, err := conn.Writer.Write(data)
    if err != nil {
        //conn.lock.Unlock()
        return err
    }

    err = conn.Writer.Flush()

    //conn.lock.Unlock()
    return err
}

func (conn *Connection) Close() error {
    //conn.lock.Lock()
    //defer conn.lock.Unlock()
    return conn.conn.Close()
}

type TsdbItem struct {
    Metric    string            `json:"metric"`
    Tags      map[string]string `json:"tags"`
    Value     float64           `json:"value"`
    Timestamp int64             `json:"timestamp"`
}

func (this *TsdbItem) String() string {
    return fmt.Sprintf(
        "<Metric:%s, Tags:%v, Value:%v, TS:%d>",
        this.Metric,
        this.Tags,
        this.Value,
        this.Timestamp,
    )
}

func (this *TsdbItem) TsdbString() (s string) {
    s = fmt.Sprintf("put %s %d %.3f ", this.Metric, this.Timestamp, this.Value)

    for k, v := range this.Tags {
        key := strings.ToLower(strings.Replace(k, " ", "_", -1))
        value := strings.Replace(v, " ", "_", -1)
        s += key + "=" + value + " "
    }

    return s
}

type MetaData struct {
    Metric      string            `json:"metric"`
    Endpoint    string            `json:"endpoint"`
    Timestamp   int64             `json:"timestamp"`
    Step        int64             `json:"step"`
    Value       float64           `json:"value"`
    CounterType string            `json:"counterType"`
    Tags        map[string]string `json:"tags"`
}

func convert2TsdbItem(d *MetaData) *TsdbItem {
    t := TsdbItem{Tags: make(map[string]string)}

    for k, v := range d.Tags {
        t.Tags[k] = v
    }
    t.Tags["endpoint"] = d.Endpoint
    t.Metric = d.Metric
    t.Timestamp = d.Timestamp
    t.Value = d.Value
    return &t
}

func NewMetaData() *MetaData {
    return &MetaData{
        Metric:      "tsdb.status",
        Endpoint:    "opentsdb",
        Tags:        make(map[string]string),
        Step:        60,
        Value:       10,
        Timestamp:   time.Now().Unix(),
        CounterType: "GUAGE",
    }
}

func init() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
}

//put data  to opentsdb
func PutDataToTsdb() {
    c, err := NewConn("10.100.101.70:4242")
    if err != nil {
        log.Println(err)
        return
    }
    var closeCh chan struct{} = make(chan struct{}, 1)

    go func(closeCh chan struct{}, c *Connection) {
        ticker := time.NewTicker(Default_timeout)
        defer ticker.Stop()

        for {
            select {
            case <-ticker.C:
                d := convert2TsdbItem(NewMetaData())
                var tsdbBuffer bytes.Buffer
                tsdbBuffer.WriteString(d.TsdbString())
                tsdbBuffer.WriteString("\n")
                err := c.Send(tsdbBuffer.Bytes())
                if err != nil {
                    log.Println(err)
                }

                log.Println("send tsdb message success, msg content:", d.String())

            case <-closeCh:
                return
            }
        }
    }(closeCh, c)

    /*
            //windows not support that.
            sigs := make(chan os.Signal, 1)
            signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
            log.Println(os.Getpid(), "register signal notify")
            <-sigs
            close(closeCh)
            time.Sleep(Default_timeout)
    */

    select {}
}

type Query struct {
    Aggregator string            `json:"aggregator"`
    Metric     string            `json:"metric"`
    Rate       bool              `json:"rate,omitempty"`
    Tags       map[string]string `json:"tags,omitempty"`
}

type QueryParams struct {
    Start             interface{} `json:"start"`
    End               interface{} `json:"end,omitempty"`
    Queries           []Query     `json:"queries,omitempty"`
    NoAnnotations     bool        `json:"no_annotations,omitempty"`
    GlobalAnnotations bool        `json:"global_annotations,omitempty"`
    MsResolution      bool        `json:"ms,omitempty"`
    ShowTSUIDs        bool        `json:"show_tsuids,omitempty"`
    ShowSummary       bool        `json:"show_summary,omitempty"`
    ShowQuery         bool        `json:"show_query,omitempty"`
    Delete            bool        `json:"delete,omitempty"`
}

type QueryResponse struct {
    Metric        string             `json:"metric"`
    Tags          map[string]string  `json:"tags"`
    AggregateTags []string           `json:"aggregateTags"`
    Dps           map[string]float64 `json:"dps"`
}

func NewQueryParams() (*QueryParams, error) {
    return &QueryParams{}, nil
}

//query data from opentsdb by metric and time
func QueryByMetricAndTimestamp() {
    //    item := &Query{Tags: make(map[string]string)}
    //    item.Tags["endpoint"] = "hadoop1"
    //    item.Aggregator = "none"
    //    item.Metric = "cpu.idle"
    //format time for q.start and q.end

    now := time.Now()
    m, _ := time.ParseDuration("-1m")
    m1 := now.Add(70 * m)
    m2 := now.Add(60 * m)
    start := m1.Format("2006/01/02-15:04:05")
    end := m2.Format("2006/01/02-15:04:05")
    fmt.Println(start)
    fmt.Println(end)
    q, _ := NewQueryParams()
    q.Start = start
    q.End = end
    //    q.Start = "2018/11/07-01:30:00"
    //    q.End = "2018/11/07-01:40:00"
    //    q.Start = "1h-ago"
    //    q.Queries = append(q.Queries, *item)
    q.Queries = append(q.Queries, Query{Aggregator: "none", Metric: "cpu.idle", Tags: map[string]string{"endpoint": "hadoop1"}})
    data, err := json.Marshal(*q)
    if err != nil {
        fmt.Println(err)
    }

    req, err := http.NewRequest("POST", "http://10.100.101.70:4242/api/query", bytes.NewBuffer(data))
    if err != nil {
        fmt.Println(err)
    }

    req.Header.Set("Content-Type", "application/json")
    //    fmt.Println("new request :", req)
    client := &http.Client{}
    resp, err := client.Do(req)
    fmt.Println("client do response :", resp)
    defer resp.Body.Close()
    if err != nil {
        panic(err)
    }

    body, err := ioutil.ReadAll(resp.Body)

    if err != nil {
        fmt.Println(err)
    }
    //    fmt.Println("tsbody :", string(body))
    var tsdb []QueryResponse
    err = json.Unmarshal(body, &tsdb)
    if err != nil {
        log.Fatalln("parse fail:", err)
    }
    for k, _ := range tsdb {
        //        fmt.Println("Metric:", tsdb[k].Metric)
        //        fmt.Println("Tags:", tsdb[k].Tags)
        //        fmt.Println("AggregateTags:", tsdb[k].AggregateTags)
        //        fmt.Println("Dps", tsdb[k].Dps)
        //        fmt.Println("Dps len", len(tsdb[k].Dps))
        t := time.Now()
        sli := make([]int, 0)
        var intstr int
        for tk, vv := range tsdb[k].Dps {
            fmt.Println(tk, ":", vv)
            intstr, _ = strconv.Atoi(tk)
            sli = append(sli, intstr)
        }
        sort.Ints(sli[:])
        for _, sv := range sli {
            fmt.Println(sv, ":", tsdb[k].Dps[strconv.Itoa(sv)])
        }
        fmt.Println("slice建立速度："+time.Now().Sub(t).String(), sli)
    }

}

func main() {

    QueryByMetricAndTimestamp()
    PutDataToTsdb()

}