type Config struct {
	RootPath        string   `toml:"root_path"`
	BackgroundExec  string   `toml:"background_exec"` // Execute that stays running and is unaffected by any reloads npm run dev for example
    BackgroundCheck bool     `toml:"background_check"`
	Ignore          Ignore   `toml:"ignore"`
	ExecList        []string `toml:"exec_list"` // See [Execute Lifecycle](https://github.com/atterpac/refresh#execute-lifecycle)
	LogLevel        string   `toml:"log_level"`
	Debounce        int      `toml:"debounce"`
	Callback        func(*EventCallback) EventHandle
	Slog            *slog.Logger
}

type Ignore struct {
	Dir        []string `toml:"dir"` // Specfic directory to ignore ie; node_modules
	File       []string `toml:"file"` // Specific file to ignore 
	WatchExten []string `toml:"extension"` // Extensions to watch NOT ignore, ie; `*.go, *.js` would ignore any file that is not go or javascript
    GitIgnore  bool     `toml:"git_ignore"` // When true will check for a .gitignore in the root directory and add all entries to the ignore
}

type Execute struct {
	Cmd          string      `toml:"cmd" yaml:"cmd"`                     // Execute command
	ChangeDir    string      `toml:"dir" yaml:"dir"`                     // If directory needs to be changed to call this command relative to the root path
	IsBlocking   bool        `toml:"blocking" yaml:"blocking"`           // Should the following executes wait for this one to complete
	IsPrimary    bool        `toml:"primary" yaml:"primary"`             // Only one primary command can be run at a time
	DelayNext    int         `toml:"delay_next" yaml:"delay_next"`       // Delay in milliseconds before running command
}

import ( // other imports
     "github.com/atterpac/refresh/engine"
    )

func main () {
    // Setup your watched exensions and any ignored files or directories
	ignore := engine.Ignore{
        // Can use * wildcards per usual filepath pattern matching (including /**/) 
        // ! denoted an invert in this example ignoring any extensions that are not *.go
        WatchedExten: []string{"*.go"}, // Ignore all files that are not go
		File:         []string{"ignore*.go"},  // Pattern match to ignore any golang files that start with ignore
		Dir:          []string{".git","*/node_modules", "!api/*"}, // Ignore .git and any node_modules in the directory or anything not within the api directory
        IgnoreGit: true, // .gitignore sitting in the root directory? set this to true to automatially ignore those files
	}
    // Build execute structs
	tidy := engine.Execute{
		Cmd:        "go mod tidy",
		IsBlocking: true, // Next command should wait for this to finish
	}
	build := engine.Execute{
		Cmd:        "go build -o ./bin/myapp",
		IsBlocking: true, // Wait to kill (next step) until the new binary is built
	}
    // Provided KILL_STALE will tell refresh when you would like to remove the stale process to prepare to launch the new one
	kill := engine.KILL_STALE 
    // Primary process usually runs your binary
	run := engine.Execute{
        ChangeDir:   "./bin", // Change directory to call command in
		Cmd:        "./myapp",
		IsBlocking: false, // Should not block because it doesnt finish until Killed by refresh
		IsPrimary:  true, // This is the main process refersh is rerunning so denoting it as primary
	}
    // Create config to pass into refresh.NewEngineFromConfig()
	config := engine.Config{
		RootPath: "./test",
		// Below is ran when a reload is triggered before killing the stale version
		Ignore:     ignore,
		Debounce:   1000, // Time in ms to ignore repitive reload triggers usually caused by an OS creating multiple write/rename events for a singular change
		LogLevel:   "debug", // debug | info | warn | error | mute -> surpresses all logs to the stdOut
        Callback:   RefreshCallback, // func(*engine.Callback) refresh.EventHandle {}
		ExecStruct: []refresh.Execute{tidy, build, kill, run},
        // Alternatively for easier config but less control over executes
        // ExecList: []string{"go mod tidy", "go build -o ./myapp", refresh.KILL_EXEC, refresh.REFRESH_EXEC, "./myapp"}
        // All calls will be blocking with the exception of the call after REFRESH
        // Both KILL_EXEC and REFRESH_EXEC are **REQUIRED** for refresh to function properly
        // engine.KILL_EXEC denotes when the stale process should be killed
        // engine.REFRESH_EXEC denotes the next execute is "primary"
		Slog:       nil, // Optionally provide a slog interface
                         // if nil a default will be provided
                         // If provided stdout will not be piped through refresh
	}

	engine, err := refresh.NewEngineFromConfig(config)
    if err != nil {
        //Handle err
    }
	err = engine.Start()
    if err != nil {
        // Start will return an error when a user hits ctrl-c after it gracefully kills the processes
    }

	// Stop monitoring files and kill child processes
	engine.Stop()
}

func RefreshCallback(e *engine.EventCallback) engine.EventHandle {
    switch e.Type {
        case engine.Create:
            return engine.EventIgnore
        case engine.Write:
                if e.Path == "test/monitored/ignore.go" {
                    return engine.EventBypass
                }
                return engine.EventContinue
        case engine.Remove:
                    return engine.EventContinue
                        // Other cases as needed ...
    }
    return engine.EventContinue
}

const (
    // Base Actions
	Create Event = iota
	Write
	Remove
	Rename
	// Windows Specific Actions
	ActionModified
	ActionRenamedNewName
	ActionRenamedOldName
	ActionAdded
	ActionRemoved
	ChangeLastWrite
	ChangeAttributes
	ChangeSize
	ChangeDirName
	ChangeFileName
	ChangeSecurity
	ChangeCreation
	ChangeLastAccess
	// Linux Specific Actions
	InCloseWrite
	InModify
	InMovedTo
	InMovedFrom
	InCreate
	InDelete
)

// Used as a response to the Callback 
const (
	EventContinue EventHandle = iota
	EventBypass
	EventIgnore
)

// Called whenever a change is detected in the filesystem
// By default we ignore file rename/remove and a bunch of other events that would likely cause breaking changes on a reload see eventmap_[oos].go for default rules
type EventCallback struct {
	Type Event  // Type of Notification (Write/Create/Remove...)
	Time time.Time // time.Now() when event was triggered
	Path string    // Relative path based on root if root is ./myProject paths start with "myProject/..."
}
// Available returns from the Callback function
const (
	EventContinue EventHandle = iota // Continue with refresh ruleset 
	EventBypass // Bypass all rule and reload the process
	EventIgnore // Force Ignore event and continue watching 
)

func ExampleCallback(e refresh.EventCallback) refresh.EventHandle {
	switch e.Type {
	case engine.Create:
		// Continue with reload process based on configured ruleset
		return refresh.EventContinue
	case engine.Write:
		// Ignore a file that would normally trigger a reload based on config
		if e.Path == "path/to/watched/file" {
			return engine.EventIgnore
		}
		// Continue with reload ruleset but add some extra logs/logic
		fmt.Println("File Modified: %s", e.Path)	
		return engine.EventContinue
	case engine.Remove:
		// refresh will ignore this event by default
		// Return EventBypass to force reload process
		return engine.EventBypass
	}
	return engine.EventContinue
}

engine.NewEngineFromTOML("path/to/toml")
engine.SetLogger(//Input slog.Logger)