package main

import (
	"io"
	"log"
	"net/http"
	"strconv"
	"time"

	"git.icedream.tech/icedream/uplink/app/sources"
	"git.icedream.tech/icedream/uplink/app/streams"

	humanize "github.com/dustin/go-humanize"
	"github.com/gorilla/mux"
	"github.com/viert/lame"
)

func main() {
	stream := streams.NewStream(128 * 1024)

	wr := lame.NewWriter(stream)
	wr.Encoder.SetBitrate(192)
	wr.Encoder.SetQuality(1)
	wr.Encoder.SetInSamplerate(44100)
	wr.Encoder.SetNumChannels(2)
	wr.Encoder.InitParams()

	go func() {
		log.Println("Sine stream goroutine started")

		sine := new(sources.SineStream)
		sine.Samplerate = 44100
		sine.Frequency = 990
		sine.Beep = true
		sine.Timestamp = time.Now()

		log.Println("Will now broadcast sine stream")
		n, err := io.Copy(wr, sine)
		if err != nil {
			log.Fatal("Sine stream copy failed:", err)
		}
		log.Println("Sine stream finished, written", humanize.Bytes(uint64(n)), "bytes")
	}()

	server := new(http.Server)
	mux := mux.NewRouter()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		log.Println("Got a listener")

		w.Header().Set("content-type", "audio/mpeg")
		w.Header().Set("server", "Uplink/0.0.0")
		if r.Header.Get("icy-metadata") == "1" {
			w.Header().Set("icy-metadata", "1")
			w.Header().Set("icy-metaint", strconv.Itoa(2*1024))
		}
		w.WriteHeader(200)

		cancel := w.(http.CloseNotifier).CloseNotify()

		sr := streams.NewStreamReader(stream)
		var n int64
		var err error
		if r.Header.Get("icy-metadata") == "1" {
			mstream := streams.NewMetadataInjector(sr, 2*1024)
			mstream.Metadata = map[string]string{
				"StreamTitle": "beep",
			}
			go func() {
				for {
					select {
					case <-cancel:
						return
					case <-time.After(time.Second):
						mstream.Metadata["StreamTitle"] = "beep - time: " + time.Now().String()
					}
				}
			}()
			mstream.Metadata = map[string]string{
				"StreamTitle": "DreamNetwork - Testing",
			}
			n, err = io.Copy(w, mstream)
		} else {
			n, err = io.Copy(w, sr)
		}
		log.Println("Transmitted", humanize.Bytes(uint64(n)))
		if err != nil {
			log.Println("Client transmission error:", err)
		}

		/*notify := w.(http.CloseNotifier).CloseNotify()
		data := make([]byte, 4096)

		log.Println("Start client tx loop")
		for {
			select {
			case <-notify:
				log.Println("Stop client tx loop")
				sr.Close()
				return
			default:
				n, err := sr.Read(data)
				if err != nil {
					log.Println("Read from stream failed:", err)
					return
				}
				n, err = w.Write(data[0:n])
				if err != nil {
					log.Println("Write to client failed:", err)
					log.Println("Stop client tx loop")
					sr.Close()
					return
				}
			}
		}*/
	})
	server.Handler = mux
	server.Addr = ":8080"
	server.ListenAndServe()
}