package main

import (
	"context"
	"dndmusicbot/opus"
	discordspeaker "dndmusicbot/speaker"
	"encoding/json"
	"log"
	"net/url"
	"os"
	"strconv"
	"time"

	"github.com/google/uuid"
	"github.com/gopxl/beep"
	"github.com/gopxl/beep/effects"
	"github.com/kataras/go-events"
	"github.com/steino/gompd/v2/mpd"
	"golang.org/x/time/rate"

	ytdl "github.com/kkdai/youtube/v2"
)

type SongInfo struct {
	Playlist     uuid.UUID `json:"playlist,omitempty"`
	PlaylistName string    `json:"playlistname,omitempty"`
	Title        string    `json:"current,omitempty"`
	Channel      string    `json:"channel,omitempty"`
	Position     int64     `json:"position"`
	Length       int64     `json:"len,omitempty"`
	Pause        bool      `json:"pause"`
	Song         string    `json:"song,omitempty"`
}

var l = rate.Sometimes{Interval: 800 * time.Millisecond}
var ytdl_client = ytdl.Client{}

func init() {
	log.Println("events.go loading...")

	app.events = events.New()

	app.events.On("load_playlist", app.loadPlaylist)
	app.events.On("add_playlist", app.addPlaylist)

	//app.events.On("preload_song", app.preloadSong)
	//app.events.On("song_over", app.songInfo)
	//app.events.On("song_start", app.songInfo)
	app.events.On("player", app.songInfo)
	//app.events.On("song_position", app.songPosition)

	app.events.On("ambiance_play", app.ambiancePlay)
	app.events.On("ambiance_stop", app.ambianceStop)
	app.events.On("ambiance_add", app.ambianceAdd)

	app.events.On("stop", app.stop)
	app.events.On("next", app.nextSong)
	app.events.On("prev", app.prevSong)

	app.events.On("vol_up", app.volup)
	app.events.On("vol_down", app.voldown)
	app.events.On("vol_set", app.volset)

	//app.events.On("tick", app.checkQueue)
	app.events.On("tick", app.songPosition)
	//app.events.On("tick", app.checkTimeleft)
}

func (app *App) volup(payload ...interface{}) {
	if !(len(payload) > 0) {
		log.Println("volup called without a payload.")
		return
	}

	var t string
	switch data := payload[0].(type) {
	case json.RawMessage:
		var err error
		err = json.Unmarshal(data, &t)
		if err != nil {
			log.Println(err)
			return
		}
	default:
		log.Println("volup called with invalid payload.")
		return
	}

	switch t {
	case "playlist":
		pl_volume.Volume = pl_volume.Volume + 0.1
	case "ambiance":
		amb_volume.Volume = amb_volume.Volume + 0.1
	}
}

func (app *App) voldown(payload ...interface{}) {
	if !(len(payload) > 0) {
		log.Println("voldown called without a payload.")
		return
	}

	var t string
	switch data := payload[0].(type) {
	case json.RawMessage:
		var err error
		err = json.Unmarshal(data, &t)
		if err != nil {
			log.Println(err)
			return
		}
	default:
		log.Println("voldown called with invalid payload.")
		return
	}

	switch t {
	case "playlist":
		pl_volume.Volume = pl_volume.Volume - 0.1
	case "ambiance":
		amb_volume.Volume = amb_volume.Volume - 0.1
	}
}

func (app *App) volset(payload ...interface{}) {
	if !(len(payload) > 0) {
		log.Println("volset called without a payload.")
		return
	}

	var data map[string]string
	switch js := payload[0].(type) {
	case json.RawMessage:
		json.Unmarshal(js, &data)
	default:
		log.Println("volset called with invalid payload.")
		return
	}

	vol, err := strconv.ParseFloat(data["vol"], 64)
	if err != nil {
		log.Println(err)
		return
	}

	switch data["type"] {
	case "playlist":
		pl_volume.Volume = vol
	case "ambiance":
		amb_volume.Volume = vol
	}

	app.sendVolume()
}

func (app *App) sendVolume() {
	msg := make(map[string]interface{})
	out := make(map[string]float64)
	msg["event"] = "volume"
	out["playlist"] = pl_volume.Volume
	out["ambiance"] = amb_volume.Volume
	msg["payload"] = out
	ws_msg <- msg
}

func (app *App) songInfoEvent(event string) map[string]interface{} {
	msg := make(map[string]interface{})
	msg["event"] = event
	status, err := app.mpd.Status()
	if err != nil {
		log.Println(err)
		return nil
	}

	cur, err := app.mpd.CurrentSong()
	if err != nil {
		log.Println(err)
		return nil
	}

	info := new(SongInfo)

	if status["state"] != "play" {
		info.Pause = true
		msg["payload"] = info
		return msg
	}

	duration, ok := status["duration"]
	if ok && duration != "" {
		slen, err := strconv.ParseFloat(duration, 64)
		if err != nil {
			log.Println(err)
			return nil
		}
		info.Length = time.Duration(slen * float64(time.Second)).Milliseconds()
	}

	elapsed, ok := status["elapsed"]
	if ok && elapsed != "" {
		spos, err := strconv.ParseFloat(elapsed, 64)
		if err != nil {
			log.Println(err)
			return nil
		}
		info.Position = time.Duration(spos * float64(time.Second)).Milliseconds()
	}

	album, ok := cur["Album"]
	if ok {
		plid, err := uuid.ParseBytes([]byte(album))
		if err != nil {
			log.Println(err)
			return nil
		}

		pl, err := app.GetPlaylist(plid)
		if err != nil {
			log.Println(err)
			return nil
		}

		info.Playlist = pl.Id
		info.PlaylistName = pl.Title
	}

	title, ok := cur["Title"]
	if ok {
		info.Title = title
	}

	artist, ok := cur["Artist"]
	if ok {
		info.Channel = artist
	}

	location, ok := cur["Location"]
	if ok {
		info.Song = location
	}

	msg["payload"] = *info

	return msg
}

func (app *App) ambiancePlay(payload ...interface{}) {
	if !(len(payload) > 0) {
		log.Println("ambiance_play called without a payload.")
		return
	}

	var id string
	switch data := payload[0].(type) {
	case json.RawMessage:
		var err error
		err = json.Unmarshal(data, &id)
		if err != nil {
			log.Println(err)
			return
		}
	default:
		log.Println("loadPlaylist called with invalid payload.")
		return
	}

	amb, err := GetAmbiance(id)
	if err != nil {
		log.Println(err)
		return
	}

	f, err := os.Open(amb.Path)
	if err != nil {
		log.Println(err)
		return
	}

	play, err := opus.New(f)
	if err != nil {
		log.Println(err)
		return
	}

	loop := beep.Loop(-1, play)

	volume := &effects.Volume{
		Streamer: loop,
		Base:     2,
		Volume:   -2.5,
		Silent:   false,
	}

	discordspeaker.Lock()
	app.ambiance.Clear()
	app.ambiance.Add(volume)
	discordspeaker.Unlock()

	msg := make(map[string]interface{})
	out := make(map[string]interface{})

	app.curamb = amb

	msg["event"] = "ambiance_play"
	out["id"] = id
	msg["payload"] = out
	ws_msg <- msg
}

func (app *App) ambianceStop(payload ...interface{}) {
	log.Println("Stopping ambiance")
	discordspeaker.Lock()
	app.ambiance.Clear()
	discordspeaker.Unlock()

	msg := make(map[string]interface{})
	msg["event"] = "ambiance_stop"
	ws_msg <- msg

}

func (app *App) ambianceAdd(payload ...interface{}) {
	if !(len(payload) > 0) {
		log.Println("addPlaylist called without a payload.")
		return
	}

	log.Println("ambiance_add event received")

	var data map[string]string
	switch js := payload[0].(type) {
	case json.RawMessage:
		json.Unmarshal(js, &data)
	default:
		log.Println("newPlaylist called with invalid payload.")
		return
	}

	amburl, ok := data["url"]
	if !ok {
		log.Println("addPlaylist without url")
		return
	}
	ambtitle, ok := data["title"]
	if !ok {
		log.Println("addPlaylist without title")
		return
	}

	amb, err := AddAmbiance(amburl, ambtitle)
	if err != nil {
		log.Println(err)
		return
	}

	msg := make(map[string]interface{})
	out := make(map[string]interface{})
	msg["event"] = "ambiance_add"
	out["title"] = amb.Title
	out["id"] = amb.Id
	msg["payload"] = out
	ws_msg <- msg
}

func (app *App) songPosition(payload ...interface{}) {
	status, err := app.mpd.Status()
	if err != nil {
		log.Println(err)
		return
	}

	if status["state"] == "stop" {
		return
	}

	l.Do(func() {
		msg := make(map[string]interface{})
		out := make(map[string]interface{})

		slen, _ := strconv.ParseFloat(status["duration"], 64)
		spos, _ := strconv.ParseFloat(status["elapsed"], 64)

		msg["event"] = "song_position"
		out["len"] = time.Duration(slen * float64(time.Second)).Milliseconds()
		out["position"] = time.Duration(spos * float64(time.Second)).Milliseconds()

		msg["payload"] = out
		ws_msg <- msg
	})

}

func (app *App) songInfo(payload ...interface{}) {
	log.Println("song_info event received")

	msg := app.songInfoEvent("song_info")
	if msg != nil {
		ws_msg <- msg
	}
}

func (app *App) stop(payload ...interface{}) {
	log.Println("stop event received")

	app.plmutex.Lock()
	if app.plcancel != nil {
		app.plcancel()
	}
	app.mpd.Stop()
	app.plmutex.Unlock()

	msg := make(map[string]interface{})
	msg["event"] = "stop"

	ws_msg <- msg
}

func (app *App) prevSong(payload ...interface{}) {
	log.Println("prev_song event received")
	app.plmutex.Lock()
	err := app.mpd.Previous()
	app.plmutex.Unlock()
	if err != nil {
		log.Println(err)
	}
}

func (app *App) nextSong(payload ...interface{}) {
	log.Println("next_song event received")

	app.plmutex.Lock()
	err := app.mpd.Next()
	app.plmutex.Unlock()
	if err != nil {
		log.Println(err)
	}
}

func (app *App) addPlaylist(payload ...interface{}) {
	if !(len(payload) > 0) {
		log.Println("addPlaylist called without a payload.")
		return
	}

	log.Println("add_playlist event received")

	var data map[string]string
	switch js := payload[0].(type) {
	case json.RawMessage:
		json.Unmarshal(js, &data)
	default:
		log.Println("newPlaylist called with invalid payload.")
		return
	}

	plurl, ok := data["url"]
	if !ok {
		log.Println("addPlaylist without url")
		return
	}
	pltitle, ok := data["title"]
	if !ok {
		log.Println("addPlaylist without title")
		return
	}

	pl, err := url.Parse(plurl)
	if err != nil {
		log.Println("addPlaylist invalid url")
		return
	}

	plid := pl.Query().Get("list")
	if plid == "" {
		log.Println("addPlaylist missing list in url")
		return
	}

	_, err = ytdl_client.GetPlaylist(plurl)
	if err != nil {
		log.Println("Error getting youtube playlist info,", plid)
	}

	id, err := app.AddPlaylist(pltitle, plid)
	if err != nil {
		log.Println("Error getting youtube playlist info,", plid)
	}

	msg := make(map[string]interface{})

	msg["event"] = "new_playlist"
	msg["payload"] = map[string]string{"url": id.String(), "title": pltitle}

	ws_msg <- msg
}

func (app *App) loadPlaylist(payload ...interface{}) {
	log.Println("load_playlist event received")

	if !(len(payload) > 0) {
		log.Println("loadPlaylist called without a payload.")
		return
	}

	var id uuid.UUID
	switch data := payload[0].(type) {
	case json.RawMessage:
		var err error
		var tmp string

		json.Unmarshal(data, &tmp)
		id, err = uuid.Parse(tmp)
		if err != nil {
			log.Println("Unable to parse UUID,", err)
		}
	case uuid.UUID:
		id = data
	default:
		log.Println("loadPlaylist called with invalid payload.")
		return
	}

	log.Println("Loading new playlist: ", id)
	pl, err := app.GetPlaylist(id)
	if err != nil {
		log.Println("Unable to find playlist with id,", id)
		return
	}

	list, err := ytdl_client.GetPlaylist(pl.Url)

	if err != nil {
		log.Println("Error getting playlist info,", id)
		return
	}

	app.plmutex.Lock()
	if app.plcancel != nil {
		app.plcancel()
	}
	app.mpd.Stop()
	app.mpd.Clear()
	app.plmutex.Unlock()

	ctx, cancel := context.WithCancel(context.Background())
	app.plcancel = cancel

	go func() {
		defer cancel()

		for _, ytinfo := range list.Videos {
			log.Printf("Adding %s (%s - %s)", ytinfo.ID, ytinfo.Author, ytinfo.Title)

			vinfo, err := app.youtube.GetVideoFromID(ytinfo.ID)
			if err != nil {
				log.Println(err)
				continue
			}

			// Run as a local function so we can defer the mutex unlock incase one of these errors.
			ok := func() (ok bool) {
				app.plmutex.Lock()
				defer app.plmutex.Unlock()

				if ctx.Err() != nil {
					return false
				}

				ok = true

				// state:stop
				songid, err := app.mpd.AddID(vinfo.GetHLSPlaylist("234"), 0)
				if err != nil {
					log.Println(err)
					return
				}

				mpdcmd := app.mpd.Command("%s %d %s %s", mpd.Quoted("addtagid"), songid, mpd.Quoted("artist"), ytinfo.Author)
				err = mpdcmd.OK()
				if err != nil {
					log.Println(err)
					return
				}

				mpdcmd = app.mpd.Command("%s %d %s %s", mpd.Quoted("addtagid"), songid, mpd.Quoted("title"), ytinfo.Title)
				err = mpdcmd.OK()
				if err != nil {
					log.Println(err)
					return
				}

				mpdcmd = app.mpd.Command("%s %d %s %s", mpd.Quoted("addtagid"), songid, mpd.Quoted("location"), ytinfo.ID)
				err = mpdcmd.OK()
				if err != nil {
					log.Println(err)
					return
				}

				mpdcmd = app.mpd.Command("%s %d %s %s", mpd.Quoted("addtagid"), songid, mpd.Quoted("album"), pl.Id.String())
				err = mpdcmd.OK()
				if err != nil {
					log.Println(err)
					return
				}

				app.mpd.Play(-1)

				return
			}()

			if !ok {
				break
			}
		}
	}()
}