/*
Copyright © 2023-2024 AGECEM
*/
package main

import (
	"encoding/json"
	"fmt"
	"log"
	"os"
	"strings"

	"codeberg.org/vlbeaudoin/serpents"
	"git.agecem.com/agecem/agecem-org/v3/pkg/agecemorg"
	"github.com/spf13/cobra"
	"github.com/spf13/viper"
)

// configCmd represents the config command
var configCmd = &cobra.Command{
	Use:   "config",
	Short: "Print the config to stdout in indented JSON format",
	Run: func(cmd *cobra.Command, args []string) {
		var cfg agecemorg.Config

		if err := viper.Unmarshal(&cfg); err != nil {
			log.Fatal(err)
		}

		printConfig(cfg)
	},
}

func init() {
	rootCmd.AddCommand(configCmd)
}

func printConfig(config agecemorg.Config) error {
	buf, err := json.MarshalIndent(config, "", "  ")
	if err != nil {
		return err
	}

	fmt.Println(string(buf))

	return nil
}

var cfgFile string

// rootCmd represents the base command when called without any subcommands
var rootCmd = &cobra.Command{
	Use:   "agecem-org",
	Short: "Application du site web de l'AGECEM",
	Long:  "Application du site web de l'AGECEM, l'Association Générale Étudiante du Cégep Édouard-Montpetit.",
}

// Execute adds all child commands to the root command and sets flags appropriately.
// This is called by main.main(). It only needs to happen once to the rootCmd.
func Execute() {
	err := rootCmd.Execute()
	if err != nil {
		os.Exit(1)
	}
}

func init() {
	cobra.OnInitialize(initConfig)

	rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.agecem-org.yaml)")
}

// initConfig reads in config file and ENV variables if set.
func initConfig() {
	if cfgFile != "" {
		// Use config file from the flag.
		viper.SetConfigFile(cfgFile)
	} else {
		// Find home directory.
		home, err := os.UserHomeDir()
		cobra.CheckErr(err)

		// Search config in home directory with name ".agecem-org" (without extension).
		viper.AddConfigPath(home)
		viper.SetConfigType("yaml")
		viper.SetConfigName(".agecem-org")
	}

	viper.SetEnvPrefix("AGECEM_ORG")
	viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
	viper.AutomaticEnv() // read in environment variables that match

	// If a config file is found, read it in.
	if err := viper.ReadInConfig(); err == nil {
		fmt.Fprintln(os.Stderr, "Using config file:", viper.ConfigFileUsed())
	}
}

// serverCmd represents the server command
var serverCmd = &cobra.Command{
	Use:   "server",
	Short: "Démarrer le serveur web",
	Run: func(cmd *cobra.Command, args []string) {
		var cfg agecemorg.Config
		if err := viper.Unmarshal(&cfg); err != nil {
			log.Fatal(err)
		}

		mediaClient, err := agecemorg.NewMediaClientFromViper()
		switch err != nil {
		case true:
			log.Printf("NewMediaClientFromViper error: %s", err)
		case false:
			new_buckets, err := mediaClient.Seed()
			if err != nil {
				log.Printf("(*media.MediaClient).Seed error: %s", err)
			} else {
				log.Printf("Seeded %d buckets.\n", len(new_buckets))
			}
		}

		agecemorg.RunServer(cfg)
	},
}

func init() {
	rootCmd.AddCommand(serverCmd)

	serpents.Int(serverCmd.Flags(),
		"server.port", "server-port", 8080,
		"Port to run the webserver on")

	// Not currently used
	/*
		// server.documents.location    -    --server-documents-location
		serverCmd.Flags().String("server-documents-location", "us-east", "Storage bucket location (config: server.documents.location)")
		viper.BindPFlag("server.documents.location", serverCmd.Flags().Lookup("server-documents-location"))
	*/

	serpents.String(serverCmd.Flags(),
		"server.documents.endpoint", "server-documents-endpoint", "minio:9000",
		"Storage server endpoint")

	serpents.String(serverCmd.Flags(),
		"server.documents.access_key_id", "server-documents-access-key-id", "agecem-org",
		"Storage server access key id")

	serpents.String(serverCmd.Flags(),
		"server.documents.secret_access_key", "server-documents-secret-access-key", "agecem-org",
		"Storage server secret access key")

	serpents.Bool(serverCmd.Flags(),
		"server.documents.use_ssl", "server-documents-use-ssl", false,
		"Storage server SSL status")

	serpents.StringToString(serverCmd.Flags(),
		"server.documents.buckets", "server-documents-buckets", map[string]string{
			"politiques":  "Politiques",
			"reglements":  "Règlements",
			"formulaires": "Formulaires",
		},
		"Buckets that are allowed to be accessed by the API")

	serpents.Bool(serverCmd.Flags(),
		"server.api.auth", "server-api-auth", true,
		"Enable to allow key authentication for /v1 routes")

	serpents.String(serverCmd.Flags(),
		"server.api.key", "server-api-key", "agecem-org",
		"Key to use for authenticating to /v1 routes")

	serpents.Int(serverCmd.Flags(),
		"server.api.port", "server-api-port", 8080,
		"API server port")

	serpents.String(serverCmd.Flags(),
		"server.api.protocol", "server-api-protocol", "http",
		"API server protocol (http/https)")

	serpents.String(serverCmd.Flags(),
		"server.api.host", "server-api-host", "localhost",
		"API server host")

	serpents.Bool(serverCmd.Flags(),
		"server.admin.auth", "server-admin-auth", true,
		"Enable to allow basic authentication for /admin routes")

	serpents.String(serverCmd.Flags(),
		"server.admin.username", "server-admin-username", "agecem-org",
		"Username for basic authentication for /admin routes")

	serpents.String(serverCmd.Flags(),
		"server.admin.password", "server-admin-password", "agecem-org",
		"Password for basic authentication for /admin routes")
}

// versionCmd represents the version command
var versionCmd = &cobra.Command{
	Use:   "version",
	Short: "Print version registered at build time",
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("agecem-org", agecemorg.Version())
	},
}

func init() {
	rootCmd.AddCommand(versionCmd)
}