HATray/internal/app/app.go

package app

import (
	"log/slog"
	"sync"
)

// App represents the main application layer that is generic and cross-platform
type App struct {
	logger *slog.Logger
	mu     sync.RWMutex
	state  AppState
}

// AppState represents the current state of the application
type AppState string

const (
	StateRunning AppState = "running"
	StatePaused  AppState = "paused"
	StateStopped AppState = "stopped"
)

// NewApp creates a new application instance
func NewApp(logger *slog.Logger) *App {
	return &App{
		logger: logger,
		state:  StateRunning,
	}
}

// Pause disconnects from the server and ceases any background tasks
func (a *App) Pause() error {
	a.mu.Lock()
	defer a.mu.Unlock()

	a.logger.Info("Pausing application",
		"action", "pause",
		"previous_state", a.state,
		"new_state", StatePaused)

	// TODO: Implement actual pause logic
	// - Disconnect from Home Assistant WebSocket
	// - Stop background tasks
	// - Pause sensor monitoring

	a.state = StatePaused

	a.logger.Info("Application paused successfully",
		"action", "pause",
		"state", a.state)

	return nil
}

// Resume connects to the server and initiates background tasks
func (a *App) Resume() error {
	a.mu.Lock()
	defer a.mu.Unlock()

	a.logger.Info("Resuming application",
		"action", "resume",
		"previous_state", a.state,
		"new_state", StateRunning)

	// TODO: Implement actual resume logic
	// - Connect to Home Assistant WebSocket
	// - Start background tasks
	// - Resume sensor monitoring

	a.state = StateRunning

	a.logger.Info("Application resumed successfully",
		"action", "resume",
		"state", a.state)

	return nil
}

// Reload pauses the application, re-reads configuration files, then resumes
func (a *App) Reload() error {
	a.logger.Info("Starting application reload",
		"action", "reload",
		"current_state", a.state)

	// Pause if not already paused
	if a.state != StatePaused {
		if err := a.Pause(); err != nil {
			a.logger.Error("Failed to pause during reload",
				"action", "reload",
				"error", err)
			return err
		}
	}

	// TODO: Implement configuration reload logic
	// - Re-read TOML configuration files
	// - Validate configuration
	// - Update internal state with new configuration

	a.logger.Info("Configuration reloaded successfully",
		"action", "reload")

	// Resume the application
	if err := a.Resume(); err != nil {
		a.logger.Error("Failed to resume after reload",
			"action", "reload",
			"error", err)
		return err
	}

	a.logger.Info("Application reload completed successfully",
		"action", "reload",
		"final_state", a.state)

	return nil
}

// GetState returns the current state of the application
func (a *App) GetState() AppState {
	a.mu.RLock()
	defer a.mu.RUnlock()
	return a.state
}

// Stop stops the application completely
func (a *App) Stop() error {
	a.mu.Lock()
	defer a.mu.Unlock()

	a.logger.Info("Stopping application",
		"action", "stop",
		"previous_state", a.state,
		"new_state", StateStopped)

	// TODO: Implement actual stop logic
	// - Disconnect from all services
	// - Clean up resources
	// - Stop all background tasks

	a.state = StateStopped

	a.logger.Info("Application stopped successfully",
		"action", "stop",
		"state", a.state)

	return nil
}