package config

import (
	"encoding/json"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"
)

// NetworkChannelsConfig definiert die Konfiguration für automatische Channel-Joins
type NetworkChannelsConfig struct {
	Networks map[string][]string `json:"networks"`
}

// DefaultConfigPath gibt den Standardpfad für die Konfigurationsdatei zurück
func DefaultConfigPath() string {
	homeDir, err := os.UserHomeDir()
	if err != nil {
		return ".xdcc-cli-config.json"
	}
	return filepath.Join(homeDir, ".xdcc-cli-config.json")
}

// LoadConfig lädt die Konfiguration aus einer JSON-Datei
func LoadConfig(configPath string) (*NetworkChannelsConfig, error) {
	// Wenn die Datei nicht existiert, gibt eine leere Konfiguration zurück
	if _, err := os.Stat(configPath); os.IsNotExist(err) {
		return &NetworkChannelsConfig{
			Networks: make(map[string][]string),
		}, nil
	}

	file, err := os.Open(configPath)
	if err != nil {
		return nil, fmt.Errorf("fehler beim Öffnen der Konfigurationsdatei: %v", err)
	}
	defer file.Close()

	data, err := io.ReadAll(file)
	if err != nil {
		return nil, fmt.Errorf("fehler beim Lesen der Konfigurationsdatei: %v", err)
	}

	var config NetworkChannelsConfig
	if err := json.Unmarshal(data, &config); err != nil {
		return nil, fmt.Errorf("fehler beim Parsen der Konfigurationsdatei: %v", err)
	}

	// Initialisiere Networks falls nil
	if config.Networks == nil {
		config.Networks = make(map[string][]string)
	}

	return &config, nil
}

// SaveConfig speichert die Konfiguration in eine JSON-Datei
func SaveConfig(configPath string, config *NetworkChannelsConfig) error {
	data, err := json.MarshalIndent(config, "", "  ")
	if err != nil {
		return fmt.Errorf("fehler beim Serialisieren der Konfiguration: %v", err)
	}

	if err := os.WriteFile(configPath, data, 0644); err != nil {
		return fmt.Errorf("fehler beim Schreiben der Konfigurationsdatei: %v", err)
	}

	return nil
}

// GetChannelsForNetwork gibt die konfigurierten Channels für ein Netzwerk zurück
func (c *NetworkChannelsConfig) GetChannelsForNetwork(network string) []string {
	channels, exists := c.Networks[network]
	if !exists {
		return []string{}
	}
	
	// Stelle sicher, dass alle Channels mit # beginnen
	normalizedChannels := make([]string, len(channels))
	for i, channel := range channels {
		if channel != "" && !strings.HasPrefix(channel, "#") {
			normalizedChannels[i] = "#" + channel
		} else {
			normalizedChannels[i] = channel
		}
	}
	
	return normalizedChannels
}

// AddChannelToNetwork fügt einen Channel zu einem Netzwerk hinzu
func (c *NetworkChannelsConfig) AddChannelToNetwork(network, channel string) {
	if c.Networks == nil {
		c.Networks = make(map[string][]string)
	}
	
	// Normalisiere den Channel-Namen
	if channel != "" && !strings.HasPrefix(channel, "#") {
		channel = "#" + channel
	}
	
	// Prüfe ob der Channel bereits existiert
	for _, existingChannel := range c.Networks[network] {
		if existingChannel == channel {
			return // Channel bereits vorhanden
		}
	}
	
	c.Networks[network] = append(c.Networks[network], channel)
}

// RemoveChannelFromNetwork entfernt einen Channel von einem Netzwerk
func (c *NetworkChannelsConfig) RemoveChannelFromNetwork(network, channel string) {
	if c.Networks == nil {
		return
	}
	
	// Normalisiere den Channel-Namen
	if channel != "" && !strings.HasPrefix(channel, "#") {
		channel = "#" + channel
	}
	
	channels := c.Networks[network]
	for i, existingChannel := range channels {
		if existingChannel == channel {
			// Entferne den Channel aus dem Slice
			c.Networks[network] = append(channels[:i], channels[i+1:]...)
			break
		}
	}
	
	// Entferne das Netzwerk wenn keine Channels mehr vorhanden sind
	if len(c.Networks[network]) == 0 {
		delete(c.Networks, network)
	}
}