package daemons

import (
	"fmt"
	"oc-schedulerd/conf"
	"os"
	"os/exec"
	"time"

	oclib "cloud.o-forge.io/core/oc-lib"
	"cloud.o-forge.io/core/oc-lib/models/common/enum"
	"github.com/rs/zerolog"
)

type LocalMonitor struct {
	ExecutionID   string
	PeerID        string
	Duration      int
	LokiUrl       string
	MongoUrl      string
	DBName        string
	ScheduledTime time.Time
}

func NewLocalMonitor(UUID string, peerId string, duration int, scheduledTime time.Time) Executor {
	return &LocalMonitor{
		ExecutionID:   UUID,
		PeerID:        peerId,
		Duration:      duration,
		ScheduledTime: scheduledTime,
	}
}

// func (lm *LocalMonitor) LaunchLocalMonitor() {
// 	if lm.ExecutionID == "" {
// 		lm.Logger.Error().Msg("Missing parameter in LocalMonitor")
// 	}

// }

func (lm *LocalMonitor) PrepareMonitorExec() []string {

	args := []string{
		"-e", lm.ExecutionID,
		"-p", lm.PeerID,
		"-H", conf.GetConfig().KubeHost,
		"-c", conf.GetConfig().KubeCA,
		"-C", conf.GetConfig().KubeCert,
		"-D", conf.GetConfig().KubeData,
		"-s", fmt.Sprintf("%d", lm.ScheduledTime.Unix()),
	}
	if lm.Duration > 0 {
		args = append(args, "-t", fmt.Sprintf("%d", lm.Duration))
	}

	return args
}

func (lm *LocalMonitor) LaunchMonitor(args []string, execID string, ns string, l zerolog.Logger) {
	cmd := exec.Command(conf.GetConfig().MonitorPath, args...)
	cmd.Env = append(os.Environ(),
		"OC_MONGO_URL="+oclib.GetConfig().MongoUrl,
		"OC_MONGO_DATABASE="+oclib.GetConfig().MongoDatabase,
		"OC_LOKI_URL="+oclib.GetConfig().LokiUrl,
		"OC_NATS_URL="+oclib.GetConfig().NATSUrl,
	)
	fmt.Println("LaunchMonitor LOCAL")
	l.Info().Str("binary", conf.GetConfig().MonitorPath).Strs("args", args).Msg("Starting oc-monitord")

	stdoutMonitord, err := cmd.StdoutPipe()
	if err != nil {
		l.Error().Err(err).Msg("Could not retrieve stdout pipe for oc-monitord")
		oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.WORKFLOW_EXECUTION), nil).UpdateOne(map[string]interface{}{
			"state": enum.FAILURE.EnumIndex(),
		}, execID)
		return
	}

	stderrMonitord, err := cmd.StderrPipe()
	if err != nil {
		l.Error().Err(err).Msg("Could not retrieve stderr pipe for oc-monitord")
		oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.WORKFLOW_EXECUTION), nil).UpdateOne(map[string]interface{}{
			"state": enum.FAILURE.EnumIndex(),
		}, execID)
		return
	}

	err = cmd.Start()
	if err != nil {
		l.Error().Err(err).Str("execution", lm.ExecutionID).Msg("Could not start oc-monitord")
		oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.WORKFLOW_EXECUTION), nil).UpdateOne(map[string]interface{}{
			"state": enum.FAILURE.EnumIndex(),
		}, execID)
		return
	}

	l.Info().Int("pid", cmd.Process.Pid).Msg("oc-monitord started")
	go logExecution(stderrMonitord, l)
	logExecution(stdoutMonitord, l)
}