package main

import (
	"flag"
	"fmt"
	"log"
	"log/slog"
	"net/http"
	"os"
	"time"

	"gitea.local.lab/Lbenedar/foundry_helper_service/internal/foundry"
)

type service_mode string

const (
	API_MODE         = "api"
	DISCORD_BOT_MODE = "discord"
	TG_BOT_MODE      = "tg"
)

type config struct {
	mode        service_mode
	port        string
	foundryHost string
	foundryPass string
}

type application struct {
	cfg        config
	foundryApp *foundry.Foundry
	slogger    *slog.Logger
	logger     *log.Logger
}

// TODO: change default values
func (app *application) parseFlags() {
	var mode string

	flag.StringVar(&mode, "service_mode", "api", "Type of service mode(api|discord|tg)")
	flag.StringVar(&app.cfg.port, "port", ":9090", "Service port")
	flag.StringVar(&app.cfg.foundryHost, "foundry_host", "127.0.0.1", "Address to connect to Foundry")
	flag.StringVar(&app.cfg.foundryPass, "foundry_pass", "", "Password to connect to Foundry")
	flag.Parse()

	app.cfg.mode = service_mode(mode)
}

func (app *application) ConnectToFoundry(foundryHost, foundryPass string) error {
	var err error

	if app.foundryApp == nil {
		app.foundryApp, err = foundry.NewFoundry(foundryHost)
		if err != nil {
			return err
		}
	}

	fmt.Printf("Foundry1: %v\n", app.foundryApp)

	ok, err := app.foundryApp.CheckSessionToken(foundryHost)
	if err != nil {
		return err
	}

	fmt.Printf("Foundry2: %v\n", app.foundryApp)

	if foundryPass != "" && !ok {
		err := app.foundryApp.Authenticate(foundryPass)
		if err != nil {
			return err
		}
	}

	fmt.Printf("Foundry3: %v\n", app.foundryApp)
	return nil
}

func (app *application) StartListenFoundry() {
	for {
		err := app.ConnectToFoundry(app.cfg.foundryHost, app.cfg.foundryPass)
		if err != nil {
			app.logger.Println(err)
			return
		}

		err = foundry.ConnectToWebSocket(app.foundryApp)
		if err != nil {
			app.logger.Println(err)
			return
		}

		err = app.foundryApp.StartListen()
		if err != nil && err != foundry.ListenIsDone {
			app.logger.Println(err)
			return
		}
	}
}

func main() {
	app := application{foundryApp: nil}

	app.parseFlags()
	app.slogger = slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))
	app.logger = slog.NewLogLogger(app.slogger.Handler(), slog.LevelInfo)

	go app.StartListenFoundry()

	server := &http.Server{
		Addr:     app.cfg.port,
		Handler:  app.routes(),
		ErrorLog: app.logger,
		// TLSConfig:    tlsConfig,
		IdleTimeout:  time.Minute,
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 10 * time.Second,
	}

	switch app.cfg.mode {
	case API_MODE:
		app.slogger.Info("Server is started", "port", app.cfg.port)
		server.ListenAndServe()
	case DISCORD_BOT_MODE:
		app.slogger.Warn("TODO: implement this mode")
	case TG_BOT_MODE:
		app.slogger.Warn("TODO: implement this mode")
	default:
		app.slogger.Error("Wrong Mode. Should be one of: 'api', 'discord', 'tg'", "mode", app.cfg.mode)
	}
}