BuildCommand.php

<?php

declare(strict_types=1);

namespace OpenForgeProject\MageForge\Console\Command\Theme;

use Laravel\Prompts\MultiSearchPrompt;
use Laravel\Prompts\Spinner;
use OpenForgeProject\MageForge\Console\Command\AbstractCommand;
use OpenForgeProject\MageForge\Model\ThemeList;
use OpenForgeProject\MageForge\Model\ThemePath;
use OpenForgeProject\MageForge\Service\ThemeBuilder\BuilderPool;
use OpenForgeProject\MageForge\Service\ThemeSuggester;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;

/**
 * Command for building Magento themes
 */
class BuildCommand extends AbstractCommand
{
    /**
     * @param ThemePath $themePath
     * @param ThemeList $themeList
     * @param BuilderPool $builderPool
     * @param ThemeSuggester $themeSuggester
     */
    public function __construct(
        private readonly ThemePath $themePath,
        private readonly ThemeList $themeList,
        private readonly BuilderPool $builderPool,
        private readonly ThemeSuggester $themeSuggester,
    ) {
        parent::__construct();
    }

    /**
     * Configure command.
     *
     * @return void
     */
    protected function configure(): void
    {
        $this
            ->setName($this->getCommandName('theme', 'build'))
            ->setDescription('Builds a Magento theme')
            ->addArgument(
                'themeCodes',
                InputArgument::IS_ARRAY,
                'Theme codes to build (format: Vendor/theme, Vendor/theme 2, ...)',
            )
            ->setAliases(['frontend:build']);
    }

    /**
     * Execute command.
     *
     * @param InputInterface $input
     * @param OutputInterface $output
     * @return int
     */
    protected function executeCommand(InputInterface $input, OutputInterface $output): int
    {
        $themeCodes = $input->getArgument('themeCodes');
        $isVerbose = $this->isVerbose($output);

        if (empty($themeCodes)) {
            $themes = $this->themeList->getAllThemes();
            $options = array_values(array_map(fn($theme) => $theme->getCode(), $themes));

            // Check if we're in an interactive terminal environment
            if (!$this->isInteractiveTerminal($output)) {
                // Fallback for non-interactive environments
                $this->displayAvailableThemes($this->io);
                return Command::SUCCESS;
            }

            // Set environment variables for Laravel Prompts
            $this->setPromptEnvironment();

            $themeCodesPrompt = new MultiSearchPrompt(
                label: 'Select themes to build',
                options: fn(string $value) => empty($value)
                    ? $options
                    : array_values(array_filter($options, fn($option) => stripos((string)$option, $value) !== false)),
                placeholder: 'Type to search theme...',
                hint: 'Type to search, arrow keys to navigate, Space to toggle, Enter to confirm',
                required: false,
            );

            try {
                $themeCodes = $themeCodesPrompt->prompt();
                \Laravel\Prompts\Prompt::terminal()->restoreTty();

                // Reset environment
                $this->resetPromptEnvironment();

                // If no themes selected, show available themes
                if (empty($themeCodes)) {
                    $this->io->info('No themes selected.');
                    return Command::SUCCESS;
                }
            } catch (\Exception $e) {
                // Reset environment on exception
                $this->resetPromptEnvironment();
                // Fallback if prompt fails
                $this->io->error('Interactive mode failed: ' . $e->getMessage());
                $this->displayAvailableThemes($this->io);
                $this->io->newLine();
                return Command::SUCCESS;
            }
        }

        return $this->processBuildThemes($themeCodes, $this->io, $output, $isVerbose);
    }

    /**
     * Display available themes
     *
     * @param SymfonyStyle $io
     * @return int
     */
    private function displayAvailableThemes(SymfonyStyle $io): int
    {
        $table = new Table($io);
        $table->setHeaders(['Theme Code', 'Title']);

        foreach ($this->themeList->getAllThemes() as $theme) {
            $table->addRow([$theme->getCode(), $theme->getThemeTitle()]);
        }

        $table->render();
        $io->info('Usage: bin/magento mageforge:theme:build <theme-code> [<theme-code>...]');

        return Command::SUCCESS;
    }

    /**
     * Process theme building
     *
     * @param array<string> $themeCodes
     * @param SymfonyStyle $io
     * @param OutputInterface $output
     * @param bool $isVerbose
     * @return int
     */
    private function processBuildThemes(
        array $themeCodes,
        SymfonyStyle $io,
        OutputInterface $output,
        bool $isVerbose,
    ): int {
        $startTime = microtime(true);
        $successList = [];
        $totalThemes = count($themeCodes);

        if ($isVerbose) {
            $io->title(sprintf('Building %d theme(s)', $totalThemes));

            foreach ($themeCodes as $themeCode) {
                if (!$this->processTheme($themeCode, $io, $output, $isVerbose, $successList)) {
                    continue;
                }
            }
        } else {
            // Use the existing spinner with a customized message
            foreach ($themeCodes as $index => $themeCode) {
                $currentTheme = $index + 1;

                // Validate theme and handle suggestions BEFORE showing spinner
                $validatedTheme = $this->validateAndCorrectTheme($themeCode, $io, $output);

                if ($validatedTheme === null) {
                    // Theme validation failed or user cancelled - skip this theme
                    continue;
                }

                // Show which theme is currently being built (with validated/corrected name)
                $themeNameCyan = sprintf('<fg=cyan>%s</>', $validatedTheme);
                $spinner = new Spinner(sprintf(
                    'Building %s (%d of %d) ...',
                    $themeNameCyan,
                    $currentTheme,
                    $totalThemes,
                ));
                $success = false;

                $spinner->spin(function () use ($validatedTheme, $io, $output, $isVerbose, &$successList, &$success) {
                    $success = $this->buildValidatedTheme($validatedTheme, $io, $output, $isVerbose, $successList);
                    return true;
                });

                if ($success) {
                    // Show that the theme was successfully built
                    $io->writeln(sprintf(
                        '   Building %s (%d of %d) ... <fg=green>done</>',
                        $themeNameCyan,
                        $currentTheme,
                        $totalThemes,
                    ));
                } else {
                    // Show that an error occurred while building the theme
                    $io->writeln(sprintf(
                        '   Building %s (%d of %d) ... <fg=red>failed</>',
                        $themeNameCyan,
                        $currentTheme,
                        $totalThemes,
                    ));
                }
            }
        }

        $this->displayBuildSummary($io, $successList, microtime(true) - $startTime);

        return Command::SUCCESS;
    }

    /**
     * Validate theme and correct if invalid (with suggestions)
     *
     * @param string $themeCode
     * @param SymfonyStyle $io
     * @param OutputInterface $output
     * @return string|null Validated/corrected theme code or null if invalid/cancelled
     */
    private function validateAndCorrectTheme(string $themeCode, SymfonyStyle $io, OutputInterface $output): ?string
    {
        // Get theme path
        $themePath = $this->themePath->getPath($themeCode);
        if ($themePath === null) {
            // Try to suggest similar themes
            $correctedTheme = $this->handleInvalidThemeWithSuggestions($themeCode, $this->themeSuggester, $output);

            // If no theme was selected, return null
            if ($correctedTheme === null) {
                return null;
            }

            // Double-check the corrected theme exists
            $themePath = $this->themePath->getPath($correctedTheme);
            if ($themePath === null) {
                $io->error("Theme $correctedTheme is not installed.");
                return null;
            }

            $io->info("Using theme: $correctedTheme");
            return $correctedTheme;
        }

        return $themeCode;
    }

    /**
     * Build a validated theme (theme existence already confirmed)
     *
     * @param string $themeCode
     * @param SymfonyStyle $io
     * @param OutputInterface $output
     * @param bool $isVerbose
     * @param array<string> $successList
     * @return bool
     */
    private function buildValidatedTheme(
        string $themeCode,
        SymfonyStyle $io,
        OutputInterface $output,
        bool $isVerbose,
        array &$successList,
    ): bool {
        $themePath = $this->themePath->getPath($themeCode);

        if ($themePath === null) {
            $io->error("Could not find path for theme $themeCode.");
            return false;
        }

        // Find appropriate builder
        $builder = $this->builderPool->getBuilder($themePath);
        if ($builder === null) {
            $io->error("No suitable builder found for theme $themeCode.");
            return false;
        }

        if ($isVerbose) {
            $io->section(sprintf('Building theme %s using %s builder', $themeCode, $builder->getName()));
        }

        // Build the theme
        if (!$builder->build($themeCode, $themePath, $io, $output, $isVerbose)) {
            $io->error("Failed to build theme $themeCode.");
            return false;
        }

        $successList[] = sprintf('%s: Built successfully using %s builder', $themeCode, $builder->getName());
        return true;
    }

    /**
     * Process a single theme
     *
     * @param string $themeCode
     * @param SymfonyStyle $io
     * @param OutputInterface $output
     * @param bool $isVerbose
     * @param array<string> $successList
     * @return bool
     */
    private function processTheme(
        string $themeCode,
        SymfonyStyle $io,
        OutputInterface $output,
        bool $isVerbose,
        array &$successList,
    ): bool {
        // Validate and correct theme
        $validatedTheme = $this->validateAndCorrectTheme($themeCode, $io, $output);

        if ($validatedTheme === null) {
            return false;
        }

        // Build the validated theme
        return $this->buildValidatedTheme($validatedTheme, $io, $output, $isVerbose, $successList);
    }

    /**
     * Display build summary
     *
     * @param SymfonyStyle $io
     * @param array<string> $successList
     * @param float $duration
     */
    private function displayBuildSummary(SymfonyStyle $io, array $successList, float $duration): void
    {
        $io->newLine();
        $io->success(sprintf('🚀 Build process completed in %.2f seconds with the following results:', $duration));
        $io->writeln('Summary:');
        $io->newLine();

        if (empty($successList)) {
            $io->warning('No themes were built successfully.');
            return;
        }

        foreach ($successList as $success) {
            $parts = explode(': ', $success, 2);
            if (count($parts) === 2) {
                $themeName = $parts[0];
                $details = $parts[1];
                // Color the builder name in magenta
                if (preg_match('/(using\s+)([^\s]+)(\s+builder)/', $details, $matches)) {
                    $details = str_replace(
                        $matches[0],
                        $matches[1] . '<fg=magenta>' . $matches[2] . '</>' . $matches[3],
                        $details,
                    );
                }
                $io->writeln(sprintf('✅ <fg=cyan>%s</>: %s', $themeName, $details));
            } else {
                $io->writeln("✅ $success");
            }
        }

        $io->newLine();
    }
}