<?php

namespace bff\utils;

use File;
use Exception;
use DOMDocument;
use bff\traits\Macroable;

/**
 * Класс вспомогательных HTML методов
 * @copyright Tamaranga
 */
abstract class HTML
{
    use Macroable;

    /**
     * Преобразует символы в соответствующие HTML-сущности
     * @param string $value
     * @return string
     */
    public static function entities(string $value): string
    {
        return htmlentities($value, ENT_QUOTES, 'UTF-8', false);
    }

    /**
     * Преобразуем все HTML-сущности в соответствующие символы
     * @param string $value
     * @return string
     */
    public static function decode(string $value): string
    {
        return html_entity_decode($value, ENT_QUOTES, 'UTF-8');
    }

    /**
     * Конвертируем специальные HTML символы
     * @param string $value
     * @return string
     */
    public static function specialchars(string $value): string
    {
        return htmlspecialchars($value, ENT_QUOTES, 'UTF-8', false);
    }

    /**
     * Эскейпим строку
     * @param string|array $value данные
     * @param string|bool $type тип: 'html'/true, 'js'
     * @param array $keysOnly список ключей, в случае если $value массив
     * @return array|string
     */
    public static function escape($value, $type = 'html', array $keysOnly = [])
    {
        if (is_bool($type)) {
            if ($type === true) {
                $type = 'html';
            } else {
                return $value;
            }
        }
        if (is_string($value)) {
            return static::escapeValue($value, $type);
        }
        if (is_array($value)) {
            foreach ($value as $key => $val) {
                if (is_array($val) || (!empty($keysOnly) && !in_array($key, $keysOnly))) {
                    continue;
                }
                if (is_string($val)) {
                    $value[$key] = static::escapeValue($val, $type);
                }
            }
            return $value;
        }
        return $value;
    }

    /**
     * Эскейпим строку
     * @param string $value данные
     * @param string $type тип: 'html', 'js' ('javascript')
     * @return string
     */
    protected static function escapeValue(string $value, string $type = 'html'): string
    {
        switch ($type) {
            case 'html':
                return htmlspecialchars($value, ENT_QUOTES, 'UTF-8');
            case 'js':
            case 'javascript':
                # escape quotes and backslashes, newlines, etc.
                return strtr($value, [
                    '\\' => '\\\\',
                    "'"  => "\\'",
                    '"'  => '\\"',
                    "\r" => '\\r',
                    "\n" => '\\n',
                    '</' => '<\/',
                ]);
        }

        return $value;
    }

    /**
     * Формирование простых полей ввода
     * @param string $tag HTML тег, допустимые: input, hidden, text, number, email, checkbox, radio, textarea, button
     * @param string|string[]|mixed $value значение
     * @param array $attributes атрибуты
     * @return string
     * @throws Exception
     */
    public static function input(string $tag, $value, array $attributes = []): string
    {
        if (in_array($tag, ['hidden','text','number','email','checkbox','radio'], true)) {
            $attributes['type'] = $tag;
            $tag = 'input';
        }
        if ($tag === 'input') {
            $attributes['value'] = $value;
            return '<' . $tag . static::attributes($attributes) . ' />';
        } elseif ($tag === 'textarea' || $tag === 'button') {
            $value = static::escape($value);
            if (is_array($value)) {
                $value = join(' ', $value);
            }
            return '<' . $tag . static::attributes($attributes) . '>' . $value . '</' . $tag . '>';
        }
        throw new Exception(_t('html', '[class]: Unsupported HTML tag "[tag]"', [
            'class' => static::class,
            'tag'   => strval($tag),
        ]));
    }

    /**
     * Формирование <option> тегов для <select>
     * @param array $data данные
     * @param int|string|bool $selectedID ID выбранного элемента
     * @param bool|string|array $empty
     *   false - не добавлять вариант "не выбран";
     *   string - название;
     *   [id,title] - id + название
     * @param string|null $idKey - ключ ID пунктов
     * @param string|null $titleKey - ключ названия пунктов
     * @param array $dataAttributes дополнительные "data-" атрибуты
     * @param array $opts дополнительные настройки
     * @return string
     */
    public static function selectOptions(
        array $data,
        $selectedID = 0,
        $empty = false,
        ?string $idKey = null,
        ?string $titleKey = null,
        array $dataAttributes = [],
        array $opts = []
    ): string {
        $html = '';
        $escape = $opts['escape'] ?? 'html';
        if (! empty($empty)) {
            if (is_string($empty)) {
                $empty = [0 => 0, 1 => $empty];
            }
            if (is_array($empty) && count($empty) == 2) {
                $attr = [];
                if ($selectedID == $empty[0]) {
                    $attr[] = 'selected';
                }
                $attr['value'] = $empty[0];
                $html .= '<option' . static::attributes($attr) . '>' . static::escape($empty[1], $escape) . '</option>';
            }
        }

        if (!empty($data)) {
            if (empty($titleKey) || empty($idKey)) {
                foreach ($data as $k => $v) {
                    if (is_array($v)) {
                        continue;
                    }
                    $attr = ['value' => $k];
                    if ($k == $selectedID) {
                        $attr[] = 'selected';
                    }
                    $html .= '<option' . static::attributes($attr) . '>' . static::escape($v, $escape) . '</option>';
                }
            } else {
                foreach ($data as $v) {
                    $attr = ['value' => $v[$idKey]];
                    if (is_numeric($v[$idKey])) {
                        if ($v[$idKey] == $selectedID) {
                            $attr[] = 'selected';
                        }
                    } else {
                        if ($v[$idKey] === $selectedID) {
                            $attr[] = 'selected';
                        }
                    }
                    if (!empty($dataAttributes)) {
                        foreach ($dataAttributes as $v2) {
                            if (isset($v[$v2])) {
                                $attr['data-' . $v2] = $v[$v2];
                            }
                        }
                    }
                    $html .=
                        '<option' . static::attributes($attr) . '>' .
                            static::escape($v[$titleKey], $escape) .
                        '</option>';
                }
            }
        }

        return $html;
    }

    /**
     * Формирование списков на основе данных (<ul><li>...</ul>)
     * @param array $data данные
     * @param array|mixed $values значения
     * @param callback $children функция, формирующая элементы списка на основе данных;
     *   входящие параметры: $k, $v, $values(значения)
     * @param int|array $columns
     *   int - требуемое кол-во колонок,
     *   array - подсчет колонок на основе данных array(кол-во колонок=> мин. кол-во данных, ...)
     * @param array $parentAttributes атрибуты тега контейнера
     * @param string $parentTag тег контейнера, по-умолчанию 'ul'
     * @return string HTML
     */
    public static function renderList(
        $data,
        $values,
        $children,
        $columns = 3,
        array $parentAttributes = ['style' => ''],
        string $parentTag = 'ul'
    ): string {
        if (empty($data) || !is_array($data) || !is_callable($children) || empty($parentTag)) {
            return '';
        }

        $parentAttributes = static::attributes($parentAttributes);
        $total = sizeof($data);
        $cols = 1;
        if (is_int($columns)) {
            $cols = $columns;
        } elseif (is_array($columns)) {
            foreach ($columns as $colsTo => $min) {
                if ($total >= $min) {
                    $cols = $colsTo;
                } else {
                    break;
                }
            }
        }
        $inColumn = ceil($total / $cols);
        $breakColumn = $inColumn;
        $i = 0;
        $col_i = 1;
        $html = '<' . $parentTag . $parentAttributes . '>';
        reset($data);
        foreach ($data as $k => $v) {
            if ($i == $breakColumn) {
                $col_i++;
                $html .= '</' . $parentTag . '><' . $parentTag . $parentAttributes . '>';
                if ($col_i < $cols) {
                    $breakColumn += $inColumn;
                }
            }
            $html .= $children($k, $v, $values);
            $i++;
        }
        $html .= '</' . $parentTag . '>';
        if (mb_stripos($parentAttributes, 'float:left;') !== false) {
            $html .= '<div class="clearfix" style="clear:both;"></div>';
        }

        return $html;
    }

    /**
     * Формируем HTML ссылку mailto + обфусцируем е-mail адрес для защиты от спам-ботов
     * @param string $email
     * @param string|null $title
     * @param array $attributes
     * @return string HTML
     */
    public static function mailto(string $email, ?string $title = null, array $attributes = []): string
    {
        $email = static::email($email);
        if (is_null($title)) {
            $title = $email;
        }
        $email = '&#109;&#097;&#105;&#108;&#116;&#111;&#058;' . $email;

        return '<a href="' . $email . '" ' . static::attributes($attributes) . '>' . static::entities($title) . '</a>';
    }

    /**
     * Обфусцируем е-mail адрес для защиты от спам-ботов
     * @param string $email
     * @return string
     */
    public static function email(string $email): string
    {
        return str_replace('@', '&#64;', static::obfuscate($email));
    }

    /**
     * Формируем HTML атрибуты
     * @param array $attributes
     * @param array $defaults
     * @param array $skip
     * @return string
     */
    public static function attributes($attributes, array $defaults = [], array $skip = []): string
    {
        if (empty($attributes) || !is_array($attributes)) {
            return '';
        }

        # наполняем значениями по умолчанию
        if (!empty($defaults)) {
            foreach ($defaults as $key => $v) {
                if (!isset($attributes[$key])) {
                    $attributes[$key] = $v;
                }
            }
        }

        $html = [];
        foreach ($attributes as $key => $value) {
            # пропускаем по ключу
            if (!empty($skip) && in_array($key, $skip, true)) {
                continue;
            }
            if (is_array($value)) {
                $value = join(' ', $value);
            }
            # в случае если ключ числовой, подразумеваем что нужно использовать
            # только значение, например для таких атрибутов как disabled="disabled",...
            if (is_numeric($key)) {
                $key = $value;
            }

            if (!is_null($value)) {
                $html[] = $key . '="' . static::entities($value) . '"';
            }
        }

        return (count($html) > 0) ? ' ' . join(' ', $html) : '';
    }

    /**
     * Дополняем HTML атрибуты в список
     * @param array $attributes @ref дополняемый список атрибутов
     * @param string $key ключ атрибута
     * @param mixed $value значение
     * @return void
     */
    public static function attributeAdd(array &$attributes, $key, $value)
    {
        if (array_key_exists($key, $attributes)) {
            if (! is_array($attributes[$key])) {
                $attributes[$key] = [$attributes[$key]];
            }
            if (is_array($value)) {
                foreach ($value as $v) {
                    if (! in_array($v, $attributes[$key])) {
                        $attributes[$key][] = $v;
                    }
                }
            } else {
                $attributes[$key][] = $value;
            }
        } else {
            $attributes[$key] = $value;
        }
    }

    /**
     * Удаляем HTML атрибут из списка по ключу
     * @param array $attributes @ref список атрибутов
     * @param string $key ключ атрибута
     * @param mixed $value значение или массив значений, которые необходимо удалить
     * @return void
     */
    public static function attributeRemove(array &$attributes, $key, $value)
    {
        if (! array_key_exists($key, $attributes)) {
            return;
        }
        if (! is_array($value)) {
            $value = [$value];
        }
        if (! is_array($attributes[$key])) {
            foreach ($value as $v) {
                if ($attributes[$key] == $v) {
                    unset($attributes[$key]);
                }
            }
        } else {
            foreach ($value as $v) {
                $k = array_search($v, $attributes[$key]);
                if ($k === false) {
                    continue;
                }
                unset($attributes[$key][$k]);
            }
        }
    }

    /**
     * Дополнить HTML атрибут, если такого нет
     * @param array $attributes @ref список атрибутов
     * @param string $key ключ атрибута
     * @param mixed $value значение
     * @return void
     */
    public static function attributeAddNotExist(array &$attributes, $key, $value)
    {
        if (! isset($attributes[$key])) {
            static::attributeAdd($attributes, $key, $value);
        }
    }

    /**
     * Обфусцируем строку для защиты от спам-ботов
     * @param string $value
     * @return string
     */
    public static function obfuscate(string $value): string
    {
        $safe = '';
        foreach (preg_split('//u', $value, null, PREG_SPLIT_NO_EMPTY) as $letter) {
            # каждый символ кодируем в hex или entity
            switch (rand(1, 3)) {
                case 1:
                    $safe .= '&#' . mb_ord($letter) . ';';
                    break;
                case 2:
                    $safe .= '&#x' . dechex(mb_ord($letter)) . ';';
                    break;
                case 3:
                    $safe .= $letter;
                    break;
            }
        }

        return $safe;
    }

    /**
     * Отрисовка тега <img> или <svg>
     * @param string $url URL
     * @param array $class класс тега
     * @param array $attr доп. атрибуты тега
     * @return string
     */
    public static function inlineSvg(string $url, array $class = [], array $attr = [])
    {
        # <svg>
        do {
            if (mb_substr($url, -4) !== '.svg') {
                break;
            }
            # cache
            $cacheDir = bff('path.base') . 'files' . DS . 'cache' . DS . 'svg' . DS;
            if (! File::isDirectory($cacheDir)) {
                Files::makeDir($cacheDir);
                if (! File::isDirectory($cacheDir)) {
                    break;
                }
            }
            $hash = $url;
            if (! empty($class)) {
                $hash .= json_encode($class);
            }
            $cache = $cacheDir . md5($hash) . '.svg';
            if (! bff()->isDebug() && File::exists($cache)) {
                return File::get($cache);
            }
            # url => cache
            $path = strtr($url, [SITEURL_STATIC . '/' => PATH_PUBLIC]);

            if (! File::exists($path)) {
                break;
            }

            $dom = new DOMDocument();
            $dom->preserveWhiteSpace = false;
            $res = $dom->load($path, LIBXML_NOBLANKS | LIBXML_NOERROR);
            if ($res === false) {
                break;
            }
            if ($dom->documentElement->tagName !== 'svg') {
                break;
            }
            # clean:
            # -desc
            foreach ($dom->getElementsByTagName('desc') as $element) {
                $element->parentNode->removeChild($element);
            }
            # -empty defs
            foreach ($dom->getElementsByTagName('defs') as $element) {
                if (! $element->hasChildNodes()) {
                    $element->parentNode->removeChild($element);
                }
            }
            # attr
            $class[] = 'svg';
            $attr['class'] = $class;
            foreach ($attr as $key => $value) {
                if (is_array($value)) {
                    $value = join(' ', $value);
                }
                if (is_numeric($key)) {
                    $key = $value;
                }
                if (is_null($value)) {
                    continue;
                }
                $dom->documentElement->setAttribute($key, $value);
            }
            # save
            $save = $dom->C14N();
            if (! empty($save)) {
                File::put($cache, $save);
                return $save;
            }
        } while (false);

        # <img>
        if (! empty($class)) {
            $attr['class'] = $class;
        }
        $attr['src'] = $url;
        return '<img' . static::attributes($attr) . '/>';
    }

    /**
     * Convert color code from HEX ("#000", "#000000") to RGB ("0, 0, 0", [0, 0, 0])
     * @param string $hex
     * @param string|null $separator
     * @param array $default
     * @return string|array
     */
    public static function colorHexToRgb(string $hex, ?string $separator = ', ', array $default = [0, 0, 0])
    {
        static $cache = [];

        $rgb = $default;
        do {
            $hex = mb_strtolower($hex);
            if (isset($cache[$hex])) {
                $rgb = $cache[$hex];
                break;
            }
            $length = strlen($hex);
            if (
                ! $length ||
                mb_strpos($hex, '#') !== 0 ||
                ! ($length === 7 || $length === 4)
            ) {
                break;
            }
            $rgb = $cache[$hex] = array_map(function ($char) {
                return hexdec(str_pad($char, 2, $char));
            }, str_split(trim($hex, '#'), $length > 4 ? 2 : 1));
        } while (false);
        if (is_null($separator)) {
            return $rgb;
        }
        return join($separator, $rgb);
    }
}