server.go

package main

import (
	"bufio"
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"html/template"
	"io/ioutil"
	"math/rand"
	"net"
	"net/http"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"sync/atomic"
	"time"

	"github.com/PuerkitoBio/goquery"
	"github.com/go-redis/redis/v8"
	"github.com/huin/goupnp"
	"github.com/huin/goupnp/dcps/av1"
	"github.com/krisek/gompd/mpd"
	"github.com/robfig/cron/v3"
	"github.com/rs/cors"
	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

var errMPDIdleTimeout = errors.New("mpd idle timeout")
var errResponseSent = errors.New("response already sent")

type FileInfo struct {
	Directory    string                 `json:"directory,omitempty"`
	LastModified string                 `json:"last-modified"`
	Count        map[string]interface{} `json:"count,omitempty"`
	Artist       string                 `json:"artist,omitempty"`
	File         string                 `json:"file,omitempty"`
	Format       string                 `json:"format,omitempty"`
	Time         string                 `json:"time,omitempty"`

	Duration string `json:"duration,omitempty"`
	Genre    string `json:"genre,omitempty"`
	Codec    string `json:"codec,omitempty"`
	Track    string `json:"track,omitempty"`
	Date     string `json:"date,omitempty"`
	Album    string `json:"album,omitempty"`
	Title    string `json:"title,omitempty"`
	Stream   string `json:"stream,omitempty"`
}

var (
	ctx                    = context.Background()
	redisClient            *redis.Client
	bandcampEnabled, _     = strconv.ParseBool(getEnv("AL_BANDCAMP_ENABLED", "true"))
	clientDB               = getEnv("AL_CLIENT_DB", getEnv("HOME", "/tmp")+"/Music/audioloader-db")
	defaultStream          = getEnv("AL_DEFAULT_STREAM", "http://"+os.Getenv("HOST")+":8000/audio.ogg")
	mpdHost                = getEnv("AL_MPD_HOST", "localhost")
	mpdPort                = getEnv("AL_MPD_PORT", "6600")
	listeningPort          = getEnv("AL_LISTENING_PORT", "3400")
	libraryPath            = getEnv("AL_LIBRARY_PATH", getEnv("HOME", "/media")+"/Music")
	logLevel               = getEnv("AL_LOG_LEVEL", "info")
	maxBackoffDuration     = 256 * time.Second // Maximum backoff of 256 seconds
	maxRetryDuration       = 1 * time.Hour     // Total maximum retry duration of 1 hour
	maxConcurrentPolls     = getEnvInt("AL_MAX_CONCURRENT_POLLS", 32)
	bandcampHistorySize, _ = strconv.Atoi(getEnv("AL_BANDCAMP_HISTORY_SIZE", "100"))
	snapcastHost           = getEnv("AL_SNAPCAST_HOST", "localhost")
	sharedMPDConnections   = newMPDConnectionManager()
	pollActiveRequests     int64
	pollTotalRequests      uint64
	pollTimeouts           uint64
	pollIdleEvents         uint64
	pollErrors             uint64
	pollRejectedDuplicate  uint64
	pollRejectedCapacity   uint64
	metricsPollSamples     uint64
	mpdDialAttempts        uint64
	mpdDialFailures        uint64
	mpdDialSuccesses       uint64
	pollLimiterMu          sync.Mutex
	activePollByClient     = make(map[string]struct{})
	pollSlots              = make(chan struct{}, maxConcurrentPolls)
)

type mpdMetricsSnapshot struct {
	PollActiveRequests int64  `json:"poll_active_requests"`
	PollTotalRequests  uint64 `json:"poll_total_requests"`
	PollTimeouts       uint64 `json:"poll_timeouts"`
	PollIdleEvents     uint64 `json:"poll_idle_events"`
	PollErrors         uint64 `json:"poll_errors"`
	PollRejectDuplicate uint64 `json:"poll_reject_duplicate"`
	PollRejectCapacity  uint64 `json:"poll_reject_capacity"`
	PollSlotCapacity    int    `json:"poll_slot_capacity"`
	PollSlotInUse       int    `json:"poll_slot_in_use"`
	MPDDialAttempts    uint64 `json:"mpd_dial_attempts"`
	MPDDialFailures    uint64 `json:"mpd_dial_failures"`
	MPDDialSuccesses   uint64 `json:"mpd_dial_successes"`
	Goroutines         int    `json:"goroutines"`
}

func getMPDMetricsSnapshot() mpdMetricsSnapshot {
	return mpdMetricsSnapshot{
		PollActiveRequests: atomic.LoadInt64(&pollActiveRequests),
		PollTotalRequests:  atomic.LoadUint64(&pollTotalRequests),
		PollTimeouts:       atomic.LoadUint64(&pollTimeouts),
		PollIdleEvents:     atomic.LoadUint64(&pollIdleEvents),
		PollErrors:         atomic.LoadUint64(&pollErrors),
		PollRejectDuplicate: atomic.LoadUint64(&pollRejectedDuplicate),
		PollRejectCapacity:  atomic.LoadUint64(&pollRejectedCapacity),
		PollSlotCapacity:    cap(pollSlots),
		PollSlotInUse:       len(pollSlots),
		MPDDialAttempts:    atomic.LoadUint64(&mpdDialAttempts),
		MPDDialFailures:    atomic.LoadUint64(&mpdDialFailures),
		MPDDialSuccesses:   atomic.LoadUint64(&mpdDialSuccesses),
		Goroutines:         runtime.NumGoroutine(),
	}
}

func maybeLogPollMetricsSnapshot() {
	sample := atomic.AddUint64(&metricsPollSamples, 1)
	if sample%50 != 0 {
		return
	}

	snapshot := getMPDMetricsSnapshot()
	log.Info().
		Str("function", "pollCurrentSongHandler").
		Int64("poll_active_requests", snapshot.PollActiveRequests).
		Uint64("poll_total_requests", snapshot.PollTotalRequests).
		Uint64("poll_timeouts", snapshot.PollTimeouts).
		Uint64("poll_idle_events", snapshot.PollIdleEvents).
		Uint64("poll_errors", snapshot.PollErrors).
		Uint64("poll_reject_duplicate", snapshot.PollRejectDuplicate).
		Uint64("poll_reject_capacity", snapshot.PollRejectCapacity).
		Int("poll_slot_capacity", snapshot.PollSlotCapacity).
		Int("poll_slot_in_use", snapshot.PollSlotInUse).
		Uint64("mpd_dial_attempts", snapshot.MPDDialAttempts).
		Uint64("mpd_dial_failures", snapshot.MPDDialFailures).
		Uint64("mpd_dial_successes", snapshot.MPDDialSuccesses).
		Int("goroutines", snapshot.Goroutines).
		Msg("MPD poll metrics snapshot")
}

func pollClientKey(r *http.Request) string {
	if clientID := r.URL.Query().Get("client_id"); clientID != "" {
		return "client_id:" + clientID
	}

	ip := r.Header.Get("X-Forwarded-For")
	if ip == "" {
		ip = r.Header.Get("X-Real-IP")
	}
	if ip == "" {
		host, _, err := net.SplitHostPort(r.RemoteAddr)
		if err != nil {
			ip = r.RemoteAddr
		} else {
			ip = host
		}
	} else {
		parts := strings.Split(ip, ",")
		ip = strings.TrimSpace(parts[0])
	}

	return ip + "|" + r.UserAgent()
}

func tryAcquireClientPoll(key string) bool {
	pollLimiterMu.Lock()
	defer pollLimiterMu.Unlock()

	if _, exists := activePollByClient[key]; exists {
		return false
	}
	activePollByClient[key] = struct{}{}
	return true
}

func releaseClientPoll(key string) {
	pollLimiterMu.Lock()
	defer pollLimiterMu.Unlock()
	delete(activePollByClient, key)
}

func tryAcquirePollSlot() bool {
	select {
	case pollSlots <- struct{}{}:
		return true
	default:
		return false
	}
}

func releasePollSlot() {
	select {
	case <-pollSlots:
	default:
	}
}

func mpdMetricsHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	_ = json.NewEncoder(w).Encode(getMPDMetricsSnapshot())
}

type managedMPDConn struct {
	mu     sync.Mutex
	host   string
	port   string
	client *mpd.Client
}

type mpdConnectionManager struct {
	mu    sync.Mutex
	conns map[string]*managedMPDConn
}

func newMPDConnectionManager() *mpdConnectionManager {
	return &mpdConnectionManager{conns: make(map[string]*managedMPDConn)}
}

func normalizeMPDPort(port string) string {
	if port == "" {
		return mpdPort
	}
	return port
}

func (m *mpdConnectionManager) getConn(host, port, purpose string) *managedMPDConn {
	normalizedPort := normalizeMPDPort(port)
	key := fmt.Sprintf("%s:%s|%s", host, normalizedPort, purpose)

	m.mu.Lock()
	defer m.mu.Unlock()

	conn, ok := m.conns[key]
	if !ok {
		conn = &managedMPDConn{host: host, port: normalizedPort}
		m.conns[key] = conn
	}

	return conn
}

func isMPDConnectionError(err error) bool {
	if err == nil {
		return false
	}

	if errors.Is(err, errMPDIdleTimeout) {
		return true
	}

	msg := strings.ToLower(err.Error())
	return strings.Contains(msg, "connection") ||
		strings.Contains(msg, "broken pipe") ||
		strings.Contains(msg, "reset by peer") ||
		strings.Contains(msg, "eof") ||
		strings.Contains(msg, "closed network")
}

func (m *mpdConnectionManager) withClient(host, port, purpose string, fn func(*mpd.Client) error) error {
	conn := m.getConn(host, port, purpose)

	conn.mu.Lock()
	defer conn.mu.Unlock()

	if conn.client == nil {
		retryBudget := maxRetryDuration
		if purpose == "poll-idle" {
			// Long-poll should fail fast and retry on the next HTTP poll request.
			retryBudget = 10 * time.Second
		}

		client, err := getMPDClientWithRetry(conn.host, conn.port, retryBudget)
		if err != nil {
			return err
		}
		conn.client = client
	}

	err := fn(conn.client)
	if err != nil && isMPDConnectionError(err) {
		_ = conn.client.Close()
		conn.client = nil
	}

	return err
}

func withRequestMPDClient(r *http.Request, purpose string, fn func(*mpd.Client) error) error {
	return sharedMPDConnections.withClient(mpdHost, r.URL.Query().Get("mpd_port"), purpose, fn)
}

// Helper function to get environment variables with a default value
func getEnv(key, defaultVal string) string {
	if value, exists := os.LookupEnv(key); exists {
		return value
	}
	return defaultVal
}

func getEnvInt(key string, defaultVal int) int {
	value := getEnv(key, strconv.Itoa(defaultVal))
	parsed, err := strconv.Atoi(value)
	if err != nil || parsed <= 0 {
		return defaultVal
	}
	return parsed
}

// getMPDClient creates a new MPD client connection using the provided host and port.
// It retries the connection in case of failure with an exponential backoff strategy.
func getMPDClient(host string, port string) (*mpd.Client, error) {
	return getMPDClientWithRetry(host, port, maxRetryDuration)
}

func getMPDClientWithRetry(host string, port string, maxTotalRetry time.Duration) (*mpd.Client, error) {
	if port == "" {
		port = mpdPort
	}
	address := fmt.Sprintf("%s:%s", host, port)

	var backoff time.Duration = 1 * time.Second
	var totalWaitTime time.Duration

	for {
		atomic.AddUint64(&mpdDialAttempts, 1)
		client, err := mpd.Dial("tcp", address)
		if err == nil {
			atomic.AddUint64(&mpdDialSuccesses, 1)
			// Success! Return the client
			return client, nil
		}
		atomic.AddUint64(&mpdDialFailures, 1)

		// Log the error
		log.Printf("Failed to connect to MPD server at %s: %v. Retrying in %v...", address, err, backoff)

		// Check if we've exceeded the maximum retry duration
		totalWaitTime += backoff
		if totalWaitTime >= maxTotalRetry {
			return nil, fmt.Errorf("could not connect to MPD server after multiple retries: %w", err)
		}

		// Sleep for the current backoff duration
		time.Sleep(backoff)

		// Increase the backoff time (exponential backoff)
		backoff *= 2
		if backoff > maxBackoffDuration {
			backoff = maxBackoffDuration // Cap the backoff at the max duration
		}
	}
}

func main() {

	// Configure zerolog
	var level zerolog.Level
	switch logLevel {
	case "debug":
		level = zerolog.DebugLevel
	case "info":
		level = zerolog.InfoLevel
	case "warn":
		level = zerolog.WarnLevel
	case "error":
		level = zerolog.ErrorLevel
	default:
		level = zerolog.WarnLevel
	}

	log.Logger = zerolog.New(zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: "2006-01-02 15:04:05"}).
		Level(level).With().
		Timestamp().
		Logger()

	// Initialize Redis client
	redisClient = redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
		DB:   0,
	})

	// Initialize Cron scheduler
	c := cron.New()
	c.Start()

	fs := http.FileServer(http.Dir("./static"))
	http.Handle("/static/", http.StripPrefix("/static/", fs))

	// Set up HTTP routes
	http.HandleFunc("/cover", coverHandler)
	http.HandleFunc("/kodi", kodiHandler)
	http.HandleFunc("/upnp", upnpHandler)
	http.HandleFunc("/generate_randomset", generateRandomSetHandler)
	http.HandleFunc("/remove_favourite", favouritesHandler)
	http.HandleFunc("/add_favourite", favouritesHandler)
	http.HandleFunc("/active_players", activePlayersHandler)
	http.HandleFunc("/radio_history", radioHistoryHandler)
	http.HandleFunc("/bandcamp_history", bandcampHistoryHandler)
	http.HandleFunc("/history", dataHandler)
	http.HandleFunc("/randomset", dataHandler)
	http.HandleFunc("/favourites", dataHandler)
	http.HandleFunc("/search_radio", searchRadioHandler)
	http.HandleFunc("/search_bandcamp", searchBandcampHandler)
	http.HandleFunc("/remove_history", removeHistoryHandler)
	http.HandleFunc("/listfiles", mpdProxyHandler)
	http.HandleFunc("/lsinfo", mpdProxyHandler)
	http.HandleFunc("/ls", mpdProxyHandler)
	http.HandleFunc("/search", mpdProxyHandler)
	http.HandleFunc("/addplay", mpdProxyHandler)
	http.HandleFunc("/play", mpdProxyHandler)
	http.HandleFunc("/pause", mpdProxyHandler)
	http.HandleFunc("/playpause", mpdProxyHandler)
	http.HandleFunc("/next", mpdProxyHandler)
	http.HandleFunc("/prev", mpdProxyHandler)
	http.HandleFunc("/stop", mpdProxyHandler)
	http.HandleFunc("/status", mpdProxyHandler)
	http.HandleFunc("/poll_currentsong", pollCurrentSongHandler)
	http.HandleFunc("/currentsong", currentSongHandler)
	http.HandleFunc("/count", countHandler)
	http.HandleFunc("/toggleoutput", toggleOutputHandler)
	http.HandleFunc("/debug/mpd_metrics", mpdMetricsHandler)
	http.HandleFunc("/snapcastclients", getSnapcastClientsHandler)
	http.HandleFunc("/togglesnapcastclient", toggleSnapcastClientHandler)
	http.HandleFunc("/", catchAllHandler)

	// Enable CORS
	handler := cors.Default().Handler(http.DefaultServeMux)

	// Start HTTP server
	log.Info().Str("function", "main").Msg(fmt.Sprintf("Starting server on: http://localhost:%v/", listeningPort))
	http.ListenAndServe(":"+listeningPort, handler)
	// log.Fatal()
}

func coverHandler(w http.ResponseWriter, r *http.Request) {
	directory := r.URL.Query().Get("directory")
	log.Debug().Str("function", "coverHandler").Msg(fmt.Sprintf("Getting cover for: %s", directory))

	responseType := r.URL.Query().Get("response_type")
	if responseType == "" {
		responseType = "direct"
	}
	cover := "vinyl.webp"

	// Connect to Redis
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password set
		DB:       0,  // use default DB
	})

	ctx := context.Background()

	// Attempt to get the cover from Redis
	val, err := rdb.Get(ctx, "audioloader:cover:"+directory).Result()
	if err == redis.Nil {
		cover = "vinyl.webp"
	} else if err != nil {
		log.Debug().Str("function", "coverHandler").Msg(fmt.Sprintf("Redis error: %v", err))
		cover = "vinyl.webp"
	} else {
		cover = val
		log.Debug().Str("function", "coverHandler").Msg(fmt.Sprintf("Got cover from Redis: %s", cover))
	}

	// If the cover is not found, search the MPD directory
	if cover == "vinyl.webp" || cover == "" {
		var dirContent []mpd.Attrs
		err := withRequestMPDClient(r, "default", func(mpdClient *mpd.Client) error {
			var listErr error
			dirContent, listErr = mpdClient.ListFiles(directory)
			return listErr
		})

		if err != nil {
			log.Debug().Str("function", "coverHandler").Msg(fmt.Sprintf("Error listing files: %v", err))
			http.Error(w, "Failed to list files", http.StatusInternalServerError)
			return
		}

		imagePattern := regexp.MustCompile(`\.(jpg|jpeg|png|gif)$`)
		coverPattern := regexp.MustCompile(`(?i)folder|cover|front`)

		images := []string{}
		for _, fileData := range dirContent {
			file := fileData["file"]
			if imagePattern.MatchString(file) {
				images = append(images, file)
			}
		}

		log.Debug().Str("function", "coverHandler").Msg(fmt.Sprintf("Found images: %v", images))
		for _, image := range images {
			if coverPattern.MatchString(image) {
				cover = image
				break
			}
		}

		if cover == "vinyl.webp" && len(images) > 0 {
			cover = images[0]
		}

		log.Debug().Str("function", "coverHandler").Msg(fmt.Sprintf("Selected cover: %s", cover))

		// Save the cover in Redis
		if err := rdb.Set(ctx, "audioloader:cover:"+directory, cover, 0).Err(); err != nil {
			log.Debug().Str("function", "coverHandler").Msg(fmt.Sprintf("Error setting cover in Redis: %v", err))
		}
	}

	// Determine response
	if responseType == "redirect" {
		var fullPath string
		if cover == "vinyl.webp" {
			fullPath = "/static/assets/vinyl.webp"
		} else {
			fullPath = "/music" + "/" + directory + "/" + cover
		}
		http.Redirect(w, r, fullPath, http.StatusFound)
	} else {
		var coverPath string
		if cover == "vinyl.webp" {
			coverPath = "./static/assets/vinyl.webp"
		} else {
			coverPath = filepath.Join(libraryPath, directory, cover)
		}
		if _, err := os.Stat(coverPath); os.IsNotExist(err) {
			log.Debug().Str("function", "coverHandler").Msg(fmt.Sprintf("Cover not found, falling back to default: %v", coverPath))
			coverPath = "./static/assets/vinyl.webp"
		}
		log.Debug().Str("function", "coverHandler").Msg(fmt.Sprintf("Serving cover: %v", coverPath))
		http.ServeFile(w, r, coverPath)
	}
}

type ClientData struct {
	History         []string               `json:"history,omitempty"`
	Randomset       []string               `json:"randomset,omitempty"`
	Favourites      []string               `json:"favourites,omitempty"`
	RadioHistory    []string               `json:"radio_history,omitempty"`
	BandcampHistory []string               `json:"bandcamp_history,omitempty"`
	Stations        map[string]StationData `json:"stations,omitempty"`
	Links           map[string]LinkData    `json:"links,omitempty"`
}

// StationData holds individual radio station info.
type StationData struct {
	URL         string `json:"url"`
	StationUUID string `json:"stationuuid"`
	Name        string `json:"name"`
	Favicon     string `json:"favicon"`
}

// LinkData holds individual bandcamp album info.
type LinkData struct {
	URL     string `json:"url"`
	Title   string `json:"title"`
	Favicon string `json:"favicon"`
	Artist  string `json:"artist"`
	Date    string `json:"date"`
}

// readData reads the client's data from a JSON file.
// readData reads client data from a JSON file and returns a ClientData struct.
func readData(clientID string, dataType string) (ClientData, error) {
	// Construct the file path
	clientDataFile := filepath.Join(clientDB, fmt.Sprintf("%s.%s.json", clientID, dataType))

	// Validate clientID and file path
	if clientID == "" || !filepath.HasPrefix(clientDataFile, clientDB) {
		return ClientData{}, fmt.Errorf("invalid clientID or file path")
	}

	// Check for invalid characters in the clientID
	if !regexp.MustCompile(`^[A-Za-z0-9_\-\.]+$`).MatchString(clientID) {
		return ClientData{}, fmt.Errorf("invalid characters in clientID")
	}

	// Read the file
	data, err := ioutil.ReadFile(clientDataFile)
	if err != nil {
		log.Debug().Str("function", "readData").Msg(fmt.Sprintf("Error %s for %s not readable: %v\n", dataType, clientID, err))
		return ClientData{}, fmt.Errorf("not readable")
	}

	// Unmarshal JSON into ClientData struct
	var clientdata ClientData
	if err := json.Unmarshal(data, &clientdata); err != nil {
		log.Debug().Str("function", "readData").Msg(fmt.Sprintf("Error parsing JSON for %s: %v\n", clientID, err))
		return ClientData{}, fmt.Errorf("Cannot encode")
	}

	return clientdata, nil
}

func reverse(s []map[string]interface{}) []map[string]interface{} {
	a := make([]map[string]interface{}, len(s))
	for i, v := range s {
		a[len(s)-1-i] = v
	}
	return a
}

func getRadioStationURL(stationUUID string) string {
	// Placeholder for pyradios implementation
	// Replace this with the actual implementation later
	return ""
}

func kodiHandler(w http.ResponseWriter, r *http.Request) {
	// Implement Kodi handler
}

// Define constants or use environment/config variables as needed
var defaultStreamURL = "http://localhost:8000/audio.ogg"

// upnpHandler manages both UPnP and MPD control
func upnpHandler(w http.ResponseWriter, r *http.Request) {
	server := r.URL.Query().Get("server")
	if server == "" || server == "undefined" {
		json.NewEncoder(w).Encode(map[string]string{"result": "no server given"})
		return
	}

	action := r.URL.Query().Get("action")
	if action == "" {
		action = "Player.Stop"
	}
	streamURL := r.URL.Query().Get("stream")
	if streamURL == "" {
		streamURL = defaultStreamURL
	}

	if strings.Contains(server, "upnp") || strings.Contains(server, "xml") {
		// Handle UPnP device actions
		err := handleUPnP(server, action, streamURL)
		if err != nil {
			log.Debug().Str("function", "upnpHandler").Msg(fmt.Sprintf("UPnP Error: %v", err))
			json.NewEncoder(w).Encode(map[string]string{"result": "load failed"})
			return
		}
	} else if strings.Contains(server, "_6600") {
		// Handle MPD device actions
		err := handleMPD(server, action, streamURL)
		if err != nil {
			log.Debug().Str("function", "upnpHandler").Msg(fmt.Sprintf("MPD Error: %v", err))
			json.NewEncoder(w).Encode(map[string]string{"result": "load failed"})
			return
		}
	} else {
		// No matching device type
		json.NewEncoder(w).Encode(map[string]string{"result": "unsupported server"})
		return
	}

	// Success response
	json.NewEncoder(w).Encode(map[string]string{"result": "loaded"})
}

// handleUPnP controls UPnP devices using the AVTransport service
func handleUPnP(server, action, streamURL string) error {
	// Parse the server URL
	parsedURL, err := url.Parse(server)
	if err != nil {
		return fmt.Errorf("failed to parse server URL: %v", err)
	}

	// Discover and connect to the UPnP device
	device, err := goupnp.DeviceByURL(parsedURL)
	if err != nil {
		return fmt.Errorf("failed to discover UPnP device: %v", err)
	}

	// Parse the device's URLBase into *url.URL
	deviceURL, err := url.Parse(device.URLBase.String())
	if err != nil {
		return fmt.Errorf("failed to parse device URLBase: %v", err)
	}

	// Access the AVTransport service
	transport, err := av1.NewAVTransport1ClientsByURL(deviceURL)
	if err != nil || len(transport) == 0 {
		return fmt.Errorf("failed to connect to AVTransport service: %v", err)
	}

	client := transport[0] // Assuming there is at least one transport client

	// Perform action based on the provided action string
	switch action {
	case "Player.Open":
		// Set the URI for playback and start playing
		err := client.SetAVTransportURI(0, streamURL, "Audioloader")
		if err != nil {
			return fmt.Errorf("failed to set AVTransport URI: %v", err)
		}
		err = client.Play(0, "1")
		if err != nil {
			return fmt.Errorf("failed to start playback: %v", err)
		}
	default:
		// Stop playback
		err := client.Stop(0)
		if err != nil {
			return fmt.Errorf("failed to stop playback: %v", err)
		}
	}

	return nil
}

// handleMPD controls MPD servers
func handleMPD(server, action, streamURL string) error {
	// Parse MPD host and port
	mpdHostPort := strings.Split(server, "_")
	if len(mpdHostPort) != 2 {
		return fmt.Errorf("invalid MPD server format")
	}
	mpdHost := mpdHostPort[0]
	mpdPort := mpdHostPort[1]

	// Get MPD client
	err := sharedMPDConnections.withClient(mpdHost, mpdPort, "default", func(mpdClient *mpd.Client) error {
		switch action {
		case "Player.Open":
			err := mpdClient.Clear()
			if err != nil {
				return fmt.Errorf("failed to clear playlist: %v", err)
			}
			err = mpdClient.Add(streamURL)
			if err != nil {
				return fmt.Errorf("failed to add stream to playlist: %v", err)
			}
			err = mpdClient.Play(-1)
			if err != nil {
				return fmt.Errorf("failed to start playback: %v", err)
			}
		default:
			err := mpdClient.Stop()
			if err != nil {
				return fmt.Errorf("failed to stop playback: %v", err)
			}
		}

		return nil
	})
	if err != nil {
		return fmt.Errorf("failed to connect to MPD: %v", err)
	}

	return nil
}

func randomChoice(albums []string, k int) []string {
	n := len(albums)
	if k >= n {
		k = n
	}
	shuffled := make([]string, n)
	copy(shuffled, albums)
	rand.Shuffle(n, func(i, j int) { shuffled[i], shuffled[j] = shuffled[j], shuffled[i] })
	return shuffled[:k]
}

func uniqueStrings(input []string) []string {
	uniqueMap := make(map[string]bool)
	var result []string
	for _, item := range input {
		if _, exists := uniqueMap[item]; !exists {
			uniqueMap[item] = true
			result = append(result, item)
		}
	}
	return result
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func isValidFileName(fileName string) bool {
	return regexp.MustCompile(`^[A-Za-z0-9_\-\.\/]+$`).MatchString(fileName)
}

func generateRandomSet(w http.ResponseWriter, r *http.Request) bool {
	clientID := r.URL.Query().Get("client_id")

	filter := r.URL.Query().Get("set_filter")
	clientData := ClientData{Randomset: []string{}}
	artists := make(map[string]bool)
	err := withRequestMPDClient(r, "default", func(mpdClient *mpd.Client) error {
		albums, listErr := mpdClient.List("album")
		if listErr != nil {
			return listErr
		}

		rand.Seed(time.Now().UnixNano()) // Seed for randomness

		for i := 0; len(clientData.Randomset) < 12 && i < 20; i++ {
			randomAlbums := randomChoice(albums, 12) // Get 12 random albums

			for _, album := range randomAlbums {
				albumData, searchErr := mpdClient.Search("album", album)
				if searchErr != nil {
					log.Debug().Str("function", "").Msg(fmt.Sprintf("Error searching album %s: %v\n", album, searchErr))
					continue
				}

				if len(albumData) == 0 {
					continue
				}

				artist := albumData[0]["Artist"]
				if _, exists := artists[artist]; exists {
					continue
				}

				if filter == "" || !regexp.MustCompile(filter).MatchString(albumData[0]["file"]) {
					clientData.Randomset = append(clientData.Randomset, filepath.Dir(albumData[0]["file"]))
					artists[artist] = true
				}
			}
		}

		return nil
	})
	if err != nil {
		log.Debug().Str("function", "generateRandomSet").Msg(fmt.Sprintf("Error listing albums: %v\n", err))
		http.Error(w, "failed to generate randomset", http.StatusInternalServerError)
		return false
	}

	// Ensure randomset has unique albums and limit to 12
	clientData.Randomset = uniqueStrings(clientData.Randomset)[:min(12, len(clientData.Randomset))]
	log.Debug().Str("function", "generateRandomSet").Msg(fmt.Sprintf("clientdata unique - %v", clientData.Randomset))

	// Save to file
	clientDataFile := filepath.Join(clientDB, fmt.Sprintf("%s.randomset.json", clientID))

	log.Debug().Str("function", "generateRandomSet").Msg(fmt.Sprintf("clientDataFile - %v", clientDataFile))
	log.Debug().Str("function", "generateRandomSet").Msg(fmt.Sprintf("filepath.HasPrefix(clientDataFile, clientDB)- %v %v", filepath.HasPrefix(clientDataFile, clientDB), isValidFileName(clientDataFile)))
	if clientID != "" && filepath.HasPrefix(clientDataFile, clientDB) && isValidFileName(clientDataFile) {
		file, err := os.Create(clientDataFile)
		log.Debug().Str("function", "generateRandomSet").Msg(fmt.Sprintf("clientDataFile created %v", clientDataFile))
		if err != nil {
			log.Debug().Str("function", "generateRandomSet").Msg(fmt.Sprintf("Error writing randomset file: %v\n", err))
			http.Error(w, "failed to save randomset", http.StatusInternalServerError)
			return false
		}
		defer file.Close()

		encoder := json.NewEncoder(file)
		if err := encoder.Encode(clientData); err != nil {
			log.Debug().Str("function", "generateRandomSet").Msg(fmt.Sprintf("Error encoding JSON: %v\n", err))
			http.Error(w, "failed to save randomset", http.StatusInternalServerError)
			return false
		}
	}
	return true

}

func generateRandomSetHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	if generateRandomSet(w, r) {
		w.Write([]byte(`{"result": "ok"}`))
	} else {
		w.Write([]byte(`{"result": "nok"}`))
	}

}

// WriteData writes client data to a formatted JSON file.
func writeData(clientID, dataType string, clientData ClientData) error {
	clientDataFile := filepath.Join(clientDB, fmt.Sprintf("%s.%s.json", clientID, dataType))

	if clientID == "" || !filepath.HasPrefix(clientDataFile, clientDB) {
		return fmt.Errorf("invalid clientID or file path")
	}

	if !regexp.MustCompile(`^[A-Za-z0-9_\-\.]+$`).MatchString(clientID) {
		return fmt.Errorf("invalid characters in clientID")
	}

	// Use json.MarshalIndent to write formatted (indented) JSON
	data, err := json.MarshalIndent(clientData, "", "    ") // 4-space indentation
	if err != nil {
		return err
	}

	return os.WriteFile(clientDataFile, data, 0644)
}

// FavouritesHandler handles adding or removing favourites.
func favouritesHandler(w http.ResponseWriter, r *http.Request) {
	clientID := r.URL.Query().Get("client_id")
	if clientID == "" {
		http.Error(w, "client_id is required", http.StatusBadRequest)
		return
	}

	directory := r.URL.Query().Get("directory")
	if directory == "" {
		directory = "."
	}

	// Read existing favourites data
	clientData, err := readData(clientID, "favourites")
	if err != nil {
		log.Error().Str("function", "favouritesHandler").Msg(fmt.Sprintf("readData failed for favourites %s: %v\n", clientID, err))
		// http.Error(w, "Failed to load favourites", http.StatusInternalServerError)
		// return
	}

	if clientData.Favourites == nil {
		clientData.Favourites = []string{}
	}

	// Handle adding or removing favourite
	path := r.URL.Path
	if path == "/add_favourite" {
		if !contains(clientData.Favourites, directory) {
			clientData.Favourites = append(clientData.Favourites, directory)
		}
	} else if path == "/remove_favourite" {
		clientData.Favourites = remove(clientData.Favourites, directory)
	} else {
		http.Error(w, "Invalid endpoint", http.StatusBadRequest)
		return
	}

	// Write updated data back to the file
	if err := writeData(clientID, "favourites", clientData); err != nil {
		log.Error().Str("function", "favouritesHandler").Msg(fmt.Sprintf("writeData failed for favourites %s: %v\n", clientID, err))
		http.Error(w, "Failed to save favourites", http.StatusInternalServerError)
		return
	}

	// Respond with success
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]string{"result": "ok"})
}

// Helper function to check if a slice contains a specific item
func contains(slice []string, item string) bool {
	for _, a := range slice {
		if a == item {
			return true
		}
	}
	return false
}

// Helper function to remove an item from a slice
func remove(slice []string, item string) []string {
	for i, a := range slice {
		if a == item {
			return append(slice[:i], slice[i+1:]...)
		}
	}
	return slice
}

// ActivePlayersHandler handles requests to retrieve active players
func activePlayersHandler(w http.ResponseWriter, r *http.Request) {
	players := getActivePlayers()

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(players)
}

func radioHistoryHandler(w http.ResponseWriter, r *http.Request) {
	clientID := r.URL.Query().Get("client_id")
	if clientID == "" {
		http.Error(w, "client_id is required", http.StatusBadRequest)
		return
	}

	clientData, err := readData(clientID, "radio_history")
	if err != nil {
		log.Error().Str("function", "radioHistoryHandler").Msg(fmt.Sprintf("readData failed for radio_history %s: %v\n", clientID, err))
		json.NewEncoder(w).Encode(map[string]interface{}{
			"tree": []interface{}{},
			"info": map[string]interface{}{},
		})
		return
	}

	// Return the clientData in JSON format
	w.Header().Set("Content-Type", "application/json")
	if err := json.NewEncoder(w).Encode(clientData); err != nil {
		log.Error().Str("function", "radioHistoryHandler").Msg(fmt.Sprintf("Failed to encode radio history data for %s: %v\n", clientID, err))
		json.NewEncoder(w).Encode(map[string]interface{}{
			"tree": []interface{}{},
			"info": map[string]interface{}{},
		})
		return
	}
}

func bandcampHistoryHandler(w http.ResponseWriter, r *http.Request) {
	clientID := r.URL.Query().Get("client_id")
	if clientID == "" {
		http.Error(w, "client_id is required", http.StatusBadRequest)
		return
	}

	clientData, err := readData(clientID, "bandcamp_history")
	w.Header().Set("Content-Type", "application/json")

	if err != nil {
		log.Error().Str("function", "bandcampHistoryHandler").Msg(fmt.Sprintf("readData failed for bandcamp_history %s: %v\n", clientID, err))
		// http.Error(w, "Failed to load bandcamp history", http.StatusInternalServerError)
		// return
		json.NewEncoder(w).Encode(map[string]interface{}{
			"tree": []interface{}{},
			"info": map[string]interface{}{},
		})
		return
	}

	// Return the clientData in JSON format

	if err := json.NewEncoder(w).Encode(clientData); err != nil {
		log.Error().Str("function", "bandcampHistoryHandler").Msg(fmt.Sprintf("Failed to encode bandcamp history data for %s: %v\n", clientID, err))
		json.NewEncoder(w).Encode(map[string]interface{}{
			"tree": []interface{}{},
			"info": map[string]interface{}{},
		})
		// http.Error(w, "Failed to encode data", http.StatusInternalServerError)
		return
	}
}

func isHTTP(s string) bool {
	return strings.HasPrefix(s, "http:")
}

func formatPlaytime(playtime int) string {
	hours := playtime / 3600
	minutes := (playtime % 3600) / 60
	seconds := playtime % 60
	var playhours string
	if playtime < 3600 {
		// Omit the hour if it's less than an hour
		playhours = fmt.Sprintf("%v:%v", minutes, seconds)
	} else {
		// Include the hour
		playhours = fmt.Sprintf("%v:%v:%v", hours, minutes, seconds)
	}
	return playhours
}

func capitalizeFirstLetter(s string) string {
	if len(s) == 0 {
		return s
	}
	// Capitalize the first letter and append the rest of the string
	return strings.ToUpper(string(s[0])) + s[1:]
}

func dataHandler(w http.ResponseWriter, r *http.Request) {
	clientDataTree := map[string]interface{}{
		"tree": []interface{}{},
		"info": map[string]interface{}{},
	}

	clientID := r.URL.Query().Get("client_id")
	dataPath := r.URL.Path[1:]

	log.Debug().Str("function", "dataHandler").Msg(fmt.Sprintf("%v - %v", clientID, dataPath))

	// Read the data based on the path (history, randomset, etc.)
	ClientData, err := readData(clientID, dataPath)
	if err != nil {
		log.Error().Str("function", "dataHandler").Msg(fmt.Sprintf("readData failed %s: %v\n", clientID, err))
	}

	// Function to process the data for any string slice (History, Randomset, etc.)
	processDirectories := func(directories []string) []FileInfo {
		var fileInfos []FileInfo
		err := withRequestMPDClient(r, "default", func(mpdClient *mpd.Client) error {
			for _, directory := range directories {
				log.Debug().Str("function", "dataHandler").Msg(fmt.Sprintf("processing %v", directory))
				directoryStr := directory

				// If it's not a root or HTTP directory
				if directoryStr != "/" && !isHTTP(directoryStr) {
					count, countErr := mpdClient.Count("base", directoryStr)
					if countErr != nil {
						log.Debug().Str("function", "dataHandler").Msg(fmt.Sprintf("Could not get count for %s: %v\n", directoryStr, countErr))
						continue
					}
					seconds, _ := strconv.Atoi(count[1])

					fileInfo := FileInfo{
						Directory: directoryStr,
						Count: map[string]interface{}{
							"playhours": formatPlaytime(seconds),
							"playtime":  count[1],
							"songs":     count[0],
						},
					}
					fileInfos = append(fileInfos, fileInfo)
				} else if isHTTP(directoryStr) {
					// Handle HTTP directory
					fileInfo := FileInfo{
						Directory: directoryStr,
						Stream:    directoryStr,
					}
					fileInfos = append(fileInfos, fileInfo)
				}
			}
			return nil
		})
		if err != nil {
			log.Debug().Str("function", "dataHandler").Msg(fmt.Sprintf("Could not use MPD client: %v\n", err))
		}

		// Reverse the fileInfos slice
		for i, j := 0, len(fileInfos)-1; i < j; i, j = i+1, j-1 {
			fileInfos[i], fileInfos[j] = fileInfos[j], fileInfos[i]
		}
		return fileInfos
	}

	// Process different fields in ClientData
	var fileInfos []FileInfo

	// Check if History has data and process it
	if len(ClientData.History) > 0 {
		fileInfos = append(fileInfos, processDirectories(ClientData.History)...)
	}

	if dataPath == "randomset" && len(ClientData.Randomset) == 0 {
		generateRandomSet(w, r)
		dataHandler(w, r)
		return
	}

	// Check if Randomset has data and process it
	if len(ClientData.Randomset) > 0 {
		fileInfos = append(fileInfos, processDirectories(ClientData.Randomset)...)
	}

	// Check if Favourites has data and process it
	if len(ClientData.Favourites) > 0 {
		fileInfos = append(fileInfos, processDirectories(ClientData.Favourites)...)
	}

	// Assign the processed fileInfos to the tree
	clientDataTree["tree"] = fileInfos

	// Write the response
	json.NewEncoder(w).Encode(clientDataTree)
}

type RadioStation struct {
	Name    string `json:"name"`
	Favicon string `json:"favicon"`
	Bitrate int    `json:"bitrate"`
	UUID    string `json:"stationuuid"`
	Url     string `json:"url"`
}

type Content struct {
	Tree []RadioStation `json:"tree"`
}

func searchRadioHandler(w http.ResponseWriter, r *http.Request) {
	content := Content{Tree: []RadioStation{}}
	pattern := r.URL.Query().Get("pattern")

	if len(pattern) < 3 {
		json.NewEncoder(w).Encode(content)
		return
	}

	client := &http.Client{Timeout: 10 * time.Second}
	url := fmt.Sprintf("https://de1.api.radio-browser.info/json/stations/search?name=%s&name_exact=false", pattern)

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		log.Error().Str("function", "searchRadioHandler").Msg(fmt.Sprintf("Error creating request: %v", err))
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return
	}

	resp, err := client.Do(req)
	if err != nil {
		log.Debug().Str("function", "").Msg(fmt.Sprintf("Error making request to Radio Browser API: %v", err))
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		log.Error().Str("function", "searchRadioHandler").Msg(fmt.Sprintf("API responded with status code: %v", resp.StatusCode))
		http.Error(w, "Failed to fetch radio stations", http.StatusBadRequest)
		return
	}
	log.Debug().Str("function", "searchRadioHandler").Msg(fmt.Sprintf("radio stations: %s", resp.Body))
	var stations []RadioStation
	if err := json.NewDecoder(resp.Body).Decode(&stations); err != nil {
		log.Error().Str("function", "searchRadioHandler").Msg(fmt.Sprintf("Error decoding response: %v", err))
		http.Error(w, "Failed to process response", http.StatusInternalServerError)
		return
	}

	// Filter and modify stations as necessary
	for _, station := range stations {
		if station.Name != "" && (station.Bitrate > 60 || station.Bitrate == 0) {
			if station.Favicon == "" {
				station.Favicon = "assets/radio.png"
			}
			content.Tree = append(content.Tree, station)
		}
	}

	// Return the content as JSON
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(content)
}

// searchBandcampHandler handles the search_bandcamp route
func searchBandcampHandler(w http.ResponseWriter, r *http.Request) {
	pattern := r.URL.Query().Get("pattern")

	if len(pattern) < 20 || !(strings.Contains(pattern, "bandcamp.com/") || strings.Contains(pattern, "youtube") || strings.Contains(pattern, "youtu.be")) {
		json.NewEncoder(w).Encode(map[string]interface{}{"tree": []interface{}{}})
		return
	}

	content := map[string]interface{}{
		"tree": []map[string]interface{}{},
	}

	// Check if the pattern is for Bandcamp
	if strings.Contains(pattern, "bandcamp.com") {
		albumList, err := handleBandcampSearch(pattern)
		if err != nil {
			log.Error().Str("function", "searchBandcampHandler").Msg(fmt.Sprintf("Exception during Bandcamp search: %v", err))
			json.NewEncoder(w).Encode(content)
			return
		}
		content["tree"] = albumList
	}

	// Check if the pattern is for YouTube
	if strings.Contains(pattern, "youtube") || strings.Contains(pattern, "youtu.be") {
		youtubeLink := handleYouTubeSearch(pattern)
		content["tree"] = append(content["tree"].([]map[string]interface{}), youtubeLink)
	}

	json.NewEncoder(w).Encode(content)
}

// handleBandcampSearch fetches album info for Bandcamp URLs
func handleBandcampSearch(pattern string) ([]map[string]interface{}, error) {
	log.Debug().Str("function", "searchBandcampHandler").Msg(fmt.Sprintf("Searching for Bandcamp album: %s", pattern))

	albumInfo, err := getBandcampAlbumInfo(pattern)
	if err != nil {
		return nil, err
	}

	return []map[string]interface{}{albumInfo}, nil
}

// handleYouTubeSearch returns metadata for YouTube links
func handleYouTubeSearch(pattern string) map[string]interface{} {
	log.Debug().Str("function", "handleYouTubeSearch").Msg(fmt.Sprintf("Returning YouTube link: %s", pattern))

	return map[string]interface{}{
		"url":    pattern,
		"title":  pattern,
		"year":   "",
		"art":    "https://i.ytimg.com/vi_webp/VbChrk8Vs64/mqdefault.webp",
		"artist": "",
	}
}

// getBandcampAlbumInfo fetches metadata and track URLs from a Bandcamp album page
func getBandcampAlbumInfo(url string) (map[string]interface{}, error) {
	log.Debug().Str("function", "getBandcampAlbumInfo").Msg(fmt.Sprintf("Fetching Bandcamp album info from: %s", url))

	// Fetch the page content
	resp, err := http.Get(url)
	if err != nil || resp.StatusCode != 200 {
		return nil, fmt.Errorf("failed to retrieve the Bandcamp page")
	}
	defer resp.Body.Close()

	doc, err := goquery.NewDocumentFromReader(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("failed to parse HTML")
	}

	// Extract album details
	title, artist, releaseYear, coverArt := extractAlbumDetails(doc)

	// Use yt-dlp to get track URLs
	// trackURLs, err := getBandcampTrackURLs(url)
	// if err != nil {
	//    return nil, err
	// }

	// Construct the album data
	albumData := map[string]interface{}{
		"artist": artist,
		"title":  title,
		"art":    coverArt,
		"url":    url,
		"date":   releaseYear,
		// "tracks":       trackURLs,
	}

	return albumData, nil
}

// extractAlbumDetails extracts metadata from Bandcamp HTML
func extractAlbumDetails(doc *goquery.Document) (string, string, string, string) {
	// Extract title, artist, release year, and cover art
	description := doc.Find("meta[name='description']").AttrOr("content", "")
	title, artist, releaseYear := parseBandcampDescription(description)

	coverArt := doc.Find("meta[property='og:image']").AttrOr("content", "")

	return title, artist, releaseYear, coverArt
}

func getBandcampTrackURLs(url string) ([]string, error) {
	// Define the yt-dlp command with options to extract URLs
	log.Debug().Str("function", "getBandcampTrackURLs").Msg(fmt.Sprintf("Running yt-dlp -f bestaudio -g %v", url))
	cmd := exec.Command("yt-dlp", "-f", "bestaudio", "-g", url)

	// Capture the output
	var out bytes.Buffer
	cmd.Stdout = &out

	// Run the command
	err := cmd.Run()
	if err != nil {
		return nil, fmt.Errorf("yt-dlp command failed: %v", err)
	}

	// Split the output into lines (each URL is on a new line)
	trackURLs := bytes.Split(out.Bytes(), []byte("\n"))

	// Convert from [][]byte to []string, removing empty lines
	var result []string
	for _, track := range trackURLs {
		if len(track) > 0 {
			result = append(result, string(track))
		}
	}

	return result, nil
}

// parseBandcampDescription extracts the album title, artist, and release year from the description.
func parseBandcampDescription(description string) (string, string, string) {
	// Trim any extra newlines and spaces
	description = strings.TrimSpace(description)

	// Regular expression to match title, artist, and release date
	re := regexp.MustCompile(`^(.+?) by (.+?), released (\d{1,2} \w+ \d{4})`)
	matches := re.FindStringSubmatch(description)

	// Check if we found a match
	if len(matches) > 0 {
		title := strings.TrimSpace(matches[1])
		artist := strings.TrimSpace(matches[2])
		releaseDate := strings.TrimSpace(matches[3])

		// Extract the release year from the release date
		reYear := regexp.MustCompile(`\d{4}`)
		yearMatch := reYear.FindString(releaseDate)

		return title, artist, yearMatch
	}

	// Return empty strings if no match is found
	return "", "", ""
}

func removeHistoryHandler(w http.ResponseWriter, r *http.Request) {
	// Get the 'playable' parameter from the URL query or fall back to 'url'
	playable := r.URL.Query().Get("directory")
	if playable == "" {
		playable = r.URL.Query().Get("url")
	}
	stationuuid := r.URL.Query().Get("stationuuid")
	var history string

	// Determine the history type (radio, bandcamp, or general history)
	if stationuuid != "" {
		history = "radio_history"
	} else if strings.HasPrefix(playable, "http") {
		history = "bandcamp_history"
	} else {
		history = "history"
	}

	clientID := r.URL.Query().Get("client_id")
	if clientID == "" {
		clientID = "guest"
	}

	log.Debug().Str("function", "removeHistoryHandler").Msg(fmt.Sprintf("need to deal with history=%v", history))

	// Read the client history
	clientHistory, err := readData(clientID, history)
	if err != nil {
		http.Error(w, "Failed to read client history", http.StatusInternalServerError)
		log.Debug().Str("function", "").Msg(fmt.Sprintf("Failed to read client history: %v", err))
		return
	}

	log.Debug().Str("function", "removeHistoryHandler").Msg(fmt.Sprintf("read history=%v playable=%v", clientHistory, playable))

	// Remove the playable from the specific history type slice
	if playable != "" {
		if history == "radio_history" && len(clientHistory.RadioHistory) > 0 {
			clientHistory.RadioHistory = removeItem(clientHistory.RadioHistory, stationuuid)
			delete(clientHistory.Stations, stationuuid)
		} else if history == "bandcamp_history" && len(clientHistory.BandcampHistory) > 0 {
			clientHistory.BandcampHistory = removeItem(clientHistory.BandcampHistory, playable)
		} else if history == "history" && len(clientHistory.History) > 0 {
			clientHistory.History = removeItem(clientHistory.History, playable)
		}
	}

	// Write back the updated history
	err = writeData(clientID, history, clientHistory)
	if err != nil {
		http.Error(w, "Failed to write updated history", http.StatusInternalServerError)
		log.Error().Str("function", "removeHistoryHandler").Msg(fmt.Sprintf("Failed to write updated history: %v", err))
		return
	}

	// Respond with success
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]string{"result": "ok"})
}

// Helper function to remove an item from a slice (returns a new slice)
func removeItem(slice []string, item string) []string {
	newSlice := []string{}
	for _, v := range slice {
		if v != item {
			newSlice = append(newSlice, v)
		}
	}
	return newSlice
}

func mpdProxyHandler(w http.ResponseWriter, r *http.Request) {
	var content map[string]interface{} = make(map[string]interface{})
	var err error
	log.Debug().Str("function", "mpdProxyHandler").Msg(fmt.Sprintf("mpdProxyHandler url: %v", r.URL.Path))
	err = withRequestMPDClient(r, "default", func(mpdClient *mpd.Client) (closureErr error) {
		switch r.URL.Path {
		case "/play":
			err = mpdClient.Play(-1)
			content["message"] = "Playing"
		case "/pause":
			err = mpdClient.Pause(true)
			content["message"] = "Paused"
		case "/playpause":
			status, err := mpdClient.Status()
			if err != nil {
				http.Error(w, "Failed to get status", http.StatusInternalServerError)
				return errResponseSent
			}
			if status["state"] == "pause" {
				err = mpdClient.Play(-1)
				content["message"] = "Playing"
			} else {
				err = mpdClient.Pause(true)
				content["message"] = "Paused"
			}
		case "/next":
			err = mpdClient.Next()
			content["message"] = "Next track"
		case "/prev":
			err = mpdClient.Previous()
			content["message"] = "Previous track"
		case "/stop":
			mpdClient.Stop()
			mpdClient.Clear()
			content["message"] = "Stopped"
		case "/status":
			status, err := mpdClient.Status()
			if err != nil {
				http.Error(w, "Failed to get status", http.StatusInternalServerError)
				return errResponseSent
			}
			content["status"] = status
		case "/listfiles":
			directory := r.URL.Query().Get("directory")
			if directory == "" {
				directory = "."
			}
			files, err := mpdClient.ListInfo(directory)
			if err != nil {
				http.Error(w, "Failed to list files", http.StatusInternalServerError)
				return errResponseSent
			}
			content["tree"] = files
		case "/lsinfo":
			directory := r.URL.Query().Get("directory")
			if directory == "" {
				directory = "."
			}
			info, err := mpdClient.ListInfo(directory)
			if err != nil {
				http.Error(w, "Failed to get lsinfo", http.StatusInternalServerError)
				return errResponseSent
			}
			content["tree"] = info

		case "/search":
			pattern := r.URL.Query().Get("pattern")
			if pattern == "" {
				pattern = "ugar"
			}
			searchResult, err := mpdClient.Search("any", pattern)
			if err != nil {
				http.Error(w, "Failed to search", http.StatusInternalServerError)
				return errResponseSent
			}

			var fileInfos []FileInfo
			for _, fileRecord := range searchResult {
				file := fileRecord["file"]
				fileInfo := FileInfo{
					LastModified: fileRecord["last-modified"],
					Artist:       fileRecord["artist"],
					Album:        fileRecord["album"],
					File:         file,
					Format:       fileRecord["format"],
					// Add additional fields here
					Duration: fileRecord["duration"],
					Genre:    fileRecord["genre"],
					Codec:    fileRecord["codec"],
					Track:    fileRecord["track"],
					Date:     fileRecord["date"],
					Title:    fileRecord["title"],
				}
				fileInfos = append(fileInfos, fileInfo)
			}

			// Get directories from search results
			resultDirectories := make(map[string]bool)
			for _, elem := range searchResult {
				file := elem["file"]
				resultDirectories[filepath.Dir(file)] = true
			}

			// Add directories to fileInfos
			for directory := range resultDirectories {

				subDirCount, err := mpdClient.Count("base", directory)
				log.Debug().Str("function", "").Msg(fmt.Sprintf("subDirCount: %v", subDirCount))
				if err != nil {
					http.Error(w, "Failed to count", http.StatusInternalServerError)
					return errResponseSent
				}
				seconds, err := strconv.Atoi(subDirCount[1])
				if err != nil {
					http.Error(w, "Failed to parse count", http.StatusInternalServerError)
					return errResponseSent
				}
				duration := time.Duration(seconds) * time.Second
				hours := fmt.Sprintf("%d", int(duration.Hours()))
				minutes := fmt.Sprintf("%02d", int(duration.Minutes())%60)
				secondsStr := fmt.Sprintf("%02d", int(duration.Seconds())%60)
				playhours := fmt.Sprintf("%s:%s:%s", hours, minutes, secondsStr)

				fileInfo := FileInfo{
					Directory: directory,
					Count: map[string]interface{}{
						"playhours": playhours,
						"playtime":  subDirCount[1],
						"songs":     subDirCount[0],
					},
				}
				fileInfos = append(fileInfos, fileInfo)
			}

			content["tree"] = fileInfos

		case "/ls":
			directory := r.URL.Query().Get("directory")
			if directory == "" {
				directory = "/"
			}
			if directory == "." {
				directory = "/"
			}
			listFiles, err := mpdClient.ListInfo(directory)
			if err != nil {
				log.Debug().Str("function", "").Msg(fmt.Sprintf("%v", err))
				http.Error(w, "Failed to list files", http.StatusInternalServerError)
				return errResponseSent
			}

			lsInfo := listFiles

			var count []string

			if directory != "/" {
				count, err = mpdClient.Count("base", directory)
			} else {
				count, err = mpdClient.Count("modified-since", "0")
			}
			log.Debug().Str("function", "mpdProxyHandler:ls").Msg(fmt.Sprintf("count: %v", count))

			musicFiles := make(map[string]bool)
			for _, file := range lsInfo {
				file := file["file"]
				musicFiles[filepath.Base(file)] = true
			}
			for _, fileRecord := range listFiles {
				file := fileRecord["file"]
				if _, ok := musicFiles[filepath.Base(file)]; !ok {
					fileRecord["file"] = directory + "/" + file
					lsInfo = append(lsInfo, fileRecord)
				}
			}
			log.Debug().Str("function", "mpdProxyHandler:ls").Msg(fmt.Sprintf("lsinfo: %v", lsInfo))

			// Adjusting the info structure
			info := map[string]string{
				"playtime": count[1],
				"songs":    count[0],
			}
			content["info"] = info

			// Adjusting the tree structure
			var fileInfos []FileInfo
			log.Debug().Str("function", "mpdProxyHandler:ls").Msg(fmt.Sprintf("iterating lsinfo"))
			for _, name := range lsInfo {
				log.Debug().Str("function", "").Msg(fmt.Sprintf("name: %v", name))
				dir := name["directory"]
				if dir == "" {
					fileInfo := FileInfo{
						LastModified: name["last-modified"],
						Artist:       name["artist"],
						Album:        name["album"],
						File:         name["file"],
						Format:       name["format"],
						// Add additional fields here
						Duration: name["duration"],
						Genre:    name["genre"],
						Codec:    name["codec"],
						Track:    name["track"],
						Date:     name["date"],
						Title:    name["title"],
					}
					fileInfos = append(fileInfos, fileInfo)
					continue
				}
				subDir := dir

				subDirCount, err := mpdClient.Count("base", dir)
				log.Debug().Str("function", "").Msg(fmt.Sprintf("subDirCount: %v", subDirCount))
				seconds, err := strconv.Atoi(subDirCount[1])
				if err != nil {
					http.Error(w, "Failed to parse count", http.StatusInternalServerError)
					return errResponseSent
				}
				duration := time.Duration(seconds) * time.Second
				hours := fmt.Sprintf("%d", int(duration.Hours()))
				minutes := fmt.Sprintf("%02d", int(duration.Minutes())%60)
				secondsStr := fmt.Sprintf("%02d", int(duration.Seconds())%60)

				var playhours string
				if hours == "00" {
					// Omit the hour if it's less than an hour
					playhours = fmt.Sprintf("%s:%s", minutes, secondsStr)
				} else {
					// Include the hour
					playhours = fmt.Sprintf("%s:%s:%s", hours, minutes, secondsStr)
				}

				fileInfo := FileInfo{
					Directory:    subDir,
					LastModified: name["last-modified"],
					Count: map[string]interface{}{
						"playhours": playhours,
						"playtime":  subDirCount[1],
						"songs":     subDirCount[0],
					},
					Artist: name["artist"],
					Album:  name["album"],
					File:   name["file"],
					Format: name["format"],
					// Add additional fields here
					Duration: name["duration"],
					Genre:    name["genre"],
					Codec:    name["codec"],
					Track:    name["track"],
					Date:     name["date"],
					Title:    name["title"],
				}
				fileInfos = append(fileInfos, fileInfo)
			}

			log.Debug().Str("function", "mpdProxyHandler:ls").Msg(fmt.Sprintf("fileInfos: %v", fileInfos))
			content["tree"] = fileInfos

		case "/addplay":
			var playables []string
			playable := r.URL.Query().Get("directory")
			if playable == "" {
				playable = r.URL.Query().Get("url")
			}
			url := r.URL.Query().Get("url")
			stationUUID := r.URL.Query().Get("stationuuid")
			name := r.URL.Query().Get("name")
			favicon := r.URL.Query().Get("favicon")

			// Check if the playable URL is a radio station
			if r.URL.Query().Get("stationuuid") != "" && !strings.Contains(playable, "bandcamp.com") && !strings.Contains(playable, "youtube") && !strings.Contains(playable, "youtu.be") {
				// Placeholder for pyradios implementation
				stationURL := r.URL.Query().Get("url")
				playable = stationURL
			}

			// Check if the playable URL is a YouTube video
			if strings.Contains(playable, "youtube") || strings.Contains(playable, "youtu.be") || strings.Contains(playable, "bandcamp.com") {
				playables, _ = getBandcampTrackURLs(playable)
			}

			mpdClient.Consume(true)

			if r.URL.Query().Get("directory") != "" || len(playables) > 0 {
				mpdClient.Add("signal.mp3")
			}

			if len(playables) > 0 {
				log.Debug().Str("function", "mpdProxyHandler:addplay").Msg(fmt.Sprintf("Playables: %v", playables))
				for _, item := range playables {
					mpdClient.Add(item)
				}
			} else if playable != "" {
				log.Debug().Str("function", "mpdProxyHandler:addplay").Msg(fmt.Sprintf("Playable: %v", playable))
				mpdClient.Add(playable)
			}

			mpdClient.Play(-1)

			// Manage history
			clientID := r.URL.Query().Get("client_id")
			if r.URL.Query().Get("directory") != "" && clientID != "" {
				log.Debug().Str("function", "mpdProxyHandler:addplay").Msg(fmt.Sprintf("writing history: %v", playable))
				ClientData, err := readData(clientID, "history")
				if err != nil {
					log.Error().Str("function", "mpdProxyHandler:addplay").Msg(fmt.Sprintf("%v", err))
				}

				// Check if 'playable' exists in the client history
				for i, item := range ClientData.History {
					if item == playable {
						// Remove the item from history
						ClientData.History = append(ClientData.History[:i], ClientData.History[i+1:]...)
						break
					}
				}

				ClientData.History = append(ClientData.History, playable)

				// Limit the history to the last 10 items
				if len(ClientData.History) > 10 {
					ClientData.History = ClientData.History[len(ClientData.History)-10:]
				}

				ClientDataFile := filepath.Join(clientDB, fmt.Sprintf("%s.history.json", clientID))

				// Validate the client ID and file path
				re := regexp.MustCompile(`[^A-Za-z0-9_\-\.]`)
				if clientID != "" && filepath.HasPrefix(ClientDataFile, clientDB) && re.MatchString(ClientDataFile) {
					// Write the updated history back to the file
					file, err := os.Create(ClientDataFile)
					if err != nil {
						http.Error(w, "Unable to write file", http.StatusInternalServerError)
						return errResponseSent
					}
					defer file.Close()

					// Write JSON data to file
					encoder := json.NewEncoder(file)
					if err := encoder.Encode(ClientData); err != nil {
						http.Error(w, "Failed to write JSON data", http.StatusInternalServerError)
						return errResponseSent
					}
				}

			}
			if url != "" && playable != "" && !(strings.Contains(playable, "youtube") || strings.Contains(playable, "youtu.be") || strings.Contains(playable, "bandcamp.com")) && clientID != "" {
				log.Debug().Str("function", "mpdProxyHandler:addplay").Msg(fmt.Sprintf("writing radio_history: %v", playable))

				clientData, err := readData(clientID, "radio_history")
				if err != nil {
					clientData = ClientData{
						RadioHistory: []string{},
						Stations:     map[string]StationData{},
					}
				}

				// Ensure 'stations' exists in client data
				if clientData.Stations == nil {
					clientData.Stations = make(map[string]StationData)
				}

				// Update radio history
				// Remove the stationUUID from the history if it exists
				for i, uuid := range clientData.RadioHistory {
					if uuid == stationUUID {
						clientData.RadioHistory = append(clientData.RadioHistory[:i], clientData.RadioHistory[i+1:]...)
						break
					}
				}

				// Append the stationUUID to the history and trim history to last 12 entries
				clientData.RadioHistory = append(clientData.RadioHistory, stationUUID)
				if len(clientData.RadioHistory) > 12 {
					clientData.RadioHistory = clientData.RadioHistory[len(clientData.RadioHistory)-12:]
				}

				// Update stations information
				clientData.Stations[stationUUID] = StationData{
					URL:         playable,
					StationUUID: stationUUID,
					Name:        name,
					Favicon:     favicon,
				}
				// Write the updated data back to the file
				if err := writeData(clientID, "radio_history", clientData); err != nil {
					log.Error().Str("function", "mpdProxyHandler:addplay").Msg(fmt.Sprintf("Failed to write radio history for %s: %v", clientID, err))
					http.Error(w, "Failed to update radio history", http.StatusInternalServerError)
					return errResponseSent
				}
			}
			if url != "" && playable != "" && (strings.Contains(playable, "youtube") || strings.Contains(playable, "youtu.be") || strings.Contains(playable, "bandcamp.com")) && clientID != "" {
				log.Debug().Str("function", "mpdProxyHandler:addplay").Msg(fmt.Sprintf("writing bandcamp_history: %v", playable))

				clientData, err := readData(clientID, "bandcamp_history")
				if err != nil {
					clientData = ClientData{
						BandcampHistory: []string{},
						Links:           map[string]LinkData{},
					}
				}

				// Ensure 'stations' exists in client data
				if clientData.Links == nil {
					clientData.Links = make(map[string]LinkData)
				}

				for i, item := range clientData.BandcampHistory {
					if item == playable {
						clientData.BandcampHistory = append(clientData.BandcampHistory[:i], clientData.BandcampHistory[i+1:]...)
						break
					}
				}

				clientData.BandcampHistory = append(clientData.BandcampHistory, playable)
				if len(clientData.BandcampHistory) > bandcampHistorySize {
					clientData.BandcampHistory = clientData.BandcampHistory[len(clientData.BandcampHistory)-bandcampHistorySize:]
				}
				_, exists := clientData.Links[playable]
				if exists {
					log.Debug().Str("function", "mpdProxyHandler:addplay").Msg(fmt.Sprintf("Key '%s' exists with value in clientData.Links\n", playable))
				} else {
					// Update links information
					albumInfo, _ := getBandcampAlbumInfo(playable)

					clientData.Links[playable] = LinkData{
						URL:     playable,
						Favicon: albumInfo["art"].(string),
						Title:   albumInfo["title"].(string),
						Date:    albumInfo["date"].(string),
						Artist:  albumInfo["artist"].(string),
					}
				}

				// Write the updated data back to the file
				if err := writeData(clientID, "bandcamp_history", clientData); err != nil {
					log.Error().Str("function", "mpdProxyHandler:addplay").Msg(fmt.Sprintf("Failed to write bandcamp history for %s: %v", clientID, err))
					http.Error(w, "Failed to update bandcamp history", http.StatusInternalServerError)
					return errResponseSent
				}
			}

		default:
			http.Error(w, "Not Found", http.StatusNotFound)
			return errResponseSent
		}

		return nil
	})

	if err != nil {
		if errors.Is(err, errResponseSent) {
			return
		}
		http.Error(w, fmt.Sprintf("Failed to execute command: %v", err), http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(content)
}

func getActivePlayers() []map[string]interface{} {
	players := []map[string]interface{}{}

	// Initialize Redis client
	rdb := redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
		DB:   0,
	})

	defer rdb.Close()

	// Scan for keys
	iter := rdb.Scan(ctx, 0, "upnp:player:*:last_seen", 0).Iterator()
	for iter.Next(ctx) {
		key := iter.Val()
		lastSeenStr, err := rdb.Get(ctx, key).Result()
		if err != nil {
			log.Debug().Str("function", "getActivePlayers").Msg(fmt.Sprintf("Failed to get last seen: %v", err))
			continue
		}

		lastSeen, err := strconv.ParseFloat(lastSeenStr, 64)
		if err != nil {
			log.Debug().Str("function", "getActivePlayers").Msg(fmt.Sprintf("Failed to parse last seen: %v", err))
			continue
		}

		if time.Now().Unix()-int64(lastSeen) < 1200 {
			dataStr, err := rdb.Get(ctx, strings.Replace(key, "last_seen", "data", 1)).Result()
			if err != nil {
				log.Debug().Str("function", "getActivePlayers").Msg(fmt.Sprintf("Failed to get data: %v", err))
				continue
			}

			var data map[string]interface{}
			if err := json.Unmarshal([]byte(dataStr), &data); err != nil {
				log.Debug().Str("function", "getActivePlayers").Msg(fmt.Sprintf("Failed to unmarshal data: %v", err))
				continue
			}

			players = append(players, data)
		}

		// Housekeeping
		if time.Now().Unix()-int64(lastSeen) > 1800 {
			rdb.Del(ctx, strings.Replace(key, "last_seen", "data", 1))
			rdb.Del(ctx, key)
		}
	}
	if err := iter.Err(); err != nil {
		log.Debug().Str("function", "getActivePlayers").Msg(fmt.Sprintf("Failed to iterate: %v", err))
	}

	return players
}

func processCurrentSong(currentsong map[string]interface{}) map[string]interface{} {
	// Initialize states
	states := []string{"play", "pause", "stop"}
	for _, state := range states {
		currentsong[state] = false
		if currentsong["state"] == state {
			currentsong[state] = true
		}
	}

	// Set title and display titles
	if currentsong["Title"] == "" || currentsong["Title"] == nil {
		currentsong["title"] = currentsong["file"]
		currentsong["display_title"] = currentsong["file"]
		currentsong["display_title_top"] = currentsong["Name"]
	} else {
		titleElements := []string{}
		if track, ok := currentsong["Track"].(string); ok {
			titleElements = append(titleElements, track)
		}
		if title, ok := currentsong["Title"].(string); ok {
			titleElements = append(titleElements, title)
		}

		albumElements := []string{}
		if artist, ok := currentsong["Artist"].(string); ok {
			albumElements = append(albumElements, artist)
		}
		if album, ok := currentsong["Album"].(string); ok {
			albumElements = append(albumElements, album)
		}

		currentsong["display_title"] = strings.Join(titleElements, " - ")
		currentsong["display_title_top"] = strings.Join(albumElements, " - ")
	}

	// Set active state
	currentsong["active"] = false
	if state, ok := currentsong["state"].(string); ok {
		if state == "play" || state == "pause" {
			currentsong["active"] = true
		}
	}

	// Set not playing state
	if !currentsong["active"].(bool) {
		currentsong["title"] = "not playing"
		currentsong["display_title"] = "not playing"
	}

	// Set next state and title
	if state, ok := currentsong["state"].(string); ok {
		if state == "play" {
			currentsong["next_state"] = "pause"
			currentsong["next_title"] = "playing ➙ pause"
			currentsong["next_icon"] = "pause_circle_outline"
		} else if state == "pause" {
			currentsong["next_state"] = "play"
			currentsong["next_title"] = "paused ➙ play"
			currentsong["next_icon"] = "play_circle_outline"
		}
	}

	return currentsong
}

func pollCurrentSongHandler(w http.ResponseWriter, r *http.Request) {
	var err error
	clientKey := pollClientKey(r)

	if !tryAcquireClientPoll(clientKey) {
		atomic.AddUint64(&pollRejectedDuplicate, 1)
		log.Debug().Str("function", "pollCurrentSongHandler").Str("client", clientKey).Msg("Duplicate poll request detected; returning immediate state")
		currentSongHandler(w, r)
		return
	}
	defer releaseClientPoll(clientKey)

	if !tryAcquirePollSlot() {
		atomic.AddUint64(&pollRejectedCapacity, 1)
		log.Warn().Str("function", "pollCurrentSongHandler").Int("poll_slot_capacity", cap(pollSlots)).Msg("Poll capacity reached; returning immediate state")
		currentSongHandler(w, r)
		return
	}
	defer releasePollSlot()

	total := atomic.AddUint64(&pollTotalRequests, 1)
	active := atomic.AddInt64(&pollActiveRequests, 1)
	defer atomic.AddInt64(&pollActiveRequests, -1)

	log.Debug().
		Str("function", "pollCurrentSongHandler").
		Uint64("poll_total_requests", total).
		Int64("poll_active_requests", active).
		Msg("Starting poll request")
	maybeLogPollMetricsSnapshot()

	// Wait for MPD events with a timeout on a dedicated long-poll connection.
	timeout := 60 * time.Second
	err = withRequestMPDClient(r, "poll-idle", func(mpdClient *mpd.Client) error {
		done := make(chan error, 1)
		go func() {
			result, idleErr := mpdClient.Idle("playlist", "player")
			if idleErr != nil {
				done <- idleErr
				return
			}
			log.Debug().Str("function", "pollCurrentSongHandler").Msg(fmt.Sprintf("We've got something back: %v", result))
			done <- nil
		}()

		timer := time.NewTimer(timeout)
		defer timer.Stop()

		select {
		case idleErr := <-done:
			if idleErr != nil {
				atomic.AddUint64(&pollErrors, 1)
				return idleErr
			}
			atomic.AddUint64(&pollIdleEvents, 1)
			log.Debug().Str("function", "pollCurrentSongHandler").Msg(fmt.Sprintf("Something happened in mpd"))
			return nil
		case <-timer.C:
			atomic.AddUint64(&pollTimeouts, 1)
			log.Debug().Str("function", "pollCurrentSongHandler").Msg(fmt.Sprintf("Timeout waiting for mpd events"))
			_ = mpdClient.Close()

			// Wait briefly for Idle() to unwind after closing the connection.
			// This avoids accumulating orphaned goroutines in prolonged timeouts.
			select {
			case idleErr := <-done:
				if idleErr != nil && !isMPDConnectionError(idleErr) {
					log.Warn().Str("function", "pollCurrentSongHandler").Msg(fmt.Sprintf("Idle returned unexpected error after timeout close: %v", idleErr))
				}
			case <-time.After(2 * time.Second):
				log.Warn().Str("function", "pollCurrentSongHandler").Msg("Idle did not exit promptly after timeout close")
			}

			return errMPDIdleTimeout
		}
	})
	if err != nil && !errors.Is(err, errMPDIdleTimeout) {
		atomic.AddUint64(&pollErrors, 1)
		log.Debug().Str("function", "pollCurrentSongHandler").Msg(fmt.Sprintf("Failed to wait for mpd events: %v", err))
	}

	var currentsong mpd.Attrs
	var status mpd.Attrs
	var outputs []mpd.Attrs
	err = withRequestMPDClient(r, "default", func(mpdClient *mpd.Client) error {
		var fetchErr error
		currentsong, fetchErr = mpdClient.CurrentSong()
		if fetchErr != nil {
			return fetchErr
		}

		status, fetchErr = mpdClient.Status()
		if fetchErr != nil {
			return fetchErr
		}

		outputs, fetchErr = mpdClient.ListOutputs()
		return fetchErr
	})
	if err != nil {
		http.Error(w, "Failed to query MPD", http.StatusInternalServerError)
		log.Debug().Str("function", "pollCurrentSongHandler").Msg(fmt.Sprintf("Failed to query MPD: %v", err))
		return
	}

	// Convert mpd.Attrs to map[string]interface{}
	currentsongMap := make(map[string]interface{})
	for k, v := range currentsong {
		currentsongMap[k] = v
	}
	for k, v := range status {
		currentsongMap[k] = v
	}

	// Add additional information
	// Get the current outputs
	currentsongMap["outputs"] = outputs

	currentsongMap["players"] = getActivePlayers() // Preserve the structure of players
	currentsongMap["bandcamp_enabled"] = bandcampEnabled
	currentsongMap["default_stream"] = defaultStream

	// Process current song
	currentsongMap = processCurrentSong(currentsongMap)

	// Get Snapcast clients data
	if getEnv("AL_SNAPCAST_HOST", "") != "" {
		snapcastClients, err := getSnapcastClientsData()
		if err != nil {
			log.Debug().Str("function", "pollCurrentSongHandler").Msg(fmt.Sprintf("Failed to get Snapcast clients: %v", err))
			// Handle the error appropriately, e.g., log it or return an error response
		} else {
			currentsongMap["snapcast_clients"] = snapcastClients
		}
	}

	// Return the content as JSON
	w.Header().Set("Content-Type", "application/json")

	// Directly encode the final currentsongMap to JSON
	if err := json.NewEncoder(w).Encode(currentsongMap); err != nil {
		log.Debug().Str("function", "pollCurrentSongHandler").Msg(fmt.Sprintf("Error encoding JSON response: %v", err))
		// If encoding fails, send an empty JSON object as a fallback
		emptyResponse := map[string]interface{}{}
		json.NewEncoder(w).Encode(emptyResponse)
	}
}

func currentSongHandler(w http.ResponseWriter, r *http.Request) {
	var currentsong mpd.Attrs
	var status mpd.Attrs
	var outputs []mpd.Attrs
	err := withRequestMPDClient(r, "default", func(mpdClient *mpd.Client) error {
		var fetchErr error
		currentsong, fetchErr = mpdClient.CurrentSong()
		if fetchErr != nil {
			return fetchErr
		}

		outputs, fetchErr = mpdClient.ListOutputs()
		if fetchErr != nil {
			return fetchErr
		}

		status, fetchErr = mpdClient.Status()
		return fetchErr
	})
	if err != nil {
		http.Error(w, "Failed to query MPD", http.StatusInternalServerError)
		log.Debug().Str("function", "currentSongHandler").Msg(fmt.Sprintf("Failed to query MPD: %v", err))
		return
	}

	// Convert mpd.Attrs to map[string]interface{}
	currentsongMap := make(map[string]interface{})
	for k, v := range currentsong {
		currentsongMap[k] = v
	}
	for k, v := range status {
		currentsongMap[k] = v
	}

	// Add additional information (players, bandcamp_enabled, default_stream)
	currentsongMap["players"] = getActivePlayers()
	currentsongMap["outputs"] = outputs
	currentsongMap["bandcamp_enabled"] = bandcampEnabled
	currentsongMap["default_stream"] = defaultStream

	// Process current song
	currentsongMap = processCurrentSong(currentsongMap)

	// Get Snapcast clients data
	if getEnv("AL_SNAPCAST_HOST", "") != "" {
		snapcastClients, err := getSnapcastClientsData()
		if err != nil {
			log.Debug().Str("function", "pollCurrentSongHandler").Msg(fmt.Sprintf("Failed to get Snapcast clients: %v", err))
			// Handle the error appropriately, e.g., log it or return an error response
		} else {
			currentsongMap["snapcast_clients"] = snapcastClients
		}
	}

	// Return the content as JSON
	w.Header().Set("Content-Type", "application/json")
	if err := json.NewEncoder(w).Encode(currentsongMap); err != nil {
		http.Error(w, "Failed to encode JSON", http.StatusInternalServerError)
		log.Debug().Str("function", "currentSongHandler").Msg(fmt.Sprintf("Failed to encode JSON: %v", err))
	}
}

func countHandler(w http.ResponseWriter, r *http.Request) {
	// Get the directory from the request
	directory := r.URL.Query().Get("directory")
	if directory == "" {
		directory = "."
	}
	log.Debug().Str("function", "countHandler").Msg(fmt.Sprintf("Directory: %v", directory))

	var count []string
	err := withRequestMPDClient(r, "default", func(mpdClient *mpd.Client) error {
		var countErr error
		count, countErr = mpdClient.Count("base", directory)
		return countErr
	})
	if err != nil {
		http.Error(w, "Failed to get count", http.StatusInternalServerError)
		log.Debug().Str("function", "countHandler").Msg(fmt.Sprintf("Failed to get count: %v", err))
		return
	}
	log.Debug().Str("function", "countHandler").Msg(fmt.Sprintf("Count: %v", count))
	// Calculate the play hours

	seconds, err := strconv.Atoi(count[1])
	duration := time.Duration(seconds) * time.Second
	hours := int(duration.Hours())
	minutes := int(duration.Minutes()) % 60

	// Prepare the content to return
	content := map[string]interface{}{
		"playhours": fmt.Sprintf("%d:%02d", hours, minutes),
		"count":     count[0],
		"name":      directory,
	}

	// Return the content as JSON
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(content)
}

func toggleOutputHandler(w http.ResponseWriter, r *http.Request) {
	outputID := r.URL.Query().Get("output")
	log.Debug().Str("function", "toggleOutputHandler").Msg(fmt.Sprintf("outputID: %v", outputID))

	var outputs []mpd.Attrs
	err := withRequestMPDClient(r, "default", func(mpdClient *mpd.Client) error {
		var actionErr error
		outputs, actionErr = mpdClient.ListOutputs()
		if actionErr != nil {
			return actionErr
		}
		log.Debug().Str("function", "toggleOutputHandler").Msg(fmt.Sprintf("outputs: %v", outputs))

		for _, output := range outputs {
			if output["outputid"] == outputID {
				outputInt, atoiErr := strconv.Atoi(outputID)
				if atoiErr != nil {
					return atoiErr
				}

				if output["outputenabled"] == "1" {
					actionErr = mpdClient.DisableOutput(outputInt)
				} else {
					actionErr = mpdClient.EnableOutput(outputInt)
				}
				if actionErr != nil {
					return actionErr
				}
				break
			}
		}

		outputs, actionErr = mpdClient.ListOutputs()
		return actionErr
	})
	if err != nil {
		http.Error(w, "Failed to toggle/get outputs", http.StatusInternalServerError)
		log.Debug().Str("function", "toggleOutputHandler").Msg(fmt.Sprintf("Failed to toggle/get outputs: %v", err))
		return
	}

	// Return the outputs as JSON
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(outputs)
}

type SnapcastResponse struct {
	Result struct {
		Server struct {
			Groups []struct {
				Clients []struct {
					ID        string `json:"id"`
					Connected bool   `json:"connected"`
					Config    struct {
						Name   string `json:"name"`
						Volume struct {
							Muted bool `json:"muted"`
						} `json:"volume"`
					} `json:"config"`
					Host struct {
						Name string `json:"name"`
					} `json:"host"`
				} `json:"clients"`
			} `json:"groups"`
		} `json:"server"`
	} `json:"result"`
}

type FilteredClient struct {
	ID        string `json:"id"`
	Name      string `json:"name"`
	Connected bool   `json:"connected"`
	Muted     bool   `json:"muted"`
}

// getSnapcastClientsData is a helper function to get Snapcast client data.
func getSnapcastClientsData() ([]FilteredClient, error) {
	// Connect to Snapcast server
	log.Debug().Str("function", "getSnapcastClientsData").Msg(fmt.Sprintf("snapcastHost: %v", snapcastHost))
	conn, err := net.DialTimeout("tcp", snapcastHost+":1705", 3*time.Second)
	if err != nil {
		log.Debug().Str("function", "getSnapcastClientsData").Msg(fmt.Sprintf("Failed to connect to Snapcast server: %v", err))
		return nil, fmt.Errorf("failed to connect to Snapcast server: %w", err)
	}
	defer conn.Close()
	log.Debug().Str("function", "getSnapcastClientsData").Msg(fmt.Sprintf("connected: %v", snapcastHost))

	// Send JSON-RPC request
	sendData := "{\"id\":1, \"jsonrpc\":\"2.0\", \"method\":\"Server.GetStatus\"}\n\n"
	_, err = conn.Write([]byte(sendData))
	if err != nil {
		log.Debug().Str("function", "getSnapcastClientsData").Msg(fmt.Sprintf("Failed to send request to Snapcast server: %v", err))
		return nil, fmt.Errorf("failed to send request to Snapcast server: %w", err)
	}
	log.Debug().Str("function", "getSnapcastClientsData").Msg(fmt.Sprintf("request sent: %v", snapcastHost))

	// Read response
	reader := bufio.NewReader(conn)
	var response []byte
	for {
		line, err := reader.ReadBytes('\n')
		if err != nil {
			if err.Error() == "EOF" {
				break
			}
			log.Debug().Str("function", "getSnapcastClientsData").Msg(fmt.Sprintf("Failed to read response from Snapcast server: %v", err))
			return nil, fmt.Errorf("failed to read response from Snapcast server: %w", err)
		}
		response = append(response, line...)
		if bytes.Contains(response, []byte("}\n")) || bytes.Contains(response, []byte("}")) {
			break
		}
	}

	// log.Debug().Str("function", "getSnapcastClientsData").Msg(fmt.Sprintf("Response received: %s", string(response)))

	// Parse JSON response
	var snapResponse SnapcastResponse
	err = json.Unmarshal(response, &snapResponse)
	if err != nil {
		log.Debug().Str("function", "getSnapcastClientsData").Msg(fmt.Sprintf("Failed to decode json response from Snapcast server: %v", err))
		return nil, fmt.Errorf("failed to decode json response from Snapcast server: %w", err)
	}

	// Extract relevant client information
	var clients []FilteredClient
	for _, group := range snapResponse.Result.Server.Groups {
		for _, client := range group.Clients {

			if !client.Connected {
				continue
			}

			name := client.Host.Name
			if cfgName := client.Config.Name; cfgName != "" {
				name = cfgName
			}

			clients = append(clients, FilteredClient{
				ID:        client.ID,
				Name:      name,
				Connected: client.Connected,
				Muted:     client.Config.Volume.Muted,
			})
		}
	}
	return clients, nil
}

func getSnapcastClientsHandler(w http.ResponseWriter, r *http.Request) {
	clients, err := getSnapcastClientsData()
	if err != nil {
		http.Error(w, "Failed to get Snapcast clients", http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(clients)
}

func toggleSnapcastClientHandler(w http.ResponseWriter, r *http.Request) {
	id := r.URL.Query().Get("id")
	muted := r.URL.Query().Get("muted")

	log.Debug().Str("function", "toggleSnapcastClientHandler").Msg(fmt.Sprintf("id: %v muted: %v", id, muted))

	// ❯ echo -e '{"id":5,"jsonrpc":"2.0","method":"Client.SetVolume","params":{"id":"14:75:5b:a4:67:e4","volume":{ "muted": true}}}' | socat - TCP:10.181.0.13:1705
	// {"id":5,"jsonrpc":"2.0","result":{"volume":{"muted":true,"percent":100}}}
	// echo -e '{"id":5,"jsonrpc":"2.0","method":"Client.SetVolume","params":{"id":"14:75:5b:a4:67:e4","volume":{ "muted": false}}}' | socat - TCP:10.181.0.13:1705
	// {"id":5,"jsonrpc":"2.0","result":{"volume":{"muted":false,"percent":100}}}

	conn, err := net.DialTimeout("tcp", snapcastHost+":1705", 3*time.Second)
	if err != nil {
		log.Debug().Str("function", "toggleSnapcastClientHandler").Msg(fmt.Sprintf("Failed to connect to Snapcast server: %v", err))
		http.Error(w, "failed to connect to Snapcast server", http.StatusInternalServerError)
		return
	}
	defer conn.Close()
	log.Debug().Str("function", "toggleSnapcastClientHandler").Msg(fmt.Sprintf("connected: %v", snapcastHost))

	// Send JSON-RPC request
	sendData := "{\"id\":5, \"jsonrpc\":\"2.0\", \"method\":\"Client.SetVolume\", \"params\":{\"id\":\"" + id + "\", \"volume\":{\"muted\":" + muted + "}}}\n\n"
	_, err = conn.Write([]byte(sendData))
	if err != nil {
		log.Debug().Str("function", "toggleSnapcastClientHandler").Msg(fmt.Sprintf("Failed to send request to Snapcast server: %v", err))
		http.Error(w, "failed to send request to Snapcast server", http.StatusInternalServerError)
		return
	}
	log.Debug().Str("function", "toggleSnapcastClientHandler").Msg(fmt.Sprintf("request sent: %v", sendData))

	// Read response
	reader := bufio.NewReader(conn)
	var response []byte
	for {
		line, err := reader.ReadBytes('\n')
		if err != nil {
			if err.Error() == "EOF" {
				break
			}
			log.Debug().Str("function", "toggleSnapcastClientHandler").Msg(fmt.Sprintf("Failed to read response from Snapcast server: %v", err))
			http.Error(w, "failed to read response from Snapcast server", http.StatusInternalServerError)
			return
		}
		response = append(response, line...)
		log.Debug().Str("function", "toggleSnapcastClientHandler").Msg(fmt.Sprintf("response line read: %v", line))

		if bytes.Contains(response, []byte("}\n")) || bytes.Contains(response, []byte("}")) {
			break
		}
	}

	var snapResponse SnapcastResponse
	err = json.Unmarshal(response, &snapResponse)
	if err != nil {
		log.Debug().Str("function", "getSnapcastClientsData").Msg(fmt.Sprintf("Failed to decode json response from Snapcast server: %v", err))
		http.Error(w, "failed to decode json response from Snapcast server", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(snapResponse)

}

func catchAllHandler(w http.ResponseWriter, r *http.Request) {
	// Redirect root path to /static/
	if r.URL.Path == "/" {
		http.Redirect(w, r, "/static/", http.StatusMovedPermanently)
		return
	}

	// Get the absolute path of the requested URL
	absPath := filepath.Join("./", r.URL.Path)

	// Check if the path is a file
	fileInfo, err := os.Stat(absPath)
	if err != nil || !fileInfo.Mode().IsRegular() {
		// If the path is not a file and does not end with a trailing slash, redirect to the path with a trailing slash
		if r.URL.Path[len(r.URL.Path)-1] != '/' {
			http.Redirect(w, r, r.URL.Path+"/", http.StatusMovedPermanently)
			return
		}

		// Serve the index.html template
		tmpl, err := template.ParseFiles("index.html")
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		tmpl.Execute(w, r.URL.Query())
	} else {
		// If the path is a file, you can serve it directly or handle it as needed
		http.ServeFile(w, r, absPath)
	}
}