// Package database define database operation functions
package database

import (
	"fmt"
	"strings"
)

// InfluxDBQueryPara define struct of influxdb query parameters
type InfluxDBQueryPara struct {
	Bucket      string `json:"bucket"`
	Measurement string `json:"measurement"`
	Start       string `json:"start"`
	Stop        string `json:"stop"`
	Field       string `json:"field"`
	// Value       float64 `json:"value"`
}

// QueryPara define influxdb query parameters interface
type QueryPara interface {
	apply(string) string
}

// BucketQueryPara define influxdb bucket query parameter
type BucketQueryPara string

func (b BucketQueryPara) apply(query string) string {
	template := " from(bucket:\"{bucketId}\") "
	template = strings.Replace(template, "{bucketId}", string(b), -1)
	return query + template
}

// WithBucket define func of set bucket parameter in query statment
func WithBucket(bucketID string) BucketQueryPara {
	return BucketQueryPara(bucketID)
}

// MeasurementQueryPara define influxdb measurement query parameter
type MeasurementQueryPara string

func (m MeasurementQueryPara) apply(query string) string {
	template := " |> filter(fn: (r) => r[\"_measurement\"] == \"{measurement}\") "
	template = strings.Replace(template, "{measurement}", string(m), -1)
	return query + template
}

// WithMeasurement define func of set measurement parameter in query statment
func WithMeasurement(measurement string) MeasurementQueryPara {
	return MeasurementQueryPara(measurement)
}

// RangeTimeQueryPara define influxdb range query parameter
type RangeTimeQueryPara struct {
	StartTime string
	StopTime  string
}

func (r RangeTimeQueryPara) apply(query string) string {
	template := " |> range(start: {start}, stop: {stop}) "
	template = strings.Replace(template, "{start}", r.StartTime, -1)
	template = strings.Replace(template, "{stop}", r.StopTime, -1)
	return query + template
}

// WithRangeTime define func of set range parameter in query statment
func WithRangeTime(startTime, stopTime string) RangeTimeQueryPara {
	return RangeTimeQueryPara{StartTime: startTime, StopTime: stopTime}
}

// FieldQueryPara define influxdb field query parameter
type FieldQueryPara struct {
	Fields   []string
	Operator string
}

func (f FieldQueryPara) apply(query string) string {
	fieldTemplate := "r[\"_field\"] == \"{value}\""
	filterTemplate := " |> filter(fn: (r) => {field_template}) "
	fieldBuilder := strings.Builder{}
	for index, field := range f.Fields {
		if index > 0 {
			operator := " " + f.Operator + " "
			fieldBuilder.Write([]byte(operator))
		}
		filedContent := strings.Replace(fieldTemplate, "{value}", field, -1)
		fieldBuilder.Write([]byte(filedContent))
	}
	filterTemplate = strings.Replace(filterTemplate, "{field_template}", fieldBuilder.String(), -1)
	return query + filterTemplate
}

// WithField define func of set field parameter in query statment
func WithField(fields []string, operator string) FieldQueryPara {
	return FieldQueryPara{Fields: fields, Operator: operator}
}

// TagQueryPara define influxdb tag query parameter
type TagQueryPara struct {
	Tag      []string
	Value    []string
	Operator string
}

func (t TagQueryPara) apply(query string) string {
	tagTemplate := "r[\"{tag}\"] == \"{value}\""
	filterTemplate := " |> filter(fn: (r) => {tag_template}) "
	tagBuilder := strings.Builder{}
	for i := 0; i < len(t.Tag); i++ {
		if i > 0 {
			operator := " " + t.Operator + " "
			tagBuilder.Write([]byte(operator))
		}
		tagContent := strings.Replace(tagTemplate, "{tag}", t.Tag[i], -1)
		tagContent = strings.Replace(tagContent, "{value}", t.Value[i], -1)
		fmt.Printf("tagContent:%v\n", tagContent)
		tagBuilder.Write([]byte(tagContent))
	}

	filterTemplate = strings.Replace(filterTemplate, "{tag_template}", tagBuilder.String(), -1)
	return query + filterTemplate
}

// WithTag define func of set tag parameter in query statment
func WithTag(tag []string, value []string, operator string) TagQueryPara {
	return TagQueryPara{Tag: tag, Value: value, Operator: operator}
}

// InitQueryByPara define func of init influxdb query statment
func InitQueryByPara(paras ...QueryPara) (queryCmd string) {
	for _, para := range paras {
		queryCmd = para.apply(queryCmd)
	}
	fmt.Printf("queryCmd:%v\n", queryCmd)
	return
}