root.go

package cmd

import (
	"context"
	"fmt"
	"kubecloud/internal/api/app"
	cfg "kubecloud/internal/config"
	"kubecloud/internal/infrastructure/logger"
	"net"
	"net/http"
	"os"
	"os/signal"
	"strings"
	"syscall"
	"time"

	"github.com/spf13/cobra"
	"github.com/spf13/viper"
)

func addFlags() error {
	rootCmd.PersistentFlags().StringP("config", "c", "./config.json", "Path to the configuration file (default: ./config.json)")
	if err := viper.BindPFlag("config", rootCmd.PersistentFlags().Lookup("config")); err != nil {
		return fmt.Errorf("failed to bind config flag: %w", err)
	}

	// === Server ===
	if err := bindStringFlag(rootCmd, "server.host", "", "Server host"); err != nil {
		return fmt.Errorf("failed to bind server.host flag: %w", err)
	}
	if err := bindStringFlag(rootCmd, "server.port", "", "Server port"); err != nil {
		return fmt.Errorf("failed to bind server.port flag: %w", err)
	}

	// === Database ===
	// DSN-only database configuration (Postgres)
	if err := bindStringFlag(rootCmd, "database.dsn", "", "Database DSN"); err != nil {
		return fmt.Errorf("failed to bind database.dsn flag: %w", err)
	}

	// === JWT Token ===
	if err := bindStringFlag(rootCmd, "jwt_token.secret", "", "JWT secret"); err != nil {
		return fmt.Errorf("failed to bind jwt_token.secret flag: %w", err)
	}
	if err := bindIntFlag(rootCmd, "jwt_token.access_expiry_minutes", 60, "Access token expiry (minutes)"); err != nil {
		return fmt.Errorf("failed to bind jwt_token.access_expiry_minutes flag: %w", err)
	}
	if err := bindIntFlag(rootCmd, "jwt_token.refresh_expiry_hours", 24, "Refresh token expiry (hours)"); err != nil {
		return fmt.Errorf("failed to bind jwt_token.refresh_expiry_hours flag: %w", err)
	}

	// === Admins ===
	if err := bindStringFlag(rootCmd, "admins", "", "Comma-separated list of admin emails"); err != nil {
		return fmt.Errorf("failed to bind admins flag: %w", err)
	}

	// === Mail Sender ===
	if err := bindStringFlag(rootCmd, "mailSender.email", "", "Sender email"); err != nil {
		return fmt.Errorf("failed to bind mailSender.email flag: %w", err)
	}
	if err := bindStringFlag(rootCmd, "mailSender.sendgrid_key", "", "SendGrid API key"); err != nil {
		return fmt.Errorf("failed to bind mailSender.sendgrid_key flag: %w", err)
	}
	if err := bindIntFlag(rootCmd, "mailSender.timeout", 5, "Send timeout (minutes)"); err != nil {
		return fmt.Errorf("failed to bind mailSender.timeout flag: %w", err)
	}
	if err := bindIntFlag(rootCmd, "mailSender.max_concurrent_sends", 20, "Max concurrent sends"); err != nil {
		return fmt.Errorf("failed to bind mailSender.max_concurrent_sends flag: %w", err)
	}
	if err := bindIntFlag(rootCmd, "mailSender.max_attachment_size_mb", 10, "Max attachment size (MB)"); err != nil {
		return fmt.Errorf("failed to bind mailSender.max_attachment_size_mb flag: %w", err)
	}

	// === Stripe ===
	if err := bindStringFlag(rootCmd, "currency", "", "Currency (e.g., USD)"); err != nil {
		return fmt.Errorf("failed to bind currency flag: %w", err)
	}
	if err := bindStringFlag(rootCmd, "stripe_secret", "", "Stripe secret"); err != nil {
		return fmt.Errorf("failed to bind stripe_secret flag: %w", err)
	}

	// === Voucher ===
	if err := bindIntFlag(rootCmd, "voucher_name_length", 6, "Voucher name length"); err != nil {
		return fmt.Errorf("failed to bind voucher_name_length flag: %w", err)
	}

	// === Verification Code ===
	if err := bindIntFlag(rootCmd, "verification_code_length", 4, "Verification code length"); err != nil {
		return fmt.Errorf("failed to bind verification_code_length flag: %w", err)
	}

	// === Terms and Conditions ===
	if err := bindStringFlag(rootCmd, "terms_and_conditions.document_link", "", "Terms document link"); err != nil {
		return fmt.Errorf("failed to bind terms_and_conditions.document_link flag: %w", err)
	}
	if err := bindStringFlag(rootCmd, "terms_and_conditions.document_hash", "", "Terms document hash"); err != nil {
		return fmt.Errorf("failed to bind terms_and_conditions.document_hash flag: %w", err)
	}

	// === System Account ===
	if err := bindStringFlag(rootCmd, "system_account.mnemonic", "", "System account mnemonic"); err != nil {
		return fmt.Errorf("failed to bind system_account.mnemonic flag: %w", err)
	}
	if err := bindStringFlag(rootCmd, "system_account.network", "", "System account network"); err != nil {
		return fmt.Errorf("failed to bind system_account.network flag: %w", err)
	}

	// === Grid ===
	if err := bindStringFlag(rootCmd, "grid.mnemonic", "", "Grid mnemonic"); err != nil {
		return fmt.Errorf("failed to bind grid.mnemonic flag: %w", err)
	}
	if err := bindStringFlag(rootCmd, "grid.net", "", "Grid network"); err != nil {
		return fmt.Errorf("failed to bind grid.net flag: %w", err)
	}

	// === Deployer Workers ===
	if err := bindIntFlag(rootCmd, "deployer_workers_num", 1, "Number of deployer workers"); err != nil {
		return fmt.Errorf("failed to bind deployer_workers_num flag: %w", err)
	}

	// === Health Checks ===
	if err := bindIntFlag(rootCmd, "cluster_health_check_interval_in_hours", 1, "Cluster health check interval (hours)"); err != nil {
		return fmt.Errorf("failed to bind cluster_health_check_interval_in_hours flag: %w", err)
	}
	if err := bindIntFlag(rootCmd, "node_health_check.reserved_node_health_check_interval_in_hours", 1, "Reserved node health check interval (hours)"); err != nil {
		return fmt.Errorf("failed to bind node_health_check.reserved_node_health_check_interval_in_hours flag: %w", err)
	}
	if err := bindIntFlag(rootCmd, "node_health_check.reserved_node_health_check_timeout_in_minutes", 1, "Reserved node health check timeout (minutes)"); err != nil {
		return fmt.Errorf("failed to bind node_health_check.reserved_node_health_check_timeout_in_minutes flag: %w", err)
	}
	if err := bindIntFlag(rootCmd, "node_health_check.reserved_node_health_check_workers_num", 10, "Reserved node health check workers number"); err != nil {
		return fmt.Errorf("failed to bind node_health_check.reserved_node_health_check_workers_num flag: %w", err)
	}

	// === Invoice ===
	if err := bindStringFlag(rootCmd, "invoice.name", "", "Invoice company name"); err != nil {
		return fmt.Errorf("failed to bind invoice.name flag: %w", err)
	}
	if err := bindStringFlag(rootCmd, "invoice.address", "", "Invoice address"); err != nil {
		return fmt.Errorf("failed to bind invoice.address flag: %w", err)
	}
	if err := bindStringFlag(rootCmd, "invoice.governorate", "", "Invoice governorate"); err != nil {
		return fmt.Errorf("failed to bind invoice.governorate flag: %w", err)
	}

	// === Debug ===
	if err := bindBoolFlag(rootCmd, "debug", false, "Enable debug logging"); err != nil {
		return fmt.Errorf("failed to bind debug flag: %w", err)
	}

	// === Development Mode ===
	if err := bindBoolFlag(rootCmd, "dev_mode", false, "Enable development mode"); err != nil {
		return fmt.Errorf("failed to bind dev_mode flag: %w", err)
	}

	// === Monitor Balance Interval In Hours ===
	if err := bindIntFlag(rootCmd, "monitor_balance_interval_in_minutes", 1, "Number of minutes to monitor balance"); err != nil {
		return fmt.Errorf("failed to bind monitor_balance_interval_in_minutes flag: %w", err)
	}

	if err := bindIntFlag(rootCmd, "notify_admins_for_pending_records_in_hours", 1, "Number of hours to notify admins about pending records"); err != nil {
		return fmt.Errorf("failed to bind notify_admins_for_pending_records_in_hours flag: %w", err)
	}

	// === Users Balance Check Interval In Hours ===
	if err := bindIntFlag(rootCmd, "users_balance_check_interval_in_hours", 6, "Number of hours to check users balance"); err != nil {
		return fmt.Errorf("failed to bind users_balance_check_interval_in_hours flag: %w", err)
	}
	if err := bindIntFlag(rootCmd, "check_user_debt_interval_in_hours", 48, "Number of upcoming hours to check user debt"); err != nil {
		return fmt.Errorf("failed to bind check_user_debt_interval_in_hours flag: %w", err)
	}

	// === Logger Config ===
	if err := bindStringFlag(rootCmd, "logger.log_dir", "./logs", "Logger directory"); err != nil {
		return fmt.Errorf("failed to bind logger.log_dir flag: %w", err)
	}
	if err := bindIntFlag(rootCmd, "logger.max_size", 512, "Logger max size (MB)"); err != nil {
		return fmt.Errorf("failed to bind logger.max_size flag: %w", err)
	}
	if err := bindIntFlag(rootCmd, "logger.max_backups", 12, "Logger max backups"); err != nil {
		return fmt.Errorf("failed to bind logger.max_backups flag: %w", err)
	}
	if err := bindIntFlag(rootCmd, "logger.max_age_days", 30, "Logger max age (days)"); err != nil {
		return fmt.Errorf("failed to bind logger.max_age_days flag: %w", err)
	}
	if err := bindBoolFlag(rootCmd, "logger.compress", true, "Logger compress backups"); err != nil {
		return fmt.Errorf("failed to bind logger.compress flag: %w", err)
	}

	// === Loki ===
	if err := bindStringFlag(rootCmd, "loki.url", "http://loki:3100/loki/api/v1/push", "Loki URL"); err != nil {
		return fmt.Errorf("failed to bind loki.url flag: %w", err)
	}
	if err := bindIntFlag(rootCmd, "loki.flush_interval_second", 2, "Loki flush interval (seconds)"); err != nil {
		return fmt.Errorf("failed to bind loki.flush_interval_second flag: %w", err)
	}

	// === Loki Labels ===
	if err := bindStringFlag(rootCmd, "loki.labels.app", "myceliumcloud", "Loki app label"); err != nil {
		return fmt.Errorf("failed to bind loki.labels.app flag: %w", err)
	}
	if err := bindStringFlag(rootCmd, "loki.labels.env", "main", "Loki env label"); err != nil {
		return fmt.Errorf("failed to bind loki.labels.env flag: %w", err)
	}
	if err := bindStringFlag(rootCmd, "loki.labels.host", "localhost", "Loki host label"); err != nil {
		return fmt.Errorf("failed to bind loki.labels.host flag: %w", err)
	}

	// === Telemetry ===
	if err := bindStringFlag(rootCmd, "telemetry.otlp_endpoint", "jaeger:4317", "OpenTelemetry gRPC endpoint"); err != nil {
		return fmt.Errorf("failed to bind telemetry.otlp_endpoint flag: %w", err)
	}
	// === Lock Timeout In Hours ===
	if err := bindIntFlag(rootCmd, "lock_timeout_in_hours", 1, "Redis lock timeout (hours)"); err != nil {
		return fmt.Errorf("failed to bind lock_timeout_in_hours flag: %w", err)
	}
	return nil
}

// reloadNotificationsCmd represents the reload-notifications command
var reloadNotificationsCmd = &cobra.Command{
	Use:   "reload-notifications",
	Short: "Reload notification configuration",
	Long:  `Send a SIGHUP signal to reload notification configuration without restarting the server.`,
	RunE: func(cmd *cobra.Command, args []string) error {
		fmt.Println("Reloading notification configuration...")

		socketPath := "/tmp/myceliumcloud.sock"

		// Connect to socket
		conn, err := net.Dial("unix", socketPath)
		if err != nil {
			return fmt.Errorf("failed to connect to myceliumcloud (is it running?): %w", err)
		}
		defer conn.Close()

		// Send command
		_, err = conn.Write([]byte("reload-notifications"))
		if err != nil {
			return fmt.Errorf("failed to send command: %w", err)
		}

		// Read response
		buffer := make([]byte, 1024)
		n, err := conn.Read(buffer)
		if err != nil {
			return fmt.Errorf("failed to read response: %w", err)
		}

		response := string(buffer[:n])
		if strings.HasPrefix(response, "ERROR:") {
			return fmt.Errorf("server error: %s", strings.TrimPrefix(response, "ERROR: "))
		}

		fmt.Printf("%s\n", strings.TrimPrefix(response, "OK: "))

		return nil
	},
}

func init() {
	cobra.OnInitialize(initConfig)

	viper.SetEnvPrefix("myceliumcloud") // Prefix for environment variables
	viper.AutomaticEnv()                // Automatically bind environment variables

	// Map environment variables to their corresponding keys
	viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))

	// Add subcommands
	rootCmd.AddCommand(reloadNotificationsCmd)

	if err := addFlags(); err != nil {
		logger.GetLogger().Fatal().Err(err).Msg("Failed to add flags")
	}
}

func initConfig() {
	configFile := viper.GetString("config")
	if configFile != "" {
		viper.SetConfigFile(configFile)
	} else {
		viper.SetConfigName("config")
		viper.SetConfigType("json")
	}

	if err := viper.ReadInConfig(); err != nil {
		logger.GetLogger().Warn().Err(err).Msg("No configuration file found, using defaults")
	}
}

var rootCmd = &cobra.Command{
	Use:   "MyceliumCloud",
	Short: "Deploy secure, decentralized Kubernetes clusters on TFGrid with Mycelium networking and QSFS storage.",
	Long: `Mycelium Cloud is a CLI tool that helps you deploy and manage Kubernetes clusters on the decentralized TFGrid.

It supports:
- GPU and dedicated nodes for high-performance workloads
- Built-in storage using QSFS with backup and restore
- Private networking with Mycelium (no public IPs needed)
- Web gateway (WebGW) access to expose services
- Usage-based billing with USD pricing set by farmers
- Secure access control through Mycelium whitelisting
`,
	RunE: func(cmd *cobra.Command, args []string) error {
		config, err := cfg.LoadConfig()
		if err != nil {
			logger.GetLogger().Error().Err(err).Msg("Failed to read configurations")
			return fmt.Errorf("failed to read configuration: %w", err)
		}

		// === LOGGER SETUP  ===
		// Initialize shared logger
		loggerConfig := logger.LoggerConfig{
			LogDir:     config.Logger.LogDir,
			MaxSize:    config.Logger.MaxSize,
			MaxBackups: config.Logger.MaxBackups,
			MaxAge:     config.Logger.MaxAgeDays,
			Compress:   config.Logger.Compress,
		}
		if loggerConfig.LogDir == "" {
			loggerConfig.LogDir = "./logs"
		}

		if config.Loki.Labels == nil {
			return fmt.Errorf("failed to initialize logger: loki.labels is nil")
		}

		fmt.Printf("Setting up logging to: %s/app.log\n", loggerConfig.LogDir)
		lokiConfig := &logger.LokiConfig{
			URL:           config.Loki.URL,
			FlushInterval: time.Duration(config.Loki.FlushIntervalSecond) * time.Second,
			Labels: map[string]string{
				"app":  config.Loki.Labels.App,
				"env":  config.Loki.Labels.Env,
				"host": config.Loki.Labels.Host,
			},
		}
		if err := logger.InitLogger(loggerConfig, lokiConfig, config.Debug); err != nil {
			return fmt.Errorf("failed to initialize logger: %w", err)
		}

		app, err := app.NewApp(cmd.Context(), config)
		if err != nil {
			return fmt.Errorf("failed to create new app: %w", err)
		}

		return gracefulShutdown(app)
	},
}

func gracefulShutdown(app *app.App) error {
	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()

	go func() {
		logger.GetLogger().Info().Msg("Starting Mycelium Cloud server")

		if err := app.Run(); err != nil && err != http.ErrServerClosed {
			logger.GetLogger().Error().Err(err).Msg("Failed to start server")
			stop()
		}
	}()

	<-ctx.Done()

	logger.GetLogger().Info().Msg("Shutting down...")
	if err := app.Shutdown(); err != nil {
		logger.GetLogger().Error().Err(err).Msg("Server shutdown failed")
		return err
	}

	logger.GetLogger().Info().Msg("Server gracefully stopped.")
	return nil
}

func Execute() {
	err := rootCmd.Execute()
	if err != nil {
		logger.GetLogger().Error().Err(err).Msg("Command execution failed")
		os.Exit(1)
	}
}

func bindStringFlag(cmd *cobra.Command, key, defaultVal, usage string) error {
	cmd.PersistentFlags().String(key, defaultVal, usage)
	return viper.BindPFlag(key, cmd.PersistentFlags().Lookup(key))
}

func bindIntFlag(cmd *cobra.Command, key string, defaultVal int, usage string) error {
	cmd.PersistentFlags().Int(key, defaultVal, usage)
	if err := viper.BindPFlag(key, cmd.PersistentFlags().Lookup(key)); err != nil {
		return fmt.Errorf("failed to bind flag %s: %w", key, err)
	}

	if err := viper.BindEnv(key); err != nil {
		return fmt.Errorf("failed to bind environment variable for flag %s: %w", key, err)
	}
	// Ensure the value is set as an integer in viper
	viper.Set(key, viper.GetInt(key))

	return nil
}

func bindBoolFlag(cmd *cobra.Command, key string, defaultVal bool, usage string) error {
	cmd.PersistentFlags().Bool(key, defaultVal, usage)
	if err := viper.BindPFlag(key, cmd.PersistentFlags().Lookup(key)); err != nil {
		return fmt.Errorf("failed to bind flag %s: %w", key, err)
	}

	return nil
}