package main

import (
	"context"
	"fmt"
	"io"
	"os"
	"os/exec"
	"os/signal"
	"strings"
	"syscall"
	"time"

	runtime "github.com/banzaicloud/logrus-runtime-formatter"
	"github.com/sirupsen/logrus"
)

var logger = logrus.New()
var appConfig AppConfig

// TODO: This function needs to be refactored
func setLogLevel() {
	level := os.Getenv("LOG_LEVEL")
	verbosity := os.Getenv("VERBOSE")

	if verbosity == "1" {
		formatter := runtime.Formatter{ChildFormatter: &logrus.TextFormatter{
			FullTimestamp: true,
		}}
		formatter.Line = true

		logger.SetFormatter(&formatter)
	}

	//TODO: This should be in its own function
	logFile, err := os.OpenFile("rsslair.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
	if err != nil {
		logger.Fatal(err)
	}
	mw := io.MultiWriter(os.Stdout, logFile)
	logger.SetOutput(mw)

	switch strings.ToLower(level) {
	case "debug":
		logger.SetLevel(logrus.DebugLevel)
	case "info":
		logger.SetLevel(logrus.InfoLevel)
	case "warn":
		logger.SetLevel(logrus.WarnLevel)
	case "error":
		logger.SetLevel(logrus.ErrorLevel)
	case "trace":
		logger.SetLevel(logrus.TraceLevel)
	default:
		logger.SetLevel(logrus.InfoLevel)
	}
}

func main() {
	setLogLevel()
	loadAppConfig()

	lua := InitLua()
	defer CloseDb()
	defer lua.Close()

	// Create a channel to listen for signals
	// Listen for SIGINT and SIGTERM
	sig_channel := make(chan os.Signal, 1)
	signal.Notify(sig_channel, os.Interrupt, syscall.SIGTERM)

	address := "0.0.0.0"
	port := "8080"
	server := start_server(address, port, lua)

	// TODO: Make this look nice
	// Create channel to listen for input
	go func() {
		// disable input buffering
		exec.Command("stty", "-F", "/dev/tty", "cbreak", "min", "1").Run()
		// do not display entered characters on the screen
		exec.Command("stty", "-F", "/dev/tty", "-echo").Run()
		// restore the echoing state when exiting
		defer exec.Command("stty", "-F", "/dev/tty", "echo").Run()

		var b = make([]byte, 1)
		for {
			os.Stdin.Read(b)
			switch char := string(b); char {
			case "r":
				fmt.Println("Reloading scripts")
				routes = make(map[string]string)
				LoadScripts(lua)
			case "s":
				fmt.Println("Executing lua scripts")
				execute_all_routes(lua)
			case "d":
				fmt.Println("Dumping response data")
				for k, v := range responses {
					leng := len(v)
					if leng > 30 {
						leng = 30
					} else if leng == 0 {
						fmt.Println(k, "No response data")
						continue
					}

					msg := v[:leng]
					fmt.Println(k, msg)
				}
			}

		}
	}()

	execute_all_routes(lua)

	// TODO: Make this look nice in an actual function
	hasRun := false
	luaExecutionTimer := time.NewTicker(30 * time.Second)
	go func() {
		for {
			select {
			case <-luaExecutionTimer.C:
				now := time.Now()
				if now.Minute() == 55 && !hasRun {
					hasRun = true
					execute_all_routes(lua)
					break
				}
				hasRun = false
			}
		}
	}()

	<-sig_channel // Block until SIGINT or SIGTERM is received
	logger.Info("Shutting down now")
	if err := server.Shutdown(context.TODO()); err != nil {
		logger.Fatal("Error shutting down server: ", err)
	}
}