package main

import (
	//"fmt"
	"fmt"
	"log"
	"net"
	"os"
	"os/exec"
	"strings"

	"github.com/joho/godotenv"
)

func main() {
	// check mount point 	
	cmd := exec.Command("bash", "-c", `mountpoint -q /home/kar/Music/`)
	log.Println("Verificando punto de montaje")
	err := cmd.Run()
	if err != nil {
		addr := checkConn()
		mountDir(addr)
		openConn()
	}
	log.Println("Carpeta montada")
	openConn()
}


func restartService() {
	log.Println("Reiniciando servicio mpd")
	cmd := exec.Command("bash", "-c", fmt.Sprintf(`systemctl --user -M kar@.host restart --user mpd`))
	err := cmd.Run()
	if err != nil {
		log.Println("Error al reiniciar servicio mpd", err)
		os.Exit(1)
	}
	log.Println("Recargando base de datos de mpd")
	cmd = exec.Command("bash", "-c", fmt.Sprintf(`runuser -u kar -- mpc update`))
	err = cmd.Run()
	if err != nil {
		log.Println("Error al actualizar base de datos de mpd")
		os.Exit(1)
	}
}

func mountDir(addr string) {
	cmd := exec.Command("bash", "-c", fmt.Sprintf(`mount %s:/server/music /home/kar/Music`, addr))
	log.Printf("Montando carpeta desde el host %s\n", addr)
	_, err := cmd.CombinedOutput()
	if err != nil {
		log.Println("Error al montar carpeta")	
		os.Exit(1)
		}
	restartService()
}

func checkConn() string {
	_, err := net.Dial("tcp", "192.168.2.11:2049")
	if err != nil {
		log.Println("Error al conectar al host 192.168.2.11")
		_, err := net.Dial("tcp", "192.168.1.64:2049")
		if err != nil {
			log.Println("Error al conectar al host 192.168.1.64", err)
		}
		return "192.168.1.64"
	}
	return "192.168.2.11"
}


func openConn() {
	err := godotenv.Load()
	if err != nil {
		log.Println("Error al leer .env", err)
		os.Exit(1)
	}
	IP_SERVER := os.Getenv("IP_SERVER")

	listener, err := net.Listen("tcp", IP_SERVER)
	if err != nil {
		log.Println("Error al abrir el puerto.", err)
	}
	defer listener.Close()
	for {
		conn, err := listener.Accept()
		if err != nil {
			log.Println("Error al aceptar la conexion.", err)
		}
		go menuController(conn)
	}
}

func menuController(conn net.Conn) {
	var out string
	comandoRaw := make([]byte, 1024)
	n, err := conn.Read(comandoRaw)
	if err != nil {
		log.Println(err)
	}
	comandoString := strings.TrimSpace(string(comandoRaw[:n]))
	switch comandoString {
	case "play":
		out = playSong()
	case "pause":
		out = pauseSong()
	case "info":
		out = infoSong()
	case "next":
		out = nextSong()
	case "addsong":
		addSong(conn)
	}
	if out != "" {
		_, err = conn.Write([]byte(out))
		if err != nil {
			log.Println("Error al enviar la informacion", err)
		}
	}
}

func playSong() string {
	cmd := exec.Command("mpc", "play")
	output, err := cmd.CombinedOutput()
	if err != nil {
		log.Println("Error al reproducir musica", err)
	}
	return string(output)
}

func pauseSong() string {
	cmd := exec.Command("mpc", "pause")
	output, err := cmd.CombinedOutput()
	if err != nil {
		log.Println("Error al pausar musica", err)
	}
	return string(output)
}

func infoSong() string {
	cmd := exec.Command("mpc")
	output, err := cmd.CombinedOutput()
	if err != nil {
		log.Println("Error al solicitar informacion", err)
	}
	return string(output)
}

func nextSong() string {
	cmd := exec.Command("mpc", "next")
	output, err := cmd.CombinedOutput()
	if err != nil {
		log.Println("Error al reproducir siguiente cancion", err)
	}
	return string(output)
}

func addSong(conn net.Conn) {
	defer conn.Close()
	cmd := exec.Command("mpc", "listall")
	cmd.Stdout = conn
	cmd.Run()
	if tcpConn, ok := conn.(*net.TCPConn); ok {
		tcpConn.CloseWrite()
	}
	bufSong := make([]byte, 1024)
	n, err := conn.Read(bufSong)
	if err != nil {
		log.Println("Error al recibir cancion", err)
	}
	fmt.Printf("%s, agregado por %s\n", strings.TrimSpace(string(bufSong[:n])), conn.RemoteAddr())
	cmdmpc := exec.Command("bash", "-c", fmt.Sprintf(`runuser -u kar -- mpc insert %q && mpc next`, strings.TrimSpace(string(bufSong[:n]))))
	out, err := cmdmpc.CombinedOutput()
	if strings.TrimSpace(string(out)) == "MPD error: Not playing" {
		log.Println("Cancion agregada")
	} else {
		if err != nil {
			log.Println("Error al agregar cancion", err)
		}
	}
	_ = playSong()
	conn.Close()
}