package modelrt

import (
	"context"
	"datart/config"
	"datart/data/influx"
	"datart/log"
	"encoding/json"
	"net/url"
	"os"
	"os/signal"
	"time"

	"github.com/gorilla/websocket"
)

// 处理非模块内接口的数据
func PushDataToModelRT() {
	modelrtConfig := config.Conf().ModelRTConf("demo")
	u := url.URL{
		Scheme: modelrtConfig.GetScheme(),
		Host:   modelrtConfig.GetHost(),
		Path:   modelrtConfig.GetPath(),
	}

	signalChan := make(chan os.Signal, 1)
	signal.Notify(signalChan, os.Interrupt)

	for {
		pushDataToModelRT(signalChan, u.String())
	}
}

func pushDataToModelRT(signalChan <-chan os.Signal, url string) {
	conn, _, err := websocket.DefaultDialer.Dial(url, nil)
	if err != nil {
		log.Error("ws dial:", err)
	}
	defer conn.Close()

	done := make(chan struct{})
	go func() {
		defer close(done)

		for {
			time.Sleep(time.Second) // demo TODO
			pushData(conn, "channel_1")
			pushData(conn, "channel_2")
		}
	}()

	for {
		select {
		case <-done:
			return
		case <-signalChan:
			err := conn.WriteMessage(websocket.CloseMessage,
				websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
			if err != nil {
				log.Error("ws write close:", err)
				return
			}

			select {
			case <-done:
			case <-time.After(time.Second):
			}
			return
		}
	}
}

func pushData(conn *websocket.Conn, field string) error {
	data, err := getPushedData(field)
	if err != nil {
		return err
	}

	err = conn.WriteMessage(websocket.TextMessage, data)
	if err != nil {
		return err
	}

	_, msg, err := conn.ReadMessage()
	if err != nil {
		return err
	}

	log.Debug("ws read:", msg)

	return nil
}

func getPushedData(field string) ([]byte, error) {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	req := &influx.Request{
		RespType: "csv",
		Database: "influxBucket",
		Measure:  "samples",
		Station:  "TJSH_FZ001",
		Device:   "DDJ001",
		Field:    field,
		Begin:    0,
		End:      0,
		Operate:  "",
		Step:     "",
		Default:  "",
	}
	tvs, err := influx.GetLastLimit(ctx, req, 1000)
	if err != nil {
		return nil, err
	}

	pushedData := &struct {
		Payload *struct {
			ComponentID int          `json:"component_id"`
			Point       string       `json:"point"`
			Values      []*influx.TV `json:"values"`
		} `json:"payload"`
	}{
		Payload: &struct {
			ComponentID int          `json:"component_id"`
			Point       string       `json:"point"`
			Values      []*influx.TV `json:"values"`
		}{
			ComponentID: 0,
			Point:       field,
			Values:      tvs,
		},
	}

	data, err := json.Marshal(pushedData)
	if err != nil {
		return nil, err
	}

	return data, nil
}