package wol

import (
	"encoding/hex"
	"log"
	"net"
	"strings"
)

// Service ist der Wake-on-LAN Service
type Service struct{}

// NewService erstellt einen neuen Wake-on-LAN Service
func NewService() *Service {
	return &Service{}
}

// WakePC sendet ein Wake-on-LAN Paket an die angegebene MAC-Adresse
func (s *Service) WakePC(mac string) error {
	// MAC-Adresse normalisieren
	normalizedMAC := strings.ReplaceAll(mac, ":", "")
	normalizedMAC = strings.ReplaceAll(normalizedMAC, "-", "")

	log.Printf("Versende Wake-on-LAN Paket an MAC: %s", mac)

	// Magic Packet erstellen
	magicPacket, err := s.createMagicPacket(normalizedMAC)
	if err != nil {
		log.Printf("Fehler beim Erstellen des Magic Packets: %v", err)
		return err
	}

	// UDP-Paket senden
	err = s.sendMagicPacket(magicPacket)
	if err != nil {
		log.Printf("Fehler beim Senden des Wake-on-LAN Pakets: %v", err)
		return err
	}

	log.Printf("Wake-on-LAN Paket erfolgreich an %s gesendet", mac)
	return nil
}

// createMagicPacket erstellt ein Wake-on-LAN Magic Packet
func (s *Service) createMagicPacket(mac string) ([]byte, error) {
	// MAC-Adresse in Bytes konvertieren
	macBytes, err := hex.DecodeString(mac)
	if err != nil {
		return nil, err
	}

	// Magic Packet: 6 Bytes 0xFF gefolgt von 16 Wiederholungen der MAC-Adresse
	magicPacket := make([]byte, 102)

	// Erste 6 Bytes mit 0xFF füllen
	for i := 0; i < 6; i++ {
		magicPacket[i] = 0xFF
	}

	// MAC-Adresse 16 mal wiederholen
	for i := 6; i < 102; i += 6 {
		copy(magicPacket[i:i+6], macBytes)
	}

	return magicPacket, nil
}

// sendMagicPacket sendet das Magic Packet über UDP
func (s *Service) sendMagicPacket(magicPacket []byte) error {
	// UDP-Verbindung erstellen
	conn, err := net.Dial("udp", "255.255.255.255:9")
	if err != nil {
		return err
	}
	defer conn.Close()

	// Paket senden
	_, err = conn.Write(magicPacket)
	return err
}

// ValidateMAC prüft, ob die MAC-Adresse gültig ist
func ValidateMAC(mac string) bool {
	// MAC-Adresse bereinigen
	cleanMAC := strings.ReplaceAll(mac, ":", "")
	cleanMAC = strings.ReplaceAll(cleanMAC, "-", "")

	// Länge prüfen (12 Hex-Zeichen)
	if len(cleanMAC) != 12 {
		return false
	}

	// Prüfen, ob alle Zeichen gültige Hexadezimalziffern sind
	_, err := hex.DecodeString(cleanMAC)
	return err == nil
}