package main

import (
	"context"
	"flag"
	"fmt"
	"io"
	"net"
	"net/http"
	"os"
	"os/signal"
	"path/filepath"
	"strings"
	"sync"
	"syscall"
	"time"
)

var liveState = map[string]bool{}
var dataMu sync.Mutex

func monitor(ctx context.Context, cfg *Config) {
	dataMu.Lock()
	for _, c := range cfg.Channels {
		liveState[c] = false
	}
	dataMu.Unlock()

	for {
		for _, c := range cfg.Channels {
			if ctx.Err() != nil {
				return
			}

			online, stream, err := isLive(ctx, cfg, c)
			if err != nil {
				logWarn("check %s: %v", c, err)
				continue
			}

			dataMu.Lock()
			prev := liveState[c]
			liveState[c] = online
			dataMu.Unlock()

			if !prev && online {
				logInfo("%s went live, stream id %s, title '%s'", c, stream.StreamID, stream.Title)
				err = updateRSSWithNewStream(ctx, cfg, &stream)
				if err != nil {
					logErr("update feed for %s: %v", c, err)
				}
			}
		}
		select {
		case <-ctx.Done():
			return
		case <-time.After(time.Duration(cfg.RefreshMinutes) * time.Minute):
		}
	}
}

func rssHandler(cfg *Config) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		parts := strings.Split(r.URL.Path, "/")
		if len(parts) < 3 {
			http.Error(w, "invalid feed", http.StatusBadRequest)
			return
		}
		channel := parts[len(parts)-1]

		f, err := os.Open(rssFilePath(channel, cfg))
		if err != nil {
			http.Error(w, "found no feed for given channel", http.StatusNotFound)
			return
		}
		defer f.Close()

		w.Header().Set("Content-Type", "application/xml")
		io.Copy(w, f)
	}
}

func sandbox(cfg *Config) error {
	_ = time.Local.String()

	paths := []struct{ path, perms string }{
		{filepath.Join(cfg.DataDir, "feeds"), "rwc"},
		{"/etc/ssl/cert.pem", "r"},
		{"/etc/resolv.conf", "r"},
		{"/etc/hosts", "r"},
		{"/dev/log", "rw"},
	}
	for _, p := range paths {
		if err := unveil(p.path, p.perms); err != nil {
			return fmt.Errorf("unveil %s: %w", p.path, err)
		}
	}
	if err := unveilBlock(); err != nil {
		return fmt.Errorf("unveil block: %w", err)
	}
	if err := pledge("stdio rpath wpath cpath fattr inet dns unix"); err != nil {
		return fmt.Errorf("pledge: %w", err)
	}
	return nil
}

func main() {
	debug := flag.Bool("d", false, "log to stderr instead of syslog")
	configFlag := flag.String("c", "", "path to config directory")
	flag.Usage = func() {
		fmt.Fprintf(flag.CommandLine.Output(), "usage: %s [-d] [-c config]\n", os.Args[0])
		flag.PrintDefaults()
	}
	flag.Parse()
	if flag.NArg() > 0 {
		flag.Usage()
		os.Exit(2)
	}

	path, err := findConfigDir(*configFlag)
	if err != nil {
		fatal("%v", err)
	}

	cfg, err := loadConfig(path)
	if err != nil {
		fatal("config: %v", err)
	}

	lock, err := lockDataDir(&cfg)
	if err != nil {
		fatal("%v", err)
	}
	defer lock.Close()

	if err := initEmptyFeeds(&cfg); err != nil {
		fatal("initialize empty feeds: %v", err)
	}

	if !*debug {
		if err := initSyslog(); err != nil {
			fatal("syslog: %v", err)
		}
	}

	logInfo("startup")
	logInfo("using config directory %s", path)
	logInfo("using data directory %s", cfg.DataDir)
	logInfo("monitoring channels: %s", strings.Join(cfg.Channels, ", "))
	logInfo("using %d CDN candidate domains", len(cfg.CDNDomains))

	srv := &http.Server{Addr: fmt.Sprintf(":%d", cfg.Port)}
	var ln net.Listener
	if cfg.ServeFeeds {
		ln, err = net.Listen("tcp", srv.Addr)
		if err != nil {
			fatal("listen: %v", err)
		}
	}

	if err := sandbox(&cfg); err != nil {
		fatal("sandbox: %v", err)
	}

	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()

	monitorDone := make(chan struct{})
	go func() {
		defer close(monitorDone)
		monitor(ctx, &cfg)
	}()

	serveErr := make(chan error, 1)
	if cfg.ServeFeeds {
		http.HandleFunc("/feed/", rssHandler(&cfg))
		go func() { serveErr <- srv.Serve(ln) }()
		logInfo("listening on %s", srv.Addr)
	} else {
		logInfo("not serving feeds")
	}

	select {
	case err := <-serveErr:
		fatal("listen: %v", err)
	case <-ctx.Done():
	}

	stop()
	logInfo("shutting down")

	shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	if err := srv.Shutdown(shutdownCtx); err != nil {
		logWarn("http shutdown: %v", err)
	}
	<-monitorDone
	logInfo("exiting")
}
