debian-forge-composer/internal/integration/blue_build_integration_cli.go

package integration

import (
	"encoding/json"
	"fmt"
	"strconv"

	"github.com/sirupsen/logrus"
	"github.com/spf13/cobra"

	"debian-forge-composer/internal/modules"
	"debian-forge-composer/internal/schema"
)

// BlueBuildIntegrationCLI provides command-line interface for blue-build ecosystem integration
type BlueBuildIntegrationCLI struct {
	logger       *logrus.Logger
	modulesManager *modules.DebianModulesManager
	schemaManager  *schema.DebianSchemaManager
}

// NewBlueBuildIntegrationCLI creates a new blue-build integration CLI
func NewBlueBuildIntegrationCLI(logger *logrus.Logger) *BlueBuildIntegrationCLI {
	// Initialize managers with default configs
	modulesConfig := &modules.ModulesConfig{
		Enabled:     true,
		ModulesPath: "/var/lib/debian-forge/modules",
		Adaptations: true,
		Validation:  true,
	}
	
	schemaConfig := &schema.SchemaConfig{
		Enabled:      true,
		SchemasPath:  "/var/lib/debian-forge/schemas",
		Validation:   true,
		Adaptations:  true,
	}
	
	return &BlueBuildIntegrationCLI{
		logger:         logger,
		modulesManager: modules.NewDebianModulesManager(modulesConfig, logger),
		schemaManager:  schema.NewDebianSchemaManager(schemaConfig, logger),
	}
}

// CreateRootCommand creates the root blue-build integration command
func (cli *BlueBuildIntegrationCLI) CreateRootCommand() *cobra.Command {
	rootCmd := &cobra.Command{
		Use:   "blue-build-integration",
		Short: "Blue-Build Ecosystem Integration",
		Long:  "Manage blue-build modules and schemas integration for Debian",
	}

	// Add subcommands
	rootCmd.AddCommand(cli.createModulesCommand())
	rootCmd.AddCommand(cli.createSchemasCommand())
	rootCmd.AddCommand(cli.createStatusCommand())

	return rootCmd
}

// createModulesCommand creates the modules command
func (cli *BlueBuildIntegrationCLI) createModulesCommand() *cobra.Command {
	modulesCmd := &cobra.Command{
		Use:   "modules",
		Short: "Manage Debian-adapted blue-build modules",
		Long:  "List, validate, and manage Debian-adapted modules",
	}

	// List modules subcommand
	listCmd := &cobra.Command{
		Use:   "list",
		Short: "List available modules",
		Long:  "List all available Debian-adapted modules",
		RunE: func(cmd *cobra.Command, args []string) error {
			return cli.listModules()
		},
	}

	// List adaptations subcommand
	listAdaptationsCmd := &cobra.Command{
		Use:   "adaptations",
		Short: "List module adaptations",
		Long:  "List all module adaptations from blue-build",
		RunE: func(cmd *cobra.Command, args []string) error {
			return cli.listModuleAdaptations()
		},
	}

	// Show module subcommand
	showCmd := &cobra.Command{
		Use:   "show [module]",
		Short: "Show module details",
		Long:  "Show detailed information about a specific module",
		Args:  cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			return cli.showModule(args[0])
		},
	}

	// Validate module subcommand
	validateCmd := &cobra.Command{
		Use:   "validate [module] [config]",
		Short: "Validate module configuration",
		Long:  "Validate a module configuration against its schema",
		Args:  cobra.ExactArgs(2),
		RunE: func(cmd *cobra.Command, args []string) error {
			return cli.validateModule(args[0], args[1])
		},
	}

	// Create template subcommand
	templateCmd := &cobra.Command{
		Use:   "template [module]",
		Short: "Create module template",
		Long:  "Create a template configuration for a module",
		Args:  cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			return cli.createModuleTemplate(args[0])
		},
	}

	modulesCmd.AddCommand(listCmd, listAdaptationsCmd, showCmd, validateCmd, templateCmd)
	return modulesCmd
}

// createSchemasCommand creates the schemas command
func (cli *BlueBuildIntegrationCLI) createSchemasCommand() *cobra.Command {
	schemasCmd := &cobra.Command{
		Use:   "schemas",
		Short: "Manage Debian-adapted blue-build schemas",
		Long:  "List, validate, and manage Debian-adapted schemas",
	}

	// List schemas subcommand
	listCmd := &cobra.Command{
		Use:   "list",
		Short: "List available schemas",
		Long:  "List all available Debian-adapted schemas",
		RunE: func(cmd *cobra.Command, args []string) error {
			return cli.listSchemas()
		},
	}

	// List validations subcommand
	listValidationsCmd := &cobra.Command{
		Use:   "validations",
		Short: "List schema validations",
		Long:  "List all schema validation rules",
		RunE: func(cmd *cobra.Command, args []string) error {
			return cli.listSchemaValidations()
		},
	}

	// List adaptations subcommand
	listAdaptationsCmd := &cobra.Command{
		Use:   "adaptations",
		Short: "List schema adaptations",
		Long:  "List all schema adaptations from blue-build",
		RunE: func(cmd *cobra.Command, args []string) error {
			return cli.listSchemaAdaptations()
		},
	}

	// Show schema subcommand
	showCmd := &cobra.Command{
		Use:   "show [schema]",
		Short: "Show schema details",
		Long:  "Show detailed information about a specific schema",
		Args:  cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			return cli.showSchema(args[0])
		},
	}

	// Validate schema subcommand
	validateCmd := &cobra.Command{
		Use:   "validate [schema] [data]",
		Short: "Validate schema data",
		Long:  "Validate data against a schema",
		Args:  cobra.ExactArgs(2),
		RunE: func(cmd *cobra.Command, args []string) error {
			return cli.validateSchema(args[0], args[1])
		},
	}

	// Create template subcommand
	templateCmd := &cobra.Command{
		Use:   "template [schema]",
		Short: "Create schema template",
		Long:  "Create a template for a schema",
		Args:  cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			return cli.createSchemaTemplate(args[0])
		},
	}

	schemasCmd.AddCommand(listCmd, listValidationsCmd, listAdaptationsCmd, showCmd, validateCmd, templateCmd)
	return schemasCmd
}

// createStatusCommand creates the status command
func (cli *BlueBuildIntegrationCLI) createStatusCommand() *cobra.Command {
	statusCmd := &cobra.Command{
		Use:   "status",
		Short: "Show integration status",
		Long:  "Show current status of blue-build ecosystem integration",
		RunE: func(cmd *cobra.Command, args []string) error {
			return cli.showStatus()
		},
	}

	return statusCmd
}

// Module methods
func (cli *BlueBuildIntegrationCLI) listModules() error {
	modules := cli.modulesManager.ListModules()
	
	fmt.Printf("Available Debian Modules:\n")
	fmt.Printf("=========================\n")
	
	for _, module := range modules {
		fmt.Printf("  %s:\n", module.ID)
		fmt.Printf("    Name: %s\n", module.Name)
		fmt.Printf("    Description: %s\n", module.Description)
		fmt.Printf("    Type: %s\n", module.Type)
		fmt.Printf("    Source: %s\n", module.Source)
		fmt.Printf("    Adapted: %t\n", module.Adapted)
		fmt.Printf("\n")
	}
	
	return nil
}

func (cli *BlueBuildIntegrationCLI) listModuleAdaptations() error {
	adaptations := cli.modulesManager.ListAdaptations()
	
	fmt.Printf("Module Adaptations:\n")
	fmt.Printf("==================\n")
	
	for _, adaptation := range adaptations {
		fmt.Printf("  %s:\n", adaptation.ID)
		fmt.Printf("    Name: %s\n", adaptation.Name)
		fmt.Printf("    Description: %s\n", adaptation.Description)
		fmt.Printf("    Original: %s\n", adaptation.OriginalID)
		fmt.Printf("    Status: %s\n", adaptation.Status)
		fmt.Printf("    Changes:\n")
		for _, change := range adaptation.Changes {
			fmt.Printf("      - %s\n", change)
		}
		fmt.Printf("\n")
	}
	
	return nil
}

func (cli *BlueBuildIntegrationCLI) showModule(moduleID string) error {
	module, err := cli.modulesManager.GetModule(moduleID)
	if err != nil {
		return fmt.Errorf("failed to get module: %w", err)
	}

	fmt.Printf("Module: %s\n", module.Name)
	fmt.Printf("=======\n")
	fmt.Printf("  ID: %s\n", module.ID)
	fmt.Printf("  Description: %s\n", module.Description)
	fmt.Printf("  Type: %s\n", module.Type)
	fmt.Printf("  Source: %s\n", module.Source)
	fmt.Printf("  Adapted: %t\n", module.Adapted)
	fmt.Printf("  Enabled: %t\n", module.Enabled)
	
	if len(module.Metadata) > 0 {
		fmt.Printf("  Metadata:\n")
		for key, value := range module.Metadata {
			fmt.Printf("    %s: %v\n", key, value)
		}
	}

	return nil
}

func (cli *BlueBuildIntegrationCLI) validateModule(moduleID string, configStr string) error {
	// Parse config string (simplified - in production, use proper JSON parsing)
	config := map[string]interface{}{
		"type": configStr,
	}
	
	if err := cli.modulesManager.ValidateModule(moduleID, config); err != nil {
		return fmt.Errorf("module validation failed: %w", err)
	}

	fmt.Printf("Module validation passed: %s\n", moduleID)
	return nil
}

func (cli *BlueBuildIntegrationCLI) createModuleTemplate(moduleID string) error {
	template, err := cli.modulesManager.CreateModuleTemplate(moduleID)
	if err != nil {
		return fmt.Errorf("failed to create module template: %w", err)
	}

	fmt.Printf("Module Template for %s:\n", moduleID)
	fmt.Printf("========================\n")
	
	// Pretty print the template
	data, err := json.MarshalIndent(template, "", "  ")
	if err != nil {
		return fmt.Errorf("failed to marshal template: %w", err)
	}
	
	fmt.Printf("%s\n", string(data))
	return nil
}

// Schema methods
func (cli *BlueBuildIntegrationCLI) listSchemas() error {
	schemas := cli.schemaManager.ListSchemas()
	
	fmt.Printf("Available Debian Schemas:\n")
	fmt.Printf("=========================\n")
	
	for _, schema := range schemas {
		fmt.Printf("  %s:\n", schema.ID)
		fmt.Printf("    Name: %s\n", schema.Name)
		fmt.Printf("    Description: %s\n", schema.Description)
		fmt.Printf("    Type: %s\n", schema.Type)
		fmt.Printf("    Version: %s\n", schema.Version)
		fmt.Printf("    Source: %s\n", schema.Source)
		fmt.Printf("    Adapted: %t\n", schema.Adapted)
		fmt.Printf("\n")
	}
	
	return nil
}

func (cli *BlueBuildIntegrationCLI) listSchemaValidations() error {
	validations := cli.schemaManager.ListValidations()
	
	fmt.Printf("Schema Validations:\n")
	fmt.Printf("==================\n")
	
	for _, validation := range validations {
		fmt.Printf("  %s:\n", validation.ID)
		fmt.Printf("    Name: %s\n", validation.Name)
		fmt.Printf("    Description: %s\n", validation.Description)
		fmt.Printf("    Schema: %s\n", validation.SchemaID)
		fmt.Printf("    Type: %s\n", validation.Type)
		fmt.Printf("\n")
	}
	
	return nil
}

func (cli *BlueBuildIntegrationCLI) listSchemaAdaptations() error {
	adaptations := cli.schemaManager.ListAdaptations()
	
	fmt.Printf("Schema Adaptations:\n")
	fmt.Printf("===================\n")
	
	for _, adaptation := range adaptations {
		fmt.Printf("  %s:\n", adaptation.ID)
		fmt.Printf("    Name: %s\n", adaptation.Name)
		fmt.Printf("    Description: %s\n", adaptation.Description)
		fmt.Printf("    Original: %s\n", adaptation.OriginalID)
		fmt.Printf("    Status: %s\n", adaptation.Status)
		fmt.Printf("    Changes:\n")
		for _, change := range adaptation.Changes {
			fmt.Printf("      - %s\n", change)
		}
		fmt.Printf("\n")
	}
	
	return nil
}

func (cli *BlueBuildIntegrationCLI) showSchema(schemaID string) error {
	schema, err := cli.schemaManager.GetSchema(schemaID)
	if err != nil {
		return fmt.Errorf("failed to get schema: %w", err)
	}

	fmt.Printf("Schema: %s\n", schema.Name)
	fmt.Printf("=======\n")
	fmt.Printf("  ID: %s\n", schema.ID)
	fmt.Printf("  Description: %s\n", schema.Description)
	fmt.Printf("  Type: %s\n", schema.Type)
	fmt.Printf("  Version: %s\n", schema.Version)
	fmt.Printf("  Source: %s\n", schema.Source)
	fmt.Printf("  Adapted: %t\n", schema.Adapted)
	fmt.Printf("  Enabled: %t\n", schema.Enabled)
	
	if len(schema.Metadata) > 0 {
		fmt.Printf("  Metadata:\n")
		for key, value := range schema.Metadata {
			fmt.Printf("    %s: %v\n", key, value)
		}
	}

	return nil
}

func (cli *BlueBuildIntegrationCLI) validateSchema(schemaID string, dataStr string) error {
	// Parse data string (simplified - in production, use proper JSON parsing)
	data := map[string]interface{}{
		"type": dataStr,
	}
	
	if err := cli.schemaManager.ValidateSchema(schemaID, data); err != nil {
		return fmt.Errorf("schema validation failed: %w", err)
	}

	fmt.Printf("Schema validation passed: %s\n", schemaID)
	return nil
}

func (cli *BlueBuildIntegrationCLI) createSchemaTemplate(schemaID string) error {
	template, err := cli.schemaManager.CreateSchemaTemplate(schemaID)
	if err != nil {
		return fmt.Errorf("failed to create schema template: %w", err)
	}

	fmt.Printf("Schema Template for %s:\n", schemaID)
	fmt.Printf("========================\n")
	
	// Pretty print the template
	data, err := json.MarshalIndent(template, "", "  ")
	if err != nil {
		return fmt.Errorf("failed to marshal template: %w", err)
	}
	
	fmt.Printf("%s\n", string(data))
	return nil
}

// Status methods
func (cli *BlueBuildIntegrationCLI) showStatus() error {
	fmt.Printf("Blue-Build Ecosystem Integration Status:\n")
	fmt.Printf("========================================\n")
	
	// Modules status
	modules := cli.modulesManager.ListModules()
	adaptations := cli.modulesManager.ListAdaptations()
	
	fmt.Printf("Modules System:\n")
	fmt.Printf("  Status: Active\n")
	fmt.Printf("  Available Modules: %d\n", len(modules))
	fmt.Printf("  Module Adaptations: %d\n", len(adaptations))
	
	// Schemas status
	schemas := cli.schemaManager.ListSchemas()
	validations := cli.schemaManager.ListValidations()
	schemaAdaptations := cli.schemaManager.ListAdaptations()
	
	fmt.Printf("\nSchemas System:\n")
	fmt.Printf("  Status: Active\n")
	fmt.Printf("  Available Schemas: %d\n", len(schemas))
	fmt.Printf("  Validation Rules: %d\n", len(validations))
	fmt.Printf("  Schema Adaptations: %d\n", len(schemaAdaptations))
	
	// Integration status
	fmt.Printf("\nIntegration Status:\n")
	fmt.Printf("  Blue-Build Modules: Integrated\n")
	fmt.Printf("  Blue-Build Schemas: Integrated\n")
	fmt.Printf("  Debian Compatibility: High\n")
	fmt.Printf("  Overall Status: Complete\n")

	return nil
}