// Copyright 2021 PingCAP, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.

package cmd

import (
	"fmt"
	lg "github.com/pingcap-inc/rule-engine/log/engine"
	sqcfg "github.com/pingcap-inc/rule-engine/slowquery/config"
	sqeng "github.com/pingcap-inc/rule-engine/slowquery/engine"
	"github.com/pingcap-inc/rule-engine/utils"
	"github.com/spf13/cobra"
)

func newExecuteCmd() *cobra.Command {
	var cluster string
	var index string
	var es string
	var kibana string
	var begin string
	var end string
	var inc = []string{"log"}

	cmd := &cobra.Command{
		Use:   "execute",
		Short: "execute rule",
		RunE: func(cmd *cobra.Command, args []string) error {
			b, err := utils.ParseTime(begin)
			if err != nil {
				return err
			}
			e, err := utils.ParseTime(end)
			if err != nil {
				return err
			}
			for _, tp := range inc {
				switch tp {
				case "log":
					eng, err := lg.New(&lg.EngineConfig{
						ClusterID:      cluster,
						KibanaIndex:    index,
						ESEndpoint:     es,
						KibanaEndpoint: kibana,
						BeginTime:      b,
						EndTime:        e,
					})
					if err != nil {
						return err
					}

					syms, err := eng.Execute()
					if err != nil {
						return err
					}

					for _, sym := range syms {
						fmt.Println(sym.Kibana)
					}
				case "slow_query":
					spec, err := sqcfg.LoadBetaRuleSpec()
					if err != nil {
						return err
					}
					eng, err := sqeng.New(&sqeng.Config{
						ESIndex:        fmt.Sprintf("%s_slowquery", cluster),
						KibanaIndex:    index,
						ESEndpoint:     es,
						KibanaEndpoint: kibana,
						BeginTime:      b,
						EndTime:        e,
					}, sqeng.WithRules(spec.Rule))
					if err != nil {
						return err
					}
					syms, err := eng.Execute()
					if err != nil {
						return err
					}
					for _, sym := range syms {
						fmt.Println(sym.Kibana)
					}
				}
			}
			return nil
		},
	}

	cmd.Flags().StringVarP(&cluster, "cluster", "c", "", "the cluster id to execute on")
	cmd.Flags().StringVarP(&index, "index", "i", "", "the kibana index pattern")
	cmd.Flags().StringVarP(&es, "es", "e", "", "the elastic search endpoint")
	cmd.Flags().StringVarP(&kibana, "kibana", "k", "", "the kibana endpoint")
	cmd.Flags().StringVarP(&begin, "begin", "", "", "log search begin time")
	cmd.Flags().StringVarP(&end, "end", "", "", "log search end time")
	cmd.Flags().StringSliceVar(&inc, "include", inc, "types of data to check, supported value is log, slow_query")

	cmd.MarkFlagRequired("cluster")
	cmd.MarkFlagRequired("index")
	cmd.MarkFlagRequired("es")
	cmd.MarkFlagRequired("kibana")
	cmd.MarkFlagRequired("begin")
	cmd.MarkFlagRequired("end")

	return cmd
}