package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"net"
	"net/http"
	"os"
	"os/exec"
	"regexp"
	"strings"
	"time"

	"golang.org/x/net/html"
)

type MPVRequest struct {
	Command []string `json:"command"`
}
type MPVResponsePlayback struct {
	Data float64 `json:"data"`
}

type MPV struct {
	cmd        *exec.Cmd
	socketPath string
}

func NewMPV(streamUrl string, socketPath string) MPV {
	return MPV{
		cmd:        exec.Command("mpv", fmt.Sprintf("--input-ipc-server=%s", socketPath), streamUrl),
		socketPath: socketPath,
	}
}

func (mpv *MPV) Spawn() error {
	mpv.cmd.Stdout = io.Discard
	mpv.cmd.Stderr = os.Stderr

	return mpv.cmd.Start()
}

func (mpv *MPV) Stop() error {
	return mpv.cmd.Process.Kill()
}

func (mpv *MPV) ExecuteIPC(req *MPVRequest) ([]byte, error) {
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, err
	}
	reqBytes = append(reqBytes, byte('\n'))

	conn, err := net.Dial("unix", mpv.socketPath)
	if err != nil {
		return nil, err
	}
	defer conn.Close()

	_, err = conn.Write(reqBytes)
	if err != nil {
		return nil, err
	}

	resBytes := make([]byte, 1024)
	n, err := conn.Read(resBytes)
	if err != nil {
		return nil, err
	}

	return resBytes[:n], nil
}

func (mpv *MPV) InquirePlayback() (float64, error) {
	resBytes, err := mpv.ExecuteIPC(&MPVRequest{
		Command: []string{"get_property", "playback-time"},
	})
	if err != nil {
		return 0, err
	}

	var res MPVResponsePlayback
	if err = json.Unmarshal(resBytes, &res); err != nil {
		return 0, err
	}

	return res.Data, nil
}

func ParseWebMedia(url string) (string, error) {
	res, err := http.Get(url)
	if err != nil {
		return "", err
	}
	defer res.Body.Close()

	scripts := make([]string, 0)

	var processNode func(*html.Node)
	processNode = func(n *html.Node) {
		if n.Type == html.ElementNode && n.Data == "script" {
			if n.FirstChild != nil && n.FirstChild.Type == html.TextNode {
				scripts = append(scripts, n.FirstChild.Data)
			}
		}

		for c := n.FirstChild; c != nil; c = c.NextSibling {
			processNode(c)
		}
	}

	node, err := html.Parse(res.Body)
	if err != nil {
		return "", err
	}
	processNode(node)

	var streamChannels string

	for _, script := range scripts {
		if strings.Contains(script, "var streamChannels") {
			streamChannels = script
			break
		}
	}
	if streamChannels == "" {
		return "", fmt.Errorf("failed to find streamChannels")
	}

	re := regexp.MustCompile(`url:.*'(.*)'`)

	if match := re.FindAllStringSubmatch(streamChannels, 1); match != nil {
		return match[0][1], nil
	} else {
		return "", fmt.Errorf("regex failed")
	}
}

const MPTV_SPAWN_GRACE = 5 * time.Second
const MPTV_INQUIRE_INTERVAL = time.Second
const MPTV_MAX_ATTEMPTS = 1

var web string
var socketPath string

func main() {
	flag.StringVar(&web, "web", "", "web media")
	flag.StringVar(&socketPath, "sock", "", "where to place socket")
	flag.Parse()

	streamUrl, err := ParseWebMedia(web)
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to get stream: %s\n", err)
		return
	}

	mpv := NewMPV(streamUrl, socketPath)
	if err = mpv.Spawn(); err != nil {
		fmt.Fprintln(os.Stderr, err)
		return
	}
	time.Sleep(MPTV_SPAWN_GRACE)

	playback := 0.0
	lastPlayback := 0.0
	attempt := 0

	for {
		fmt.Printf("playback %f lastPlayback %f attempt %d\n", playback, lastPlayback, attempt)

		// inquire
		playback, err = mpv.InquirePlayback()
		if err != nil {
			// dead mpv, restart
			streamUrl, err = ParseWebMedia(web)
			if err != nil {
				fmt.Fprintf(os.Stderr, "failed to get stream: %s\n", err)
				// dont exit loop here since web request may fail due internet outage
			}

			mpv = NewMPV(streamUrl, socketPath)
			if err = mpv.Spawn(); err != nil {
				// failed to spawn mpv this time? fatal
				fmt.Fprintln(os.Stderr, err)
				return
			}

			// reset values
			playback = 0.0
			lastPlayback = 0.0
			attempt = 0

			// skip this cycle
			time.Sleep(MPTV_SPAWN_GRACE)
			continue
		}

		if lastPlayback == 0.0 {
			// first init of last playback, dont count as attempt
			lastPlayback = playback
		} else if playback == lastPlayback {
			// playback stuck, increment attempt
			attempt += 1
			if attempt > MPTV_MAX_ATTEMPTS {
				// attempts exceeded, shoot in the head old mpv
				mpv.Stop()

				// respawn mpv
				streamUrl, err = ParseWebMedia(web)
				if err != nil {
					fmt.Fprintf(os.Stderr, "failed to get stream: %s\n", err)
					// dont exit loop here since web request may fail due internet outage
				}

				mpv = NewMPV(streamUrl, socketPath)
				if err = mpv.Spawn(); err != nil {
					// failed to spawn mpv this time? fatal
					fmt.Fprintln(os.Stderr, err)
					return
				}

				// reset values
				playback = 0.0
				lastPlayback = 0.0
				attempt = 0

				// skip this cycle
				time.Sleep(MPTV_SPAWN_GRACE)
				continue
			}
		} else {
			// playback doesnt match last playback that was already initalized - we're good
			lastPlayback = playback
			attempt = 0
		}

		// new cycle
		time.Sleep(MPTV_INQUIRE_INTERVAL)
	}
}