package config

import (
	_ "embed"
	"fmt"
	"os"
	"path"
	"wazuh-notify/log"

	"github.com/BurntSushi/toml"
)

//go:embed default-config.toml
var DefaultConfigFile []byte
var File Config

// WARNING: this code is ai generated
func Read() error {
	const SystemConfigPath = "/etc/wazuh-notify/wazuh-notify-config.toml"
	execPath, _ := os.Executable()
	LocalConfigPath := path.Join(path.Dir(execPath), "wazuh-notify-config.toml")

	err := toml.Unmarshal(DefaultConfigFile, &File)
	if err != nil {
		log.Log(fmt.Sprintf("CRITICAL: Failed to parse embedded default config: %v", err))
		return err
	}

	var userTomlFile []byte
	var readErr error
	var configPath string

	userTomlFile, readErr = os.ReadFile(SystemConfigPath)
	if readErr == nil {
		configPath = SystemConfigPath
	} else {
		userTomlFile, readErr = os.ReadFile(LocalConfigPath)
		if readErr == nil {
			configPath = LocalConfigPath
		}
	}

	if readErr != nil {
		log.Log("No user config file found. Attempting to create default on disk.")

		errMkdir := os.MkdirAll(path.Dir(SystemConfigPath), os.ModePerm)
		errWrite := os.WriteFile(SystemConfigPath, DefaultConfigFile, 0600)

		if errMkdir != nil || errWrite != nil {
			log.Log(fmt.Sprintf("Warning: Could not write default config to %s (%v).", SystemConfigPath, errWrite))
			log.Log("Using embedded default configuration only.")
		} else {
			log.Log(fmt.Sprintf("Successfully created default config at %s.", SystemConfigPath))
		}

		log.Log("TOML configuration loaded successfully from Embedded Default")
		return nil
	}

	overrideErr := toml.Unmarshal(userTomlFile, &File)
	if overrideErr != nil {
		log.Log(fmt.Sprintf("Error parsing user configuration from %s: %v", configPath, overrideErr))
		return overrideErr
	}

	log.Log(fmt.Sprintf("TOML configuration loaded successfully. Defaults merged with %s", configPath))
	return nil
}

// Config holds the entire configuration structure defined in the TOML file.
type Config struct {
	General      General       `toml:"general"`
	PriorityMaps []PriorityMap `toml:"priority_map"`
	Discord      Discord       `toml:"discord"`
	Ntfy         Ntfy          `toml:"ntfy"`
	Slack        Slack         `toml:"slack"`
}

// General maps the values within the [general] TOML table.
type General struct {
	Targets             string   `toml:"targets"`
	FullAlert           string   `toml:"full_alert"`
	ExcludedRules       string   `toml:"excluded_rules"`
	ExcludedAgents      string   `toml:"excluded_agents"`
	ExcludeDescriptions []string `toml:"exclude_descriptions"`
	Sender              string   `toml:"sender"`
	Click               string   `toml:"click"`
}

// PriorityMap maps the values within a single [[priority_map]] TOML table entry.
type PriorityMap struct {
	ThreatMap        []int `toml:"threat_map"`
	MentionThreshold int   `toml:"mention_threshold"`
	NotifyThreshold  int   `toml:"notify_threshold"`
	Color            int   `toml:"color"`
}

type Discord struct {
	Webhook string `toml:"webhook"`
}

// Ntfy maps the values within the [ntfy] TOML table.
type Ntfy struct {
	Webhook string `toml:"webhook"`
}

// Slack maps the values within the [slack] TOML table.
type Slack struct {
	Webhook string `toml:"webhook"`
}