// Package cli implements the CLI adapter for Gordon.
package cli

import (
	"context"
	"fmt"
	"strings"

	"github.com/spf13/viper"

	"github.com/bnema/gordon/internal/app"
	"github.com/bnema/gordon/internal/boundaries/in"
	"github.com/bnema/gordon/internal/usecase/config"
)

// LocalServices provides direct access to local services for CLI operations.
type LocalServices struct {
	configSvc  in.ConfigService
	dataDir    string
	tlsEnabled bool
}

// GetConfigService returns the config service.
func (l *LocalServices) GetConfigService() in.ConfigService {
	return l.configSvc
}

// GetDataDir returns the data directory.
func (l *LocalServices) GetDataDir() string {
	return l.dataDir
}

// HasInternalTLS reports whether a TLS-capable entrypoint enables the internal CA.
func (l *LocalServices) HasInternalTLS() bool {
	return l.tlsEnabled
}

// GetLocalServices creates local services for CLI operations.
// It loads the config and initializes services without starting the server.
func GetLocalServices(cliConfigPath string) (*LocalServices, error) {
	// Set up viper with defaults
	v := viper.New()
	v.SetDefault("server.port", 8088)
	v.SetDefault("server.registry_port", 5000)
	v.SetDefault("server.data_dir", app.DefaultDataDir())

	// Configure viper with config file paths
	app.ConfigureViper(v, cliConfigPath)

	// Read config file
	if err := v.ReadInConfig(); err != nil {
		if _, ok := err.(viper.ConfigFileNotFoundError); !ok {
			return nil, fmt.Errorf("failed to read config file: %w", err)
		}
		// Config file not found is OK for some operations
	}

	// Create config service (without event bus for CLI operations)
	configSvc := config.NewService(v, nil)
	ctx := context.Background()
	if err := configSvc.Load(ctx); err != nil {
		return nil, fmt.Errorf("failed to load configuration: %w", err)
	}

	dataDir := v.GetString("server.data_dir")
	if dataDir == "" {
		dataDir = app.DefaultDataDir()
	}

	return &LocalServices{
		configSvc:  configSvc,
		dataDir:    dataDir,
		tlsEnabled: hasLocalTLSCapableEntrypoint(v),
	}, nil
}

func hasLocalTLSCapableEntrypoint(v *viper.Viper) bool {
	for _, rawEntryPoint := range v.GetStringMap("entrypoints") {
		entryPoint, ok := rawEntryPoint.(map[string]any)
		if !ok {
			continue
		}
		switch strings.TrimSpace(fmt.Sprint(entryPoint["protocol"])) {
		case "smart_tcp", "tls_mux":
			return true
		}
	}
	return false
}