package serve

import (
	"context"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"log/slog"
	"os"
	"os/signal"
	"time"

	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/cmd"
	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/cmd/utils"
	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/internal/client"
	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/internal/db"
	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/internal/middlewares"
	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/internal/model"
	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/internal/storage"
	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/logger"
	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/server"
	"git.faercol.me/faercol/polyculeconnect/polyculeconnect/services"
	"github.com/go-jose/go-jose/v4"
	"github.com/google/uuid"
	"github.com/spf13/cobra"
	"github.com/zitadel/oidc/v3/pkg/op"
	"go.uber.org/zap/exp/zapslog"
)

var configPath string

const stopTimeout = 10 * time.Second

// serveCmd represents the serve command
var serveCmd = &cobra.Command{
	Use:   "serve",
	Short: "Start the web server",
	Long: `Start the PolyculeConnect web server using the configuration defined through environment
variables`,
	Run: func(cmd *cobra.Command, args []string) {
		serve()
	},
}

func serve() {
	mainCtx, cancel := context.WithCancel(context.Background())

	conf := utils.InitConfig(configPath)
	logger.Init(conf.LogLevel)
	logger.L.Infof("Initialized logger with level %v", conf.LogLevel)

	storageType := utils.InitStorage(conf)
	logger.L.Infof("Initialized storage backend %q", conf.StorageType)

	userDB, err := db.New(*conf)
	if err != nil {
		utils.Failf("failed to init user DB: %s", err.Error())
	}

	backends := map[uuid.UUID]*client.OIDCClient{}
	key := sha256.Sum256([]byte("test"))

	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		utils.Failf("Failed to generate private key: %s", err)
	}
	signingKey := model.Key{
		PrivateKey: privateKey,
		KeyID:      uuid.New(),
		SigningAlg: jose.RS256,
	}

	st := storage.Storage{LocalStorage: userDB, InitializedBackends: backends, Key: &signingKey}
	opConf := op.Config{
		CryptoKey:      key,
		CodeMethodS256: false,
	}
	slogger := slog.New(zapslog.NewHandler(logger.L.Desugar().Core(), nil))
	// slogger :=
	options := []op.Option{
		op.WithAllowInsecure(),
		op.WithLogger(slogger),
		op.WithHttpInterceptors(middlewares.WithBackendFromRequestMiddleware),
	}

	// logger.L.Info("Initializing authentication backends")
	// backendConfs, err := userDB.BackendStorage().GetAllBackends(context.Background())
	// if err != nil {
	// 	utils.Failf("failed to get backend configs from the DB: %s", err.Error())
	// }

	// TODO: check if we need to do it this way or
	// 	- do a try-loop?
	//	- only init when using them in a request?
	// for _, c := range backendConfs {
	// 	logger.L.Debugf("Initializing backend %s", c.Name)
	// 	b, err := client.New(context.Background(), c, logger.L)
	// 	if err != nil {
	// 		utils.Failf("failed to init backend client: %s", err.Error())
	// 	}
	// 	backends[c.ID] = b
	// }
	// if len(backends) == 0 {
	// 	logger.L.Warn("No auth backend loaded")
	// } else {
	// 	logger.L.Infof("Initialized %d auth backends", len(backends))
	// }

	provider, err := op.NewProvider(&opConf, &st, op.StaticIssuer(conf.Issuer), options...)
	if err != nil {
		utils.Failf("failed to init OIDC provider: %s", err.Error())
	}

	if err := services.AddDefaultBackend(storageType); err != nil {
		logger.L.Errorf("Failed to add connector for backend RefuseAll to stage: %s", err.Error())
	}

	logger.L.Info("Initializing server")
	s, err := server.New(conf, provider, &st, logger.L)
	if err != nil {
		logger.L.Fatalf("Failed to initialize server: %s", err.Error())
	}

	go s.Run(mainCtx)

	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)

	logger.L.Info("Application successfully started")

	logger.L.Debug("Waiting for stop signal")
	select {
	case <-s.Done():
		logger.L.Fatal("Unexpected exit from server")
	case <-c:
		logger.L.Info("Stopping main application")
		cancel()
	}

	logger.L.Debugf("Waiting %v for all daemons to stop", stopTimeout)
	select {
	case <-time.After(stopTimeout):
		logger.L.Fatalf("Failed to stop all daemons in the expected time")
	case <-s.Done():
		logger.L.Info("web server successfully stopped")
	}

	logger.L.Info("Application successfully stopped")
	os.Exit(0)

}

func init() {
	cmd.RootCmd.AddCommand(serveCmd)
	serveCmd.Flags().StringVarP(&configPath, "config", "c", "config.json", "Path to the JSON configuration file")
}
