<?php

declare(strict_types=1);

namespace Mirzaev\Feip\Methods;

use Mirzaev\Feip\Error;

/**
 * MethodAbstract
 * 
 * @param array $ignore Список игнорируемых свойств
 * 
 * @method public function __construct(array $params) Сборщик
 * @method public filter(string $var, $params) Фильтрация входящих параметров
 * @method public function json() Возвращает json-строку собранную из объекта
 * @method private static function camelCase(string $text) Конвертация в camelCase (lower)
 * 
 * @package Mirzaev\Feip\Methods
 * @author Арсен Мирзаев <red@hood.su>
 */
class MethodAbstract
{
    /**
     * Список игнорируемых свойств
     * 
     * @var array
     */
    protected array $ignore = [];

    /**
     * Сборщик
     * 
     * Получает параметры и присваивает к одноимённым свойствам
     * 
     * @param array $params Параметры
     */
    public function __construct(array $params)
    {
        // Обработка входящих параметров
        foreach ($this as $var => $value) {
            // Перебор свойств объекта

            // Вызов метода Before
            $method = $this::camelCase($var . 'Before');
            if (method_exists($this, $method)) {
                // Если есть метод before, то вызвать его
                $this::$method();
            }

            // Список игнорируемых параметров
            if (in_array($var, $this->ignore) || $var === 'ignore') {
                // Если найден в списке, то пропустить
                continue;
            }

            // Нет значения
            if (empty($params[$var])) {
                // Если переданный параметр имеет пустое значение
                new Error(100, $var);
                continue;
            }

            // Массив
            if (is_array($params[$var])) {
                // Массив
                if (is_array($value)) {
                    // Если тип идентичного параметру свойства является массивом
                    $this->$var = $this->filter($var, $params[$var]);
                } else {
                    new Error(200, $var);
                }
            } else if (null !== $filtered = $this->filter($var, $params[$var])) {
                // Иначе, если получено скалярное значение и результат его фильтрации
                $this->$var = $filtered;
            }

            // Вызов метода After
            $method = $this::camelCase($var . 'After');
            if (method_exists($this, $method)) {
                // Если есть метод after, то вызвать его
                $this::$method();
            }
        }
    }

    /**
     * Фильтр
     * 
     * @param string|int $var Свойство объекта
     * @param mixed $params Параметры
     * 
     * @return mixed
     */
    public function filter($var, $params)
    {
        // Инициализация
        $response = [];

        if (!is_array($params)) {
            // Если передан скалярный параметр
            $params = [$var => $params];
        }

        // Обработка
        foreach ($params as $key => $value) {
            // Перебор входных параметров


            // Массив
            if (is_array($value)) {
                // Если передан массив, то войти в цикл для обработки
                $response[$key] = $this->filter($key, $value);
            }

            // Инициализация метода
            $method = $this::camelCase($key);
            // Скалярное значение
            if (method_exists($this, $method)) {
                // Если существует фильтр для параметра
                if ($value_filtered = $this::$method($value)) {
                    // Если фильтрация вернула результат
                    $response[$key] = $value_filtered;
                }
            }
        }

        // Деинициализация
        if (count($params) === 1) {
            // Если в начале был передан скалярный параметр
            $response = array_pop($response);
        }

        return $response;
    }

    /**
     * Конвертация в json
     * 
     * Возвращает строку json со значеним из всех свойств объекта
     * 
     * @return string
     */
    public function json(): string
    {
        // Инициализация
        $response = [
            'response' => [],
            'errors' => Error::get()
        ];

        // Генерация ответа
        foreach ($this as $var => $value) {
            // Перебор свойств объекта

            if (in_array($var, $this->ignore) || $var === 'ignore') {
                // Если добавлен в чёрный список, то пропустить
                continue;
            }

            $response['response'][$var] = $value;
        }
        var_dump($this->ignore);

        return json_encode($response);
    }


    /**
     * Конвертация в camelCase (lower)
     * 
     * Возвращает строку в формате camelCase (lower)
     * 
     * @param string|int $text Строка для конвертации
     * 
     * @return string
     */
    private static function camelCase($text): string
    {
        return (string) preg_replace_callback('/_(.?)/', fn ($m) => strtoupper($m[1]), $text);
    }
}