<?php
/**
 * @package         Regular Labs Library
 * @version         23.12.10783
 * 
 * @author          Peter van Westen <[email protected]>
 * @link            https://regularlabs.com
 * @copyright       Copyright © 2023 Regular Labs All Rights Reserved
 * @license         GNU General Public License version 2 or later
 */

namespace RegularLabs\Library;

defined('_JEXEC') or die;

class ArrayHelper
{
    /**
     * Add a postfix to all keys in an array
     */
    public static function addPostfixToKeys(array|object $array, string $postfix): array|object
    {
        $pefixed = [];

        foreach ($array as $key => $value)
        {
            $pefixed[StringHelper::addPostfix($key, $postfix)] = $value;
        }

        return $pefixed;
    }

    /**
     * Add a postfix to all string values in an array
     */
    public static function addPostfixToValues(array|object $array, string $postfix): array|object
    {
        foreach ($array as &$value)
        {
            $value = StringHelper::addPostfix($value, $postfix);
        }

        return $array;
    }

    /**
     * Add a prefix and postfix to all string values in an array
     */
    public static function addPreAndPostfixToValues(
        array|object $array,
        string       $prefix,
        string       $postfix,
        bool         $keep_leading_slash = true
    ): array|object
    {
        foreach ($array as &$value)
        {
            $value = StringHelper::addPrefix($value, $prefix, $keep_leading_slash);
            $value = StringHelper::addPostfix($value, $postfix, $keep_leading_slash);
        }

        return $array;
    }

    /**
     * Add a prefix to all keys in an array
     */
    public static function addPrefixToKeys(array|object $array, string $prefix): array|object
    {
        $pefixed = [];

        foreach ($array as $key => $value)
        {
            $pefixed[StringHelper::addPrefix($key, $prefix)] = $value;
        }

        return $pefixed;
    }

    /**
     * Add a prefix to all string values in an array
     */
    public static function addPrefixToValues(
        array|object $array,
        string       $prefix,
        bool         $keep_leading_slash = true
    ): array|object
    {
        foreach ($array as &$value)
        {
            $value = StringHelper::addPrefix($value, $prefix, $keep_leading_slash);
        }

        return $array;
    }

    /**
     * Run a method over all values inside the array or object
     */
    public static function applyMethodToKeys(
        array  $attributes,
        string $class = '',
        string $method = ''
    ): array|object|null
    {
        if ( ! $class || ! $method)
        {
            $caller = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1];

            $class  = $caller['class'];
            $method = $caller['function'];
        }

        $array = array_shift($attributes);

        if ( ! is_array($array) && ! is_object($array))
        {
            return null;
        }

        if (empty($array))
        {
            return $array;
        }

        $json = json_encode($array);

        foreach ($array as $key => $value)
        {
            $value_attributes = [$key, ...$attributes];

            $json = str_replace(
                '"' . $key . '":',
                '"' . $class::$method(...$value_attributes) . '":',
                $json
            );
        }

        return json_decode($json, true);
    }

    /**
     * Run a method over all values inside the array or object
     */
    public static function applyMethodToValues(
        array  $attributes,
        string $class = '',
        string $method = '',
        int    $array_number_in_attributes = 0
    ): array|object|null
    {
        if ( ! $class || ! $method)
        {
            $caller = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1];

            $class  = $caller['class'];
            $method = $caller['function'];
        }

        $array = $attributes[$array_number_in_attributes];

        if ( ! is_array($array) && ! is_object($array))
        {
            return null;
        }

        $as_object = is_object($array);

        foreach ($array as &$value)
        {
            if ( ! is_string($value) && ! is_null($value))
            {
                continue;
            }

            $value_attributes                              = array_values($attributes);
            $value_attributes[$array_number_in_attributes] = $value;

            $value = $class::$method(...$value_attributes);
        }

        return $as_object ? (object) $array : $array;
    }

    /**
     * Change the case of array keys
     */
    public static function changeKeyCase(
        array|object|null $array,
        string            $format,
        bool              $to_lowercase = true
    ): array|object
    {
        if (is_null($array))
        {
            return [];
        }

        return self::applyMethodToKeys(
            [$array, $format, $to_lowercase],
            '\RegularLabs\Library\StringHelper',
            'toCase'
        );
    }

    /**
     * Clean array by trimming values and removing empty/false values
     */
    public static function clean(?array $array): array
    {
        if ( ! is_array($array))
        {
            return $array;
        }

        $array = self::trim($array);
        $array = self::unique($array);
        $array = self::removeEmpty($array);

        return $array;
    }

    /**
     * Create a tree from a flat array based on the parent_id value
     */
    public static function createTreeArray(
        array      $array,
        int        $level = 0,
        int|string $parent = 0,
        string     $id_name = 'id',
        string     $parent_id_name = 'parent_id'
    ): array
    {
        if (empty($array))
        {
            return $array;
        }

        $tree = [];

        foreach ($array as $item)
        {
            $id        = $item->{$id_name} ?? 0;
            $parent_id = $item->{$parent_id_name} ?? '';

            if ($parent_id !== $parent)
            {
                continue;
            }

            $item->level = $level;

            $tree[$id] = $item;

            $children = self::createTreeArray($array, $level + 1, $id, $id_name, $parent_id_name);

            if (empty($children))
            {
                continue;
            }

            $tree[$id]->children = $children;
        }

        return $tree;
    }

    /**
     * Check if any of the given values is found in the array
     */
    public static function find(
        array|string|null $needles,
        array|null        $haystack,
        bool              $strict = true
    ): bool
    {
        if ( ! is_array($haystack) || empty($haystack))
        {
            return false;
        }

        $needles = self::toArray($needles);

        foreach ($needles as $value)
        {
            if (in_array($value, $haystack, $strict))
            {
                return true;
            }
        }

        return false;
    }

    /**
     * Flatten an array of nested arrays, keeping the order
     */
    public static function flatten(array $array): array
    {
        $flattened = [];

        foreach ($array as $nested)
        {
            if ( ! is_array($nested))
            {
                $flattened[] = $nested;
                continue;
            }

            $flattened = [...$flattened, ...self::flatten($nested)];
        }

        return $flattened;
    }

    /**
     * Flatten a tree array into a single dimension array
     */
    public static function flattenTreeArray(array $array, string $children_name = 'children'): array
    {
        $flat = [];

        foreach ($array as $key => $item)
        {
            $flat[$key] = $item;

            if ( ! isset($item->{$children_name}))
            {
                continue;
            }

            $children = $item->{$children_name};
            unset($flat[$key]->{$children_name});

            $flat = [...$flat, ...self::flattenTreeArray($children, $children_name)];
        }

        foreach ($flat as $key => $item)
        {
            $check = (array) $item;
            unset($check['level']);

            if (empty($check))
            {
                unset($flat[$key]);
            }
        }

        return $flat;
    }

    /**
     * Join array elements with a string
     */
    public static function implode(
        array|string|null $pieces,
        string            $glue = '',
        string            $last_glue = null
    ): string
    {
        if ( ! is_array($pieces))
        {
            $pieces = self::toArray($pieces, $glue);
        }

        if (
            is_null($last_glue)
            || $last_glue == $glue
            || count($pieces) < 2
        )
        {
            return implode($glue ?? '', $pieces);
        }

        $last_item = array_pop($pieces);

        return implode($glue ?? '', $pieces) . $last_glue . $last_item;
    }

    /**
     * Removes empty values from the array
     */
    public static function removeEmpty(array $array): array
    {
        if ( ! is_array($array))
        {
            return $array;
        }

        foreach ($array as $key => &$value)
        {
            if ($key && ! is_numeric($key))
            {
                continue;
            }

            if ($value !== '')
            {
                continue;
            }

            unset($array[$key]);
        }

        return $array;
    }

    /**
     * Removes the trailing part of all keys in an array
     */
    public static function removePostfixFromKeys(array $array, string $postfix): array
    {
        $pefixed = [];

        foreach ($array as $key => $value)
        {
            $pefixed[StringHelper::removePostfix($key, $postfix)] = $value;
        }

        return $pefixed;
    }

    /**
     * Removes the trailing part of all string values in an array
     */
    public static function removePostfixFromValues(array $array, string $postfix): array
    {
        foreach ($array as &$value)
        {
            $value = StringHelper::removePostfix($value, $postfix);
        }

        return $array;
    }

    /**
     * Removes the first part of all keys in an array
     */
    public static function removePrefixFromKeys(array $array, string $prefix): array
    {
        $pefixed = [];

        foreach ($array as $key => $value)
        {
            $pefixed[StringHelper::removePrefix($key, $prefix)] = $value;
        }

        return $pefixed;
    }

    /**
     * Removes the first part of all string values in an array
     */
    public static function removePrefixFromValues(
        array  $array,
        string $prefix,
        bool   $keep_leading_slash = true
    ): array
    {
        foreach ($array as &$value)
        {
            $value = StringHelper::removePrefix($value, $prefix, $keep_leading_slash);
        }

        return $array;
    }

    /**
     * Set the level on each object based on the parent_id value
     */
    public static function setLevelsByParentIds(
        array  $array,
        int    $starting_level = 0,
        int    $parent = 0,
        string $id_name = 'id',
        string $parent_id_name = 'parent_id'
    ): array
    {
        if (empty($array))
        {
            return $array;
        }

        $tree = self::createTreeArray($array, $starting_level, $parent, $id_name, $parent_id_name);

        return self::flattenTreeArray($tree);
    }

    /**
     * Sorts the array by keys based on the values of another array
     */
    public static function sortByOtherArray(array $array, array $order): array
    {
        if (empty($order))
        {
            return $array;
        }

        uksort($array, function ($key1, $key2) use ($order) {
            return array_search($key1, $order) > array_search($key2, $order);
        });

        return $array;
    }

    /**
     * Convert data (string or object) to an array
     */
    public static function toArray(
        mixed  $data,
        string $separator = ',',
        bool   $unique = false,
        bool   $trim = true
    ): array
    {
        if (is_array($data))
        {
            return $data;
        }

        if (is_object($data))
        {
            return (array) $data;
        }

        if ($data === '' || is_null($data))
        {
            return [];
        }

        if ($separator === '')
        {
            return [$data];
        }

        // explode on separator, but keep escaped separators
        $splitter = uniqid('RL_SPLIT');
        $data     = str_replace($separator, $splitter, $data);
        $data     = str_replace('\\' . $splitter, $separator, $data);
        $array    = explode($splitter, $data);

        if ($trim)
        {
            $array = self::trim($array);
        }

        if ($unique)
        {
            $array = array_unique($array);
        }

        return $array;
    }

    /**
     * Convert an associative array or object to a html style attribute list
     */
    public static function toAttributeString(array $array, string $key_prefix = ''): string
    {
        $array = self::toArray($array);

        return implode(' ', array_map(
            fn($key, $value) => $key_prefix . $key . '="' . htmlspecialchars($value) . '"',
            array_keys($array), $array
        ));
    }

    /**
     * Clean array by trimming values
     */
    public static function trim(array $array): array
    {
        if ( ! is_array($array))
        {
            return $array;
        }

        foreach ($array as &$value)
        {
            if ( ! is_string($value))
            {
                continue;
            }

            $value = trim($value);
        }

        return $array;
    }

    /**
     * Removes duplicate values from the array
     */
    public static function unique(?array $array): array
    {
        if ( ! is_array($array))
        {
            return $array;
        }

        $values = [];

        foreach ($array as $key => $value)
        {
            if ( ! is_numeric($key))
            {
                continue;
            }

            if ( ! in_array($value, $values, true))
            {
                $values[] = $value;
                continue;
            }

            unset($array[$key]);
        }

        return $array;
    }
}