package radio

import (
	"bytes"
	"dwelling-radio/pkg/watcher"
	"encoding/json"
	"io"
	"net/http"
	"os"
	"strings"
	"sync"
	"syscall"
	"time"

	"github.com/pkg/errors"
)

const (
	IcecastPlaylistDateFormat = "02/Jan/2006:15:04:05 -0700"
	SongTimeFormat            = "2006 15:04-0700"

	bufferSize = 8192
)

type IcecastStatusDTO struct {
	Icestats struct {
		ServerStartISO8601 string `json:"server_start_iso8601"`
		ServerStartDate    string `json:"server_start"`
		Source             struct {
			Artist       string `json:"artist"`
			Title        string `json:"title"`
			ListenerPeak int    `json:"listener_peak"`
			Listeners    int    `json:"listeners"`
		} `json:"source"`
	} `json:"icestats"`
}

func (is *IcecastStatusDTO) Song() string {
	return is.Icestats.Source.Artist + " - " + is.Icestats.Source.Title
}

type IcecastStatus struct {
	ServerStartISO8601 string `json:"server_start_iso8601"`
	ServerStartDate    string `json:"server_start_date"`
	SongName           string `json:"song"`
	ListenerPeak       int    `json:"listener_peak"`
	Listeners          int    `json:"listeners"`
}

type Song struct {
	Time      string `json:"time"`
	Listeners string `json:"listeners"`
	Song      string `json:"song"`
}

func IcecastGetStatus(icecastURL string) (*IcecastStatus, error) {
	resp, err := http.Get(icecastURL)
	if err != nil {
		return nil, err
	}

	iceStatDTO := &IcecastStatusDTO{}

	if err := json.NewDecoder(resp.Body).Decode(iceStatDTO); err != nil {
		return nil, err
	}

	return &IcecastStatus{
		ServerStartISO8601: iceStatDTO.Icestats.ServerStartISO8601,
		ServerStartDate:    iceStatDTO.Icestats.ServerStartDate,
		SongName:           iceStatDTO.Song(),
		ListenerPeak:       iceStatDTO.Icestats.Source.ListenerPeak,
		Listeners:          iceStatDTO.Icestats.Source.Listeners,
	}, nil
}

func IcecastLastPlayedSongs(lastNSongs int, playlistPath string) ([]Song, error) {
	{
		lastPlayedCacheMutex.Lock()
		defer lastPlayedCacheMutex.Unlock()
		if lpcLen := len(lastPlayedCache); lpcLen > 0 {
			if lastNSongs > lpcLen {
				lastNSongs = lpcLen
			}
			var ret []Song = make([]Song, lastNSongs)
			copy(ret[:], lastPlayedCache[lpcLen-lastNSongs:])
			return ret, nil
		}
	}

	return make([]Song, 0), nil
}

func IcecastLastSong(playlistPath string) (Song, error) {
	{
		lastPlayedCacheMutex.Lock()
		defer lastPlayedCacheMutex.Unlock()
		if lpcLen := len(lastPlayedCache); lpcLen > 0 {
			return lastPlayedCache[lpcLen-1], nil
		}
	}

	song, err := lastPlayedSong(playlistPath)
	if err != nil {
		return Song{}, err
	}

	return *song, nil
}

func lastPlayedSong(playlistPath string) (*Song, error) {
	buf := make([]byte, bufferSize)
	var last_song_line string

	playlist, err := os.Open(playlistPath)
	if err != nil {
		return nil, err
	}

	playlist_stat, _ := playlist.Stat()

	if playlist_stat.Size() == 0 {
		return nil, nil
	}

	playlist.Seek(-bufferSize, os.SEEK_END)

	_, err = playlist.Read(buf)
	if err != nil && err != io.EOF {
		return nil, err
	}

	newline_end_pos := bytes.LastIndexByte(buf, '\n')

	if newline_end_pos == -1 && !bytes.ContainsRune(buf, '|') {
		return nil, nil
	} else if newline_end_pos == -1 {
		newline_end_pos = len(buf)
	}

	newline_start_pos := bytes.LastIndexByte(buf[:newline_end_pos-1], '\n')

	last_song_line = string(buf[newline_start_pos+1 : newline_end_pos-1])

	if strings.Count(last_song_line, "|") != 3 {
		return nil, nil
	}

	fields := strings.Split(last_song_line, "|")

	tim, _ := time.Parse(IcecastPlaylistDateFormat, fields[0])

	return &Song{
		Time:      tim.Format(SongTimeFormat),
		Listeners: fields[2],
		Song:      fields[3]}, nil
}

var playlistWatcher watcher.InotifyWatcher
var playlistFired chan uint32 = make(chan uint32)
var lastPlayedCache []Song = make([]Song, 10)
var lastPlayedCacheMutex sync.Mutex

func IcecastWatchPlaylist(playlistPath string, lastNSongs int) error {
	playlistWatcher, err := watcher.NewInotifyWatcher()
	if err != nil {
		return errors.Wrap(err, "cannot instantiate inotify watcher")
	}

	err = playlistWatcher.AddWatch(playlistPath, watcher.ModIgnMask)
	if err != nil {
		return errors.Wrap(err, "cannot set a playlist to watch")
	}

	playlistWatcher.WatchForMask(playlistFired, watcher.ModIgnMask)

	go func() {
		for {
			select {
			case mask := <-playlistFired:
				if mask&syscall.IN_MODIFY > 0 {
					lastPlayedCacheMutex.Lock()
					if song, err := lastPlayedSong(playlistPath); err == nil {
						lastPlayedCache = append(lastPlayedCache, *song)
						if len(lastPlayedCache) > lastNSongs {
							lastPlayedCache = lastPlayedCache[1:]
						}
					}
					lastPlayedCacheMutex.Unlock()
				} else if mask&syscall.IN_IGNORED > 0 {
					playlistWatcher.Close()
					IcecastWatchPlaylist(playlistPath, lastNSongs)
					return
				}
			}
		}
	}()

	return nil
}

func IcecastWatchClose() {
	playlistWatcher.Close()
}