// UDP video sender. The browser receives this the same way GeForce NOW and
// Moonlight do: RTP over WebRTC, with the jitter buffer forced to zero.
// Signaling stays on the existing websocket. The picture does not.
package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strconv"
	"strings"
	"sync"
	"sync/atomic"
	"time"

	"github.com/pion/ice/v4"
	"github.com/pion/interceptor"
	"github.com/pion/rtcp"
	"github.com/pion/rtp"
	"github.com/pion/webrtc/v4"
	"github.com/pion/webrtc/v4/pkg/media"
)

const (
	playoutURI = "http://www.webrtc.org/experiments/rtp-hdrext/playout-delay"
	rtcAddr    = "127.0.0.1:6091"
)

type frame struct {
	data []byte
	key  bool
}

type peer struct {
	pc    *webrtc.PeerConnection
	track *webrtc.TrackLocalStaticSample
	gen   uint64
}

var (
	stateMu  sync.Mutex
	current  *peer
	iceReady atomic.Bool
	skip     atomic.Bool
	profile  atomic.Value // string

	keyMu   sync.Mutex
	keyFile *os.File
	lastKey time.Time

	frames = make(chan frame, 1)
)

func main() {
	profile.Store("640c1f")
	skip.Store(true)
	if fd := os.Getenv("HEIMSTREAM_KEY_FD"); fd != "" {
		n, err := strconv.Atoi(fd)
		if err != nil {
			fmt.Fprintf(os.Stderr, "key fd: %v\n", err)
			os.Exit(1)
		}
		keyFile = os.NewFile(uintptr(n), "key")
	}
	go readAnnexB(os.Stdin)
	go sendLoop()

	mux := http.NewServeMux()
	mux.HandleFunc("/health", func(w http.ResponseWriter, _ *http.Request) {
		w.Write([]byte("ok"))
	})
	mux.HandleFunc("/offer", func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
		if err != nil {
			http.Error(w, err.Error(), 400)
			return
		}
		answer, err := negotiate(string(body))
		if err != nil {
			fmt.Fprintf(os.Stderr, "offer: %v\n", err)
			http.Error(w, err.Error(), 500)
			return
		}
		w.Header().Set("Content-Type", "application/sdp")
		w.Write([]byte(answer))
	})
	fmt.Fprintf(os.Stderr, "webrtc auf http://%s/\n", rtcAddr)
	if err := http.ListenAndServe(rtcAddr, mux); err != nil {
		fmt.Fprintf(os.Stderr, "webrtc: %v\n", err)
		os.Exit(1)
	}
}

func forceKey() {
	keyMu.Lock()
	defer keyMu.Unlock()
	if keyFile == nil {
		fmt.Fprintf(os.Stderr, "kein key fd\n")
		return
	}
	lastKey = time.Now()
	if _, err := keyFile.Write([]byte("k\n")); err != nil {
		fmt.Fprintf(os.Stderr, "key write %v\n", err)
	} else {
		fmt.Fprintf(os.Stderr, "key angefordert\n")
	}
}

func enqueue(f frame) {
	if f.key {
		select {
		case frames <- f:
			return
		default:
		}
		select {
		case <-frames:
		default:
		}
		select {
		case frames <- f:
		default:
		}
		return
	}
	select {
	case frames <- f:
	default:
		skip.Store(true)
		forceKey()
	}
}

func sendLoop() {
	var sent, keys int
	tick := time.Now()
	var last time.Time
	for f := range frames {
		if !iceReady.Load() || (skip.Load() && !f.key) {
			continue
		}
		if f.key {
			skip.Store(false)
			keys++
		}
		stateMu.Lock()
		st := current
		stateMu.Unlock()
		if st == nil {
			continue
		}
		d := time.Second / 60
		now := time.Now()
		if !last.IsZero() {
			if gap := now.Sub(last); gap >= 5*time.Millisecond && gap <= 100*time.Millisecond {
				d = gap
			}
		}
		last = now
		if err := st.track.WriteSample(media.Sample{Data: f.data, Duration: d}); err != nil {
			fmt.Fprintf(os.Stderr, "sample %v\n", err)
			continue
		}
		sent++
		if time.Since(tick) >= time.Second {
			fmt.Fprintf(os.Stderr, "udp %d frames, %d key\n", sent, keys)
			sent, keys = 0, 0
			tick = time.Now()
		}
	}
}

func readAnnexB(r io.Reader) {
	buf := make([]byte, 0, 1<<20)
	tmp := make([]byte, 32*1024)
	var prefix []byte
	for {
		n, err := r.Read(tmp)
		if n > 0 {
			buf = append(buf, tmp[:n]...)
			var nal []byte
			for {
				nal, buf = nextNAL(buf)
				if nal == nil {
					break
				}
				if len(nal) == 0 {
					continue
				}
				kind := nal[0] & 0x1F
				raw := make([]byte, 4+len(nal))
				raw[3] = 1
				copy(raw[4:], nal)
				switch kind {
				case 7:
					if len(nal) >= 4 {
						profile.Store(fmt.Sprintf("%02x%02x%02x", nal[1], nal[2], nal[3]))
					}
					prefix = append(prefix, raw...)
				case 8:
					prefix = append(prefix, raw...)
				case 1, 5:
					au := append(append([]byte{}, prefix...), raw...)
					prefix = nil
					if kind == 5 {
						fmt.Fprintf(os.Stderr, "idr %d\n", len(au))
					}
					enqueue(frame{data: au, key: kind == 5})
				}
			}
		}
		if err != nil {
			fmt.Fprintf(os.Stderr, "capture ende: %v\n", err)
			os.Exit(1)
		}
	}
}

func nextNAL(buf []byte) ([]byte, []byte) {
	start, size := findStart(buf, 0)
	if start < 0 {
		if len(buf) > 4 {
			return nil, buf[len(buf)-4:]
		}
		return nil, buf
	}
	next, _ := findStart(buf, start+size)
	if next < 0 {
		return nil, buf[start:]
	}
	return buf[start+size : next], buf[next:]
}

func findStart(buf []byte, from int) (int, int) {
	for i := from; i+3 < len(buf); i++ {
		if buf[i] == 0 && buf[i+1] == 0 {
			if buf[i+2] == 1 {
				return i, 3
			}
			if i+3 < len(buf) && buf[i+2] == 0 && buf[i+3] == 1 {
				return i, 4
			}
		}
	}
	return -1, 0
}

func currentProfile() string {
	if v, ok := profile.Load().(string); ok && len(v) == 6 {
		return v
	}
	return "640c1f"
}

func negotiate(offerSDP string) (string, error) {
	m := &webrtc.MediaEngine{}
	profiles := []string{currentProfile(), "640c1f", "640028", "64001f"}
	seen := map[string]bool{}
	var pt webrtc.PayloadType = 96
	for _, id := range profiles {
		if seen[id] {
			continue
		}
		seen[id] = true
		err := m.RegisterCodec(webrtc.RTPCodecParameters{
			RTPCodecCapability: webrtc.RTPCodecCapability{
				MimeType:    webrtc.MimeTypeH264,
				ClockRate:   90000,
				SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=" + id,
				RTCPFeedback: []webrtc.RTCPFeedback{
					{Type: "nack"},
					{Type: "nack", Parameter: "pli"},
				},
			},
			PayloadType: pt,
		}, webrtc.RTPCodecTypeVideo)
		if err != nil {
			return "", err
		}
		pt += 2
	}
	if err := m.RegisterHeaderExtension(webrtc.RTPHeaderExtensionCapability{URI: playoutURI}, webrtc.RTPCodecTypeVideo); err != nil {
		return "", err
	}
	reg := &interceptor.Registry{}
	reg.Add(&playoutFactory{})
	se := webrtc.SettingEngine{}
	se.SetICEMulticastDNSMode(ice.MulticastDNSModeDisabled)
	se.SetNetworkTypes([]webrtc.NetworkType{webrtc.NetworkTypeUDP4})
	se.SetInterfaceFilter(func(name string) bool {
		return name == "en0" || name == "en1"
	})
	api := webrtc.NewAPI(
		webrtc.WithMediaEngine(m),
		webrtc.WithInterceptorRegistry(reg),
		webrtc.WithSettingEngine(se),
	)

	pc, err := api.NewPeerConnection(webrtc.Configuration{
		ICEServers: []webrtc.ICEServer{{
			URLs: []string{"stun:stun.l.google.com:19302", "stun:stun.cloudflare.com:3478"},
		}},
	})
	if err != nil {
		return "", err
	}
	track, err := webrtc.NewTrackLocalStaticSample(webrtc.RTPCodecCapability{
		MimeType:    webrtc.MimeTypeH264,
		ClockRate:   90000,
		SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=" + currentProfile(),
	}, "video", "heimstream")
	if err != nil {
		pc.Close()
		return "", err
	}
	if err = pc.SetRemoteDescription(webrtc.SessionDescription{Type: webrtc.SDPTypeOffer, SDP: offerSDP}); err != nil {
		pc.Close()
		return "", err
	}
	sender, err := pc.AddTrack(track)
	if err != nil {
		pc.Close()
		return "", err
	}
	my := atomic.AddUint64(&generation, 1)
	iceReady.Store(false)
	go readRTCP(sender, my)
	pc.OnConnectionStateChange(func(s webrtc.PeerConnectionState) {
		if atomic.LoadUint64(&generation) != my {
			return
		}
		fmt.Fprintf(os.Stderr, "ice %s\n", s.String())
		switch s {
		case webrtc.PeerConnectionStateConnected:
			iceReady.Store(true)
			skip.Store(true)
			forceKey()
		case webrtc.PeerConnectionStateFailed, webrtc.PeerConnectionStateDisconnected, webrtc.PeerConnectionStateClosed:
			iceReady.Store(false)
		}
	})
	answer, err := pc.CreateAnswer(nil)
	if err != nil {
		pc.Close()
		return "", err
	}
	gathered := webrtc.GatheringCompletePromise(pc)
	if err = pc.SetLocalDescription(answer); err != nil {
		pc.Close()
		return "", err
	}
	select {
	case <-gathered:
	case <-time.After(3 * time.Second):
	}
	stateMu.Lock()
	old := current
	current = &peer{pc: pc, track: track, gen: my}
	stateMu.Unlock()
	if old != nil {
		old.pc.Close()
	}
	if pc.ConnectionState() == webrtc.PeerConnectionStateConnected {
		iceReady.Store(true)
		skip.Store(true)
		forceKey()
	}
	sdp := fixRelated(pc.LocalDescription().SDP)
	fmt.Fprintf(os.Stderr, "answer profil %s candidates %d\n", currentProfile(), strings.Count(sdp, "a=candidate:"))
	return sdp, nil
}

func fixRelated(sdp string) string {
	host := "192.168.0.11"
	for _, ln := range strings.Split(sdp, "\n") {
		if !strings.Contains(ln, "typ host") {
			continue
		}
		f := strings.Fields(ln)
		if len(f) >= 5 && !strings.Contains(f[4], ":") {
			host = f[4]
			break
		}
	}
	return strings.ReplaceAll(sdp, "raddr 0.0.0.0", "raddr "+host)
}

var generation uint64

func readRTCP(sender *webrtc.RTPSender, my uint64) {
	buf := make([]byte, 1500)
	for {
		if atomic.LoadUint64(&generation) != my {
			return
		}
		n, _, err := sender.Read(buf)
		if err != nil {
			return
		}
		pkts, err := rtcp.Unmarshal(buf[:n])
		if err != nil {
			continue
		}
		for _, pkt := range pkts {
			switch pkt.(type) {
			case *rtcp.PictureLossIndication, *rtcp.FullIntraRequest:
				skip.Store(true)
				forceKey()
			}
		}
	}
}

type playoutFactory struct{}

func (p *playoutFactory) NewInterceptor(string) (interceptor.Interceptor, error) {
	return &playoutDelay{}, nil
}

type playoutDelay struct{}

func (p *playoutDelay) BindRTCPReader(r interceptor.RTCPReader) interceptor.RTCPReader { return r }
func (p *playoutDelay) BindRTCPWriter(w interceptor.RTCPWriter) interceptor.RTCPWriter { return w }
func (p *playoutDelay) UnbindLocalStream(*interceptor.StreamInfo)                     {}
func (p *playoutDelay) UnbindRemoteStream(*interceptor.StreamInfo)                    {}
func (p *playoutDelay) Close() error                                                  { return nil }
func (p *playoutDelay) BindRemoteStream(_ *interceptor.StreamInfo, reader interceptor.RTPReader) interceptor.RTPReader {
	return reader
}
func (p *playoutDelay) BindLocalStream(info *interceptor.StreamInfo, writer interceptor.RTPWriter) interceptor.RTPWriter {
	var id uint8
	for _, ext := range info.RTPHeaderExtensions {
		if ext.URI == playoutURI {
			id = uint8(ext.ID)
		}
	}
	// 12-bit min and max, in 10ms units. Zero means play immediately.
	payload := []byte{0, 0, 0}
	return interceptor.RTPWriterFunc(func(header *rtp.Header, packet []byte, attrs interceptor.Attributes) (int, error) {
		if id != 0 {
			header.SetExtension(id, payload)
		}
		return writer.Write(header, packet, attrs)
	})
}
