package main

import (
	"errors"
	"os"
	"time"

	"git.iamthefij.com/iamthefij/slog"
	"gopkg.in/yaml.v2"
)

var errInvalidConfig = errors.New("Invalid configuration")

// Config type is contains all provided user configuration
type Config struct {
	CheckInterval     SecondsOrDuration `yaml:"check_interval"`
	DefaultAlertAfter int16             `yaml:"default_alert_after"`
	DefaultAlertEvery *int16            `yaml:"default_alert_every"`
	DefaultAlertDown  []string          `yaml:"default_alert_down"`
	DefaultAlertUp    []string          `yaml:"default_alert_up"`
	Monitors          []*Monitor
	Alerts            map[string]*Alert
}

// CommandOrShell type wraps a string or list of strings
// for executing a command directly or in a shell
type CommandOrShell struct {
	ShellCommand string
	Command      []string
}

// Empty checks if the Command has a value
func (cos CommandOrShell) Empty() bool {
	return (cos.ShellCommand == "" && cos.Command == nil)
}

// UnmarshalYAML allows unmarshalling either a string or slice of strings
// and parsing them as either a command or a shell command.
func (cos *CommandOrShell) UnmarshalYAML(unmarshal func(interface{}) error) error {
	var cmd []string
	err := unmarshal(&cmd)
	// Error indicates this is shell command
	if err != nil {
		var shellCmd string

		err := unmarshal(&shellCmd)
		if err != nil {
			return err
		}

		cos.ShellCommand = shellCmd
	} else {
		cos.Command = cmd
	}

	return nil
}

// SecondsOrDuration wraps a duration value for parsing a duration or seconds from YAML
// NOTE: This should be removed in favor of only parsing durations once compatibility is broken
type SecondsOrDuration struct {
	value time.Duration
}

// Value returns a duration value
func (sod SecondsOrDuration) Value() time.Duration {
	return sod.value
}

// UnmarshalYAML allows unmarshalling a duration value or seconds if an int was provided
func (sod *SecondsOrDuration) UnmarshalYAML(unmarshal func(interface{}) error) error {
	var seconds int64
	err := unmarshal(&seconds)

	if err == nil {
		sod.value = time.Second * time.Duration(seconds)

		return nil
	}

	// Error indicates that we don't have an int
	err = unmarshal(&sod.value)

	return err
}

// IsValid checks config validity and returns true if valid
func (config Config) IsValid() (isValid bool) {
	isValid = true

	// Validate alerts
	if config.Alerts == nil || len(config.Alerts) == 0 {
		// This should never happen because there is a default alert named 'log' for now
		slog.Errorf("Invalid alert configuration: Must provide at least one alert")

		isValid = false
	}

	for _, alert := range config.Alerts {
		if !alert.IsValid() {
			slog.Errorf("Invalid alert configuration: %+v", alert.Name)

			isValid = false
		} else {
			slog.Debugf("Loaded alert %s", alert.Name)
		}
	}

	// Validate monitors
	if config.Monitors == nil || len(config.Monitors) == 0 {
		slog.Errorf("Invalid monitor configuration: Must provide at least one monitor")

		isValid = false
	}

	for _, monitor := range config.Monitors {
		if !monitor.IsValid() {
			slog.Errorf("Invalid monitor configuration: %s", monitor.Name)

			isValid = false
		}
		// Check that all Monitor alerts actually exist
		for _, isUp := range []bool{true, false} {
			for _, alertName := range monitor.GetAlertNames(isUp) {
				if _, ok := config.Alerts[alertName]; !ok {
					slog.Errorf(
						"Invalid monitor configuration: %s. Unknown alert %s",
						monitor.Name, alertName,
					)

					isValid = false
				}
			}
		}
	}

	return isValid
}

// Init performs extra initialization on top of loading the config from file
func (config *Config) Init() (err error) {
	for _, monitor := range config.Monitors {
		if monitor.AlertAfter == 0 && config.DefaultAlertAfter > 0 {
			monitor.AlertAfter = config.DefaultAlertAfter
		}

		if monitor.AlertEvery == nil && config.DefaultAlertEvery != nil {
			monitor.AlertEvery = config.DefaultAlertEvery
		}

		if len(monitor.AlertDown) == 0 && len(config.DefaultAlertDown) > 0 {
			monitor.AlertDown = config.DefaultAlertDown
		}

		if len(monitor.AlertUp) == 0 && len(config.DefaultAlertUp) > 0 {
			monitor.AlertUp = config.DefaultAlertUp
		}
	}

	for name, alert := range config.Alerts {
		alert.Name = name

		if err = alert.BuildTemplates(); err != nil {
			return
		}
	}

	return
}

// LoadConfig will read config from the given path and parse it
func LoadConfig(filePath string) (config Config, err error) {
	data, err := os.ReadFile(filePath)
	if err != nil {
		return
	}

	err = yaml.Unmarshal(data, &config)
	if err != nil {
		return
	}

	slog.Debugf("Config values:\n%v\n", config)

	// Finish initializing configuration
	if err = config.Init(); err != nil {
		return
	}

	if !config.IsValid() {
		err = errInvalidConfig

		return
	}

	return config, err
}