repeater/internal/app/app.go

package app

import (
	"embed"
	"log"
	"os"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/nemunaire/repeater/internal/api"
	"github.com/nemunaire/repeater/internal/config"
	"github.com/nemunaire/repeater/internal/device"
	"github.com/nemunaire/repeater/internal/hotspot"
	"github.com/nemunaire/repeater/internal/logging"
	"github.com/nemunaire/repeater/internal/models"
	"github.com/nemunaire/repeater/internal/wifi"
)

// App represents the application
type App struct {
	Status      models.SystemStatus
	StatusMutex sync.RWMutex
	StartTime   time.Time
	Assets      embed.FS
	Config      *config.Config
}

// New creates a new application instance
func New(assets embed.FS) *App {
	return &App{
		Status: models.SystemStatus{
			Connected:       false,
			ConnectionState: "disconnected",
			ConnectedSSID:   "",
			HotspotStatus:   nil,
			ConnectedCount:  0,
			DataUsage:       0.0,
			Uptime:          0,
		},
		StartTime: time.Now(),
		Assets:    assets,
	}
}

// Initialize initializes the application
func (a *App) Initialize(cfg *config.Config) error {
	// Store config reference
	a.Config = cfg

	// Initialize WiFi D-Bus connection
	if err := wifi.Initialize(cfg.WifiInterface); err != nil {
		return err
	}

	// Start WiFi event monitoring
	if err := wifi.StartEventMonitoring(); err != nil {
		log.Printf("Warning: WiFi event monitoring failed: %v", err)
		// Don't fail - polling fallback still works
	}

	// Start periodic tasks
	go a.periodicStatusUpdate()
	go a.periodicDeviceUpdate()

	logging.AddLog("Système", "Application initialisée")
	return nil
}

// Run starts the HTTP server
func (a *App) Run(addr string) error {
	router := api.SetupRouter(&a.Status, a.Config, a.Assets)

	logging.AddLog("Système", "Serveur API démarré sur "+addr)
	return router.Run(addr)
}

// Shutdown gracefully shuts down the application
func (a *App) Shutdown() {
	wifi.StopEventMonitoring()
	wifi.Close()
	logging.AddLog("Système", "Application arrêtée")
}

// getSystemUptime reads system uptime from /proc/uptime
func getSystemUptime() int64 {
	data, err := os.ReadFile("/proc/uptime")
	if err != nil {
		log.Printf("Error reading /proc/uptime: %v", err)
		return 0
	}

	fields := strings.Fields(string(data))
	if len(fields) == 0 {
		return 0
	}

	uptime, err := strconv.ParseFloat(fields[0], 64)
	if err != nil {
		log.Printf("Error parsing uptime: %v", err)
		return 0
	}

	return int64(uptime)
}

// getInterfaceBytes reads rx and tx bytes for a network interface
func getInterfaceBytes(interfaceName string) (rxBytes, txBytes int64) {
	rxPath := "/sys/class/net/" + interfaceName + "/statistics/rx_bytes"
	txPath := "/sys/class/net/" + interfaceName + "/statistics/tx_bytes"

	// Read RX bytes
	rxData, err := os.ReadFile(rxPath)
	if err != nil {
		log.Printf("Error reading rx_bytes for %s: %v", interfaceName, err)
	} else {
		rxBytes, _ = strconv.ParseInt(strings.TrimSpace(string(rxData)), 10, 64)
	}

	// Read TX bytes
	txData, err := os.ReadFile(txPath)
	if err != nil {
		log.Printf("Error reading tx_bytes for %s: %v", interfaceName, err)
	} else {
		txBytes, _ = strconv.ParseInt(strings.TrimSpace(string(txData)), 10, 64)
	}

	return rxBytes, txBytes
}

// periodicStatusUpdate updates WiFi connection status periodically
func (a *App) periodicStatusUpdate() {
	ticker := time.NewTicker(5 * time.Second)
	defer ticker.Stop()

	for range ticker.C {
		a.StatusMutex.Lock()
		a.Status.Connected = wifi.IsConnected()
		a.Status.ConnectionState = wifi.GetConnectionState()
		a.Status.ConnectedSSID = wifi.GetConnectedSSID()
		a.Status.Uptime = getSystemUptime()

		// Get detailed hotspot status
		a.Status.HotspotStatus = hotspot.GetDetailedStatus()

		// Get network data usage for WiFi interface
		if a.Config != nil {
			rxBytes, txBytes := getInterfaceBytes(a.Config.WifiInterface)
			// Convert to MB and sum rx + tx
			a.Status.DataUsage = float64(rxBytes+txBytes) / (1024 * 1024)
		}

		a.StatusMutex.Unlock()
	}
}

// periodicDeviceUpdate updates connected devices list periodically
func (a *App) periodicDeviceUpdate() {
	ticker := time.NewTicker(10 * time.Second)
	defer ticker.Stop()

	for range ticker.C {
		devices, err := device.GetConnectedDevices(a.Config)
		if err != nil {
			log.Printf("Error getting connected devices: %v", err)
			continue
		}

		a.StatusMutex.Lock()
		a.Status.ConnectedDevices = devices
		a.Status.ConnectedCount = len(devices)
		a.StatusMutex.Unlock()
	}
}