<?php
/**
 * Value formatting shared by the CSS compiler.
 *
 * The compiler is specified by `packages/core/src` and must agree with it byte for byte:
 * `tests/css-parity-wp-test.php` compiles every scene in the kit corpus with both and fails
 * on any difference. That is why the number formatting here follows JavaScript's rules
 * rather than PHP's defaults.
 *
 * @package Aumframe
 */

namespace Aumframe\Css;

defined('ABSPATH') || exit;

final class Value
{
    /** Format a scalar the way JavaScript string interpolation would. */
    public static function str($v): string
    {
        if (is_string($v)) {
            return $v;
        }
        if (is_bool($v)) {
            return $v ? 'true' : 'false';
        }
        if ($v === null) {
            return 'null';
        }
        if (is_int($v)) {
            return (string) $v;
        }
        if (is_float($v)) {
            return self::float($v);
        }
        if (is_array($v)) {
            /* JavaScript renders an array by joining its items with a comma. */
            return self::isList($v) ? implode(',', array_map([self::class, 'str'], $v)) : '';
        }

        return '';
    }

    /**
     * Format a float as JavaScript's Number-to-string does.
     *
     * PHP prints 14 significant digits and keeps a trailing `.0`; JavaScript prints the
     * shortest representation that round-trips. `17` and `17.0` therefore have to come out
     * the same, or a `width:17px` compiled here differs from the same width compiled in the
     * editor and the parity test fails.
     */
    public static function float(float $v): string
    {
        if (is_nan($v) || is_infinite($v)) {
            return $v > 0 ? 'Infinity' : ($v < 0 ? '-Infinity' : 'NaN');
        }
        if ($v === 0.0) {
            return '0';
        }
        $s = rtrim(rtrim(sprintf('%.17G', $v), '0'), '.');
        for ($p = 1; $p <= 17; $p++) {
            $c = sprintf('%.' . $p . 'G', $v);
            if ((float) $c === $v) {
                $s = $c;
                break;
            }
        }
        /* %G yields E+16; JavaScript yields e+16. */
        $s = str_replace(['E+', 'E-', 'E'], ['e+', 'e-', 'e+'], $s);
        if (str_contains($s, 'e')) {
            [$m, $e] = explode('e', $s, 2);
            $m    = rtrim(rtrim($m, '0'), '.');
            $sign = $e[0] === '-' ? '-' : '+';
            $s    = $m . 'e' . $sign . ltrim(ltrim($e, '+-'), '0');
        }

        return $s;
    }

    /** A number becomes pixels; anything else is passed through as written. */
    public static function px($v): string
    {
        return (is_int($v) || is_float($v)) ? self::str($v) . 'px' : self::str($v);
    }

    /**
     * Whether the array's keys are 0, 1, 2 … with no gaps.
     *
     * `array_is_list()` would say the same thing, but it arrived in PHP 8.1 and WordPress only
     * began shipping a fallback for it in 6.5. This plugin supports PHP 7.4 and WordPress 6.2,
     * where calling it is a fatal error on sight — and a development machine always has it, so
     * nothing here would ever have shown that.
     */
    public static function isList(array $a): bool
    {
        $i = 0;
        foreach ($a as $k => $_) {
            if ($k !== $i) {
                return false;
            }
            $i++;
        }

        return true;
    }

    /**
     * True when the value came from a JSON object rather than a JSON array.
     *
     * `json_decode(…, true)` renders both `{}` and `[]` as an empty PHP array, so an empty
     * array answers false here and the callers treat it as "no value" — which is what the
     * editor's compiler does for both shapes as well.
     */
    public static function isMap($v): bool
    {
        return is_array($v) && $v !== [] && !self::isList($v);
    }

    /**
     * True when the value would be a plain object in the editor's compiler.
     *
     * An empty array counts, because `json_decode(…, true)` gives `[]` for `{}` as well and
     * an empty table is the overwhelmingly more likely source. A populated list does not.
     */
    public static function isObjectish($v): bool
    {
        return is_array($v) && ($v === [] || !self::isList($v));
    }

    /** Read a key out of a decoded JSON object, or null when it is absent. */
    public static function get($map, string $key)
    {
        return (is_array($map) && array_key_exists($key, $map)) ? $map[$key] : null;
    }
}