package api

import (
	"datart/data"
	"datart/data/influx"
	"datart/data/postgres"
	"datart/log"
	"datart/util"
	"errors"
	"fmt"
	"strings"

	"github.com/gin-gonic/gin"
)

func (a *Api) GetPointData(ctx *gin.Context) {
	request, err := a.checkAndGenGetPointRequest(ctx)
	if err != nil {

		log.Error(err)

		ctx.JSON(200, gin.H{
			"code": 1,
			"msg":  err.Error(),
		})
		return
	}

	var data map[string][]influx.TV
	switch {
	case request.Begin > 0 && request.End > 0:
		data, err = influx.GetSSUPointsDurationData(ctx.Request.Context(), request)

	case request.Begin > 0 && request.End < 0:
		data, err = influx.GetSSUPointsAfterLimit(ctx.Request.Context(), request, 1)

	case request.Begin < 0 && request.End > 0:
		data, err = influx.GetSSUPointsBeforeLimit(ctx.Request.Context(), request, 1)

	default:
		data, err = influx.GetSSUPointsLastLimit(ctx.Request.Context(), request, 1)
	}

	if err != nil {

		log.Error(err, fmt.Sprintf(" params: %v", request))

		ctx.JSON(200, gin.H{
			"code": 2,
			"msg":  "query database error",
		})
		return
	}

	ctx.JSON(200, gin.H{
		"code": 0,
		"msg":  "success",
		"data": data,
	})
}

func (a *Api) checkAndGenGetPointRequest(ctx *gin.Context) (*influx.Request, error) {

	typeStr := ctx.DefaultQuery("type", "")
	if len(typeStr) <= 0 {
		return nil, errors.New("invalid type")
	}

	station, mainPos, subPos := "", "", ""

	mtag := ctx.DefaultQuery("mtag", "")
	v, ok := postgres.ChannelSizes.Load(mtag)
	if ok {
		if channelSize, ok := v.(postgres.ChannelSize); ok {
			fields := data.GenPhasorFields(channelSize.Channel)

			station = channelSize.Station
			mainPos = channelSize.Device
			subPos = strings.Join(fields, ",")
		}
	} else {
		station = ctx.DefaultQuery("station", "")
		if len(station) <= 0 {
			return nil, errors.New("invalid station")
		}

		mainPos = ctx.DefaultQuery("main_pos", "")
		if len(mainPos) <= 0 {
			return nil, errors.New("invalid main_pos")
		}

		subPos = ctx.DefaultQuery("sub_pos", "")
		if len(subPos) <= 0 {
			return nil, errors.New("invalid sub_pos")
		}
	}

	beginStr := ctx.DefaultQuery("begin", "")

	endStr := ctx.DefaultQuery("end", "")

	operate := ctx.DefaultQuery("operate", "")

	step := ctx.DefaultQuery("step", "")

	defaultV := ctx.DefaultQuery("default", "")

	begin := util.ConvertToInt64Default(beginStr, -1)

	end := util.ConvertToInt64Default(endStr, -1)

	bucket, err := influx.GetDB(typeStr)
	if err != nil {
		return nil, err
	}

	measure, err := influx.GetTable(typeStr, mainPos)
	if err != nil {
		return nil, err
	}

	return &influx.Request{
		DB:      bucket,
		Table:   measure,
		Type:    typeStr,
		Station: station,
		MainPos: mainPos,
		SubPos:  subPos,
		Begin:   begin,
		End:     end,
		Operate: operate,
		Step:    step,
		Default: defaultV,
	}, nil
}