package main

import (
	"fmt"
	"log"
	"os"
	"os/signal"
	"time"
)

func main() {
	logger := log.Default()

	logger.Println("Opening DB connection")
	db, err := NewDatabaseConnection()
	if err != nil {
		log.Fatalf("failed to open db: ", err)
	}

	logger.Println("Ensuring migrations")
	err = db.EnsureMigrations()
	if err != nil {
		log.Fatalf("failed to ensure migrations: ", err)
	}

	logger.Println("Preparing post chan -> db consumer")
	chanPosts := make(chan *DatabasePost, 1000)
	go db.StreamPostsFromChannel(chanPosts)

	logger.Println("Installing interrupt handler")
	interrupt := make(chan os.Signal, 1)
	signal.Notify(interrupt, os.Interrupt)

	/*
		logger.Println("Creating JS2 firehose websocket consumer")
		consumerJS2 := MakeConsumer(URL_RELAY_JETSTREAM2)
		defer consumerJS2.Close()

		logger.Println("Starting JS2 firehose consumer")
		go consumerJS2.StartConsumer(
			streamPostsToDbCurry(chanPosts),
		)

		consumer := consumerJS2
	*/

	logger.Println("Creating Blacksky firehose websocket consumer")
	consumerBlksky := MakeConsumer(URL_RELAY_BLACKSKY)
	defer consumerBlksky.Close()

	logger.Println("Initiating message handlers")
	go func() {
		decoder := CBORDecoder(chanPosts)
		for {
			select {
			case data := <-*consumerBlksky.MessagesChan:
				decoder(data)
			}
		}
	}()

	go func() {
		decoder := CBORDecoder(chanPosts)
		for {
			select {
			case data := <-*consumerBlksky.MessagesChan:
				decoder(data)
			}
		}
	}()

	logger.Println("Starting Blacksky firehose consumer")
	go consumerBlksky.StartConsumer(
	// CBORDecoder(chanPosts),
	)

	consumer := consumerBlksky

	logger.Println("Creating HTTP server")
	server := NewHTTPServer(db)

	logger.Println("Registering routes")
	server.RegisterRoutes()

	logger.Println("Starting HTTP server")
	go server.StartListener()

	logger.Println("System is now running until it isn't")
	for {
		select {
		case <-*consumer.DoneSignal:
			logger.Println("ws goroutine closed, goodbye")
			return
		case <-*server.DoneSignal:
			logger.Println("http server closed, goodbye")
			err := consumer.CloseWithTimeout(time.Second)
			if err != nil {
				logger.Println("failed to close ws: ", err)
			}

			return
		case <-interrupt:
			fmt.Println()
			err := consumer.CloseWithTimeout(time.Second)
			if err != nil {
				logger.Println("failed to close ws: ", err)
			}

			return
		}
	}
}