go-eve-pi/main.go

package main

import (
	"context"
	"encoding/json"
	"flag"
	"os"
	"os/signal"
	"strconv"

	"go-eve-pi/esi"
	wh "go-eve-pi/webhook"

	logger "git.site.quack-lab.dev/dave/cylogger"

	"github.com/fasthttp/router"
	"github.com/valyala/fasthttp"
)

var webhook wh.Webhook

func main() {
	// Add flag for generating .env.example
	help := flag.Bool("h", false, "Show help")
	flag.Parse()

	if *help {
		flag.PrintDefaults()
		if err := GenerateEnvExample(); err != nil {
			logger.Error("Failed to generate .env.example: %v", err)
			os.Exit(1)
		}
		logger.Info("Generated .env.example")
		os.Exit(0)
	}

	logger.Init(logger.ParseLevel(options.LogLevel))
	logger.Info("Starting Eve PI")

	// Create SSO instance
	sso, err := NewSSO(
		options.ClientID,
		options.RedirectURI,
		options.Scopes,
	)
	if err != nil {
		logger.Error("Failed to create SSO instance %v", err)
		return
	}

	webhook = wh.NewZulipWebhook(options.WebhookURL, options.WebhookEmail, options.WebhookToken)

	// Setup fasthttp router
	r := router.New()

	// Configure SSO to use existing fasthttp router
	sso.SetRouter(r)

	// Add your own routes
	r.GET("/", func(ctx *fasthttp.RequestCtx) {
		ctx.SetStatusCode(fasthttp.StatusOK)
		ctx.WriteString("EVE PI Server Running")
	})

	r.GET("/login/{character}", func(ctx *fasthttp.RequestCtx) {
		charName := ctx.UserValue("character")
		charNameStr, ok := charName.(string)
		if !ok || charNameStr == "" {
			ctx.SetStatusCode(fasthttp.StatusBadRequest)
			ctx.WriteString("Missing character parameter")
			return
		}
		logger.Info("Login requested for character %s", charNameStr)
		// Trigger the auth flow (will register callback if needed)
		char, err := sso.GetCharacter(context.Background(), charNameStr)
		if err != nil {
			logger.Error("Failed to authenticate character %s: %v", charNameStr, err)
			ctx.SetStatusCode(fasthttp.StatusInternalServerError)
			ctx.WriteString("Authentication failed")
			return
		}
		logger.Info("Successfully authenticated character %s", charNameStr)
		ctx.SetContentType("text/plain")
		ctx.SetStatusCode(fasthttp.StatusOK)
		ctx.WriteString("Authenticated! Access token: " + char.AccessToken)
	})

	// Get planets for a character
	r.GET("/planets/{character}", func(ctx *fasthttp.RequestCtx) {
		charName := ctx.UserValue("character")
		charNameStr, ok := charName.(string)
		if !ok || charNameStr == "" {
			ctx.SetStatusCode(fasthttp.StatusBadRequest)
			ctx.WriteString("Missing character parameter")
			return
		}

		logger.Info("Fetching planets for character %s", charNameStr)

		// Get access token for character
		char, err := sso.GetCharacter(context.Background(), charNameStr)
		if err != nil {
			logger.Error("Failed to get token for character %s: %v", charNameStr, err)
			ctx.SetStatusCode(fasthttp.StatusInternalServerError)
			ctx.WriteString("Authentication failed")
			return
		}

		// Fetch planets using ESI API
		planets, err := esi.GetCharacterPlanets(context.Background(), int(char.ID), char.AccessToken)
		if err != nil {
			logger.Error("Failed to fetch planets for character %s: %v", charNameStr, err)
			ctx.SetStatusCode(fasthttp.StatusInternalServerError)
			ctx.WriteString("Failed to fetch planets")
			return
		}

		// Return planets as JSON
		ctx.SetContentType("application/json")
		ctx.SetStatusCode(fasthttp.StatusOK)
		json.NewEncoder(ctx).Encode(planets)
	})

	// Get detailed planet information
	r.GET("/planet/{character}/{planet_id}", func(ctx *fasthttp.RequestCtx) {
		charName := ctx.UserValue("character")
		charNameStr, ok := charName.(string)
		if !ok || charNameStr == "" {
			ctx.SetStatusCode(fasthttp.StatusBadRequest)
			ctx.WriteString("Missing character parameter")
			return
		}

		planetIDStr := ctx.UserValue("planet_id")
		planetID, err := strconv.Atoi(planetIDStr.(string))
		if err != nil {
			ctx.SetStatusCode(fasthttp.StatusBadRequest)
			ctx.WriteString("Invalid planet ID")
			return
		}

		logger.Info("Fetching planet details for character %s, planet %d", charNameStr, planetID)

		// Get access token for character
		char, err := sso.GetCharacter(context.Background(), charNameStr)
		if err != nil {
			logger.Error("Failed to get token for character %s: %v", charNameStr, err)
			ctx.SetStatusCode(fasthttp.StatusInternalServerError)
			ctx.WriteString("Authentication failed")
			return
		}

		// Fetch planet details using ESI API
		planetDetail, err := esi.GetPlanetDetails(context.Background(), int(char.ID), planetID, char.AccessToken)
		if err != nil {
			logger.Error("Failed to fetch planet details for character %s, planet %d: %v", charNameStr, planetID, err)
			ctx.SetStatusCode(fasthttp.StatusInternalServerError)
			ctx.WriteString("Failed to fetch planet details")
			return
		}

		// Return planet details as JSON
		ctx.SetContentType("application/json")
		ctx.SetStatusCode(fasthttp.StatusOK)
		json.NewEncoder(ctx).Encode(planetDetail)
	})

	// Get all planets with their details for a character
	r.GET("/planets-full/{character}", func(ctx *fasthttp.RequestCtx) {
		charName := ctx.UserValue("character")
		charNameStr, ok := charName.(string)
		if !ok || charNameStr == "" {
			ctx.SetStatusCode(fasthttp.StatusBadRequest)
			ctx.WriteString("Missing character parameter")
			return
		}

		logger.Info("Fetching full planet data for character %s", charNameStr)

		// Get access token for character
		char, err := sso.GetCharacter(context.Background(), charNameStr)
		if err != nil {
			logger.Error("Failed to get token for character %s: %v", charNameStr, err)
			ctx.SetStatusCode(fasthttp.StatusInternalServerError)
			ctx.WriteString("Authentication failed")
			return
		}

		// Fetch planets list
		planets, err := esi.GetCharacterPlanets(context.Background(), int(char.ID), char.AccessToken)
		if err != nil {
			logger.Error("Failed to fetch planets for character %s: %v", charNameStr, err)
			ctx.SetStatusCode(fasthttp.StatusInternalServerError)
			ctx.WriteString("Failed to fetch planets")
			return
		}

		// Fetch details for each planet
		type PlanetWithDetails struct {
			Planet  esi.Planet
			Details *esi.PlanetDetail
		}

		var planetsWithDetails []PlanetWithDetails
		for _, planet := range planets {
			details, err := esi.GetPlanetDetails(context.Background(), int(char.ID), planet.PlanetID, char.AccessToken)
			if err != nil {
				logger.Warning("Failed to fetch details for planet %d: %v", planet.PlanetID, err)
				// Continue with other planets even if one fails
				details = nil
			}

			planetsWithDetails = append(planetsWithDetails, PlanetWithDetails{
				Planet:  planet,
				Details: details,
			})
		}

		// Return planets with details as JSON
		ctx.SetContentType("application/json")
		ctx.SetStatusCode(fasthttp.StatusOK)
		json.NewEncoder(ctx).Encode(planetsWithDetails)
	})

	logger.Info("Starting web server on 0.0.0.0:%s", options.Port)
	go func() {
		if err := fasthttp.ListenAndServe("0.0.0.0:"+options.Port, r.Handler); err != nil {
			logger.Error("Server failed: %v", err)
		}
	}()

	// for i := 0; i < 100; i++ {
	// 	logger.Info("Sending test webhook %d", i)
	// 	go func() {
	// 	err := webhook.Post("EvePI", "test", "test" + strconv.Itoa(i))
	// 		if err != nil {
	// 			logger.Error("Failed to send test webhook %d: %v", i, err)
	// 		}
	// 	}()
	// }

	// Listen for SIGINT and gracefully shut down the server
	sigCh := make(chan os.Signal, 1)
	signal.Notify(sigCh, os.Interrupt)
	<-sigCh
	logger.Info("SIGINT received, shutting down web server gracefully...")
	logger.Info("Web server shut down cleanly")
}