#!/usr/bin/env php
<?php

/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * FILE INFORMATION
 * DEFGROUP: moko-platform.CLI
 * INGROUP: moko-platform
 * REPO: https://git.mokoconsulting.tech/MokoConsulting/moko-platform
 * PATH: /cli/version_bump.php
 * BRIEF: Auto-increment version -- manifest.xml is canonical, cascades to all XML and MD files
 */

declare(strict_types=1);

require_once __DIR__ . '/../lib/Enterprise/CliFramework.php';

use MokoEnterprise\CliFramework;

class VersionBumpCli extends CliFramework
{
    protected function configure(): void
    {
        $this->setDescription('Auto-increment version -- manifest.xml is canonical, cascades to all XML and MD files');
        $this->addArgument('--path', 'Repository root', '.');
        $this->addArgument('--minor', 'Bump minor version', false);
        $this->addArgument('--major', 'Bump major version', false);
    }

    protected function run(): int
    {
        $path = $this->getArgument('--path');
        $type = 'patch';
        if ($this->getArgument('--minor')) {
            $type = 'minor';
        }
        if ($this->getArgument('--major')) {
            $type = 'major';
        }
        $root = realpath($path) ?: $path;
        $mokoVersion = null;
        $existingSuffix = '';
        $mokoManifest = "{$root}/.mokogitea/manifest.xml";
        $mokoContent = '';
        if (file_exists($mokoManifest)) {
            $mokoContent = file_get_contents($mokoManifest);
            if (preg_match('#<version>(\d{2}\.\d{2}\.\d{2})((?:-(?:dev|alpha|beta|rc))+)?</version>#', $mokoContent, $m)) {
                $mokoVersion = $m[1];
                $existingSuffix = $m[2] ?? '';
            }
        }
        $readmeVersion = null;
        $readme = "{$root}/README.md";
        $readmeContent = '';
        if (file_exists($readme)) {
            $readmeContent = file_get_contents($readme);
            if (preg_match('/VERSION:\s*(\d{2}\.\d{2}\.\d{2})/m', $readmeContent, $m)) {
                $readmeVersion = $m[1];
            }
        }
        $manifestVersion = null;
        $manifestFiles = array_merge(
            glob("{$root}/src/pkg_*.xml") ?: [],
            glob("{$root}/src/*.xml") ?: [],
            glob("{$root}/src/packages/*/mokowaas.xml") ?: [],
            glob("{$root}/src/packages/*/*.xml") ?: [],
            glob("{$root}/*.xml") ?: []
        );
        foreach ($manifestFiles as $xmlFile) {
            $xmlContent = file_get_contents($xmlFile);
            if (strpos($xmlContent, '<extension') === false && strpos($xmlContent, '<version>') === false) {
                continue;
            } if (preg_match('#<version>(\d{2}\.\d{2}\.\d{2})((?:-(?:dev|alpha|beta|rc))+)?</version>#', $xmlContent, $xm)) {
                $candidate = $xm[1];
                if ($manifestVersion === null || version_compare($candidate, $manifestVersion, '>')) {
                    $manifestVersion = $candidate;
                }
            }
        }
        $baseVersion = null;
        $candidates = array_filter([$mokoVersion, $readmeVersion, $manifestVersion]);
        foreach ($candidates as $v) {
            if ($baseVersion === null || version_compare($v, $baseVersion, '>')) {
                $baseVersion = $v;
            }
        }
        if ($baseVersion === null) {
            $this->log('ERROR', "No version found in manifest.xml, README.md, or Joomla XML");
            return 1;
        }
        if (!preg_match('/^(\d{2})\.(\d{2})\.(\d{2})$/', $baseVersion, $parts)) {
            $this->log('ERROR', "Invalid version format: {$baseVersion}");
            return 1;
        }
        $major = (int)$parts[1];
        $minor = (int)$parts[2];
        $patch = (int)$parts[3];
        $old = sprintf('%02d.%02d.%02d', $major, $minor, $patch);
        switch ($type) {
            case 'major':
                $major++;
                $minor = 0;
                $patch = 0;
                break;
            case 'minor':
                $minor++;
                $patch = 0;
                break;
            default:
                $patch++;
                if ($patch > 99) {
                    $minor++;
                    $patch = 0;
                } if ($minor > 99) {
                    $major++;
                    $minor = 0;
                }
                break;
        }
        $newBase = sprintf('%02d.%02d.%02d', $major, $minor, $patch);
        $newFull = $newBase . $existingSuffix;
        if (file_exists($mokoManifest) && !empty($mokoContent)) {
            $pattern = '#<version>\d{2}\.\d{2}\.\d{2}'
                . '(?:(?:-(?:dev|alpha|beta|rc))+)?</version>#';
            $updated = preg_replace(
                $pattern,
                "<version>{$newFull}</version>",
                $mokoContent,
                1
            );
            if ($updated !== null) {
                file_put_contents($mokoManifest, $updated);
            }
        }
        if (file_exists($readme) && !empty($readmeContent)) {
            $updated = preg_replace('/(VERSION:\s*)\d{2}\.\d{2}\.\d{2}(?:(?:-(?:dev|alpha|beta|rc))+)?/m', '${1}' . $newBase, $readmeContent, 1);
            if ($updated !== null) {
                file_put_contents($readme, $updated);
            }
        }
        $updatedFiles = [];
        foreach (["{$root}/src/pkg_*.xml", "{$root}/src/*.xml", "{$root}/src/packages/*/*.xml", "{$root}/*.xml"] as $pattern) {
            foreach (glob($pattern) ?: [] as $xmlFile) {
                $content = file_get_contents($xmlFile);
                if (strpos($content, '<extension') === false) {
                    continue;
                }
                $xmlPattern = '#<version>\d{2}\.\d{2}\.\d{2}'
                    . '(?:(?:-(?:dev|alpha|beta|rc))+)?</version>#';
                $newContent = preg_replace(
                    $xmlPattern,
                    "<version>{$newFull}</version>",
                    $content
                );
                if ($newContent !== null && $newContent !== $content) {
                    file_put_contents($xmlFile, $newContent);
                    $updatedFiles[] = substr($xmlFile, strlen($root) + 1);
                }
            }
        }
        if (!empty($updatedFiles)) {
            fwrite(STDERR, "Updated " . count($updatedFiles) . " Joomla manifest(s): " . implode(', ', $updatedFiles) . "\n");
        }
        $packageJsonFile = "{$root}/package.json";
        if (file_exists($packageJsonFile)) {
            $pkgContent = file_get_contents($packageJsonFile);
            $pkgPattern = '/("version"\s*:\s*")\d{2}\.\d{2}\.\d{2}'
                . '(?:(?:-(?:dev|alpha|beta|rc))+)?(")/m';
            $updatedPkg = preg_replace(
                $pkgPattern,
                '${1}' . $newFull . '${2}',
                $pkgContent
            );
            if ($updatedPkg !== $pkgContent) {
                file_put_contents($packageJsonFile, $updatedPkg);
                fwrite(STDERR, "Updated package.json\n");
            }
        }
        $pyprojectFile = "{$root}/pyproject.toml";
        if (file_exists($pyprojectFile)) {
            $pyContent = file_get_contents($pyprojectFile);
            $pyPattern = '/^(version\s*=\s*")\d{2}\.\d{2}\.\d{2}'
                . '(?:(?:-(?:dev|alpha|beta|rc))+)?(")/m';
            $updatedPy = preg_replace(
                $pyPattern,
                '${1}' . $newFull . '${2}',
                $pyContent
            );
            if ($updatedPy !== $pyContent) {
                file_put_contents($pyprojectFile, $updatedPy);
                fwrite(STDERR, "Updated pyproject.toml\n");
            }
        }
        $changelogFile = "{$root}/CHANGELOG.md";
        if (file_exists($changelogFile)) {
            $clContent = file_get_contents($changelogFile);
            $updatedCl = preg_replace('/(VERSION:\s*)\d{2}\.\d{2}\.\d{2}(?:(?:-(?:dev|alpha|beta|rc))+)?/m', '${1}' . $newBase, $clContent);
            if ($updatedCl !== null && $updatedCl !== $clContent) {
                file_put_contents($changelogFile, $updatedCl);
                fwrite(STDERR, "Updated CHANGELOG.md\n");
            }
        }
        $scanExtensions = ['php', 'yml', 'yaml', 'md', 'txt', 'xml', 'sh', 'toml', 'ini', 'css', 'js'];
        $excludeDirs = ['.git', 'vendor', 'node_modules', 'build', 'dist', '.claude'];
        $versionPattern = '/(VERSION:\s*)\d{2}\.\d{2}\.\d{2}/m';
        $directory = new RecursiveDirectoryIterator($root, RecursiveDirectoryIterator::SKIP_DOTS);
        $filter = new RecursiveCallbackFilterIterator($directory, function ($current, $key, $iterator) use ($excludeDirs) {
            if ($current->isDir() && in_array($current->getFilename(), $excludeDirs, true)) {
                return false;
            } return true;
        });
        $iterator = new RecursiveIteratorIterator($filter);
        $genericUpdated = [];
        foreach ($iterator as $fileInfo) {
            if ($fileInfo->isDir()) {
                continue;
            }
            $ext = strtolower($fileInfo->getExtension());
            if (!in_array($ext, $scanExtensions, true)) {
                continue;
            }
            $filePath = $fileInfo->getPathname();
            $relPath = str_replace([$root . '/', $root . '\\'], '', $filePath);
            if (in_array($relPath, ['README.md', 'CHANGELOG.md', 'package.json', 'pyproject.toml'], true)) {
                continue;
            }
            if (in_array($relPath, $updatedFiles ?? [], true)) {
                continue;
            }
            if (strpos($relPath, '.mokogitea/manifest.xml') !== false) {
                continue;
            }
            $content = @file_get_contents($filePath);
            if ($content === false) {
                continue;
            }
            if (preg_match('/^#\s*REPO:\s*https?:\/\//m', $content)) {
                continue;
            }
            $updated = preg_replace($versionPattern, '${1}' . $newBase, $content);
            if ($updated !== null && $updated !== $content) {
                file_put_contents($filePath, $updated);
                $genericUpdated[] = $relPath;
            }
        }
        if (!empty($genericUpdated)) {
            fwrite(STDERR, "Updated VERSION: in " . count($genericUpdated) . " file(s): " . implode(', ', $genericUpdated) . "\n");
        }
        echo "{$old} -> {$newFull}\n";
        return 0;
    }
}

$app = new VersionBumpCli();
exit($app->execute());