<?php

/**
 * @package SP Page Builder
 * @author JoomShaper http://www.joomshaper.com
 * @copyright Copyright (c) 2010 - 2025 JoomShaper
 * @license http://www.gnu.org/licenses/gpl-2.0.html GNU/GPLv2 or later
 */

use Joomla\CMS\Factory;
use Joomla\CMS\Component\ComponentHelper;
use Joomla\CMS\Uri\Uri;

/** No direct access. */
defined('_JEXEC') or die('Restricted access');

/**
 * Migrate the CSS method used in the site.php file.
 *
 * @since	4.0.0
 */
class CSSHelper extends HelperBase
{
	/**
	 * The default device
	 *
	 * @var 	string
	 * @since 	4.0.0
	 */
	private static $device;

	/**
	 * The font registry array. Registering all the fonts here.
	 *
	 * @var 	array
	 * @since 	4.0.0
	 */
	private $fontRegistry = [];

	/**
	 * The constructor function of the CSS Migrator.
	 *
	 * @param 	string 	$id		The addon ID selector.
	 * @param 	bool 	$force	Flag to set the ID as whatever it is provided, no sanitization is required.
	 *
	 * @since 	4.0.0
	 */
	public function __construct(string $id, bool $force = false)
	{
		parent::__construct($id, $force);
		self::$device = SpPgaeBuilderBase::$defaultDevice;
	}

	private function getFallbackValue($settings, $prop)
	{
		$keys = explode('.', $prop, 2);

		if (empty($keys)) return null;

		if (count($keys) > 1)
		{
			list($key1, $key2) = $keys;

			$originalKey1 = $key1 . '_original';
			$originalKey2 = $key2 . '_original';

			if (isset($settings->$originalKey1))
			{
				$key1 = $originalKey1;
			}

			if (isset($settings->$originalKey2))
			{
				$key2 = $originalKey2;
			}

			return isset($settings->$key1->$key2) ? $settings->$key1->$key2 : null;
		}

		$key1 = $keys[0];

		$originalKey = $key1 . '_original';

		if (isset($settings->$originalKey))
		{
			$key1 = $originalKey;
		}

		return isset($settings->$key1) ? $settings->$key1 : null;
	}

	public function objectHasString($object, $searchString) {
		foreach (get_object_vars($object) as $key => $value) {
			if (is_string($value) && strpos($value, $searchString) !== false) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Register a font name to the font registry.
	 *
	 * @param string $fontName	The font name which will be stored to the registry.
	 *
	 * @return 	void
	 * @since 	4.0.0
	 */
	private function registerFont(string $fontName)
	{
		if (!\in_array($fontName, $this->fontRegistry))
		{
			$this->fontRegistry[] = $fontName;
		}
	}

	/**
	 * Get the font registry array.
	 *
	 * @return 	array
	 * @since	4.0.0
	 */
	private function getFontRegistry(): array
	{
		return $this->fontRegistry;
	}

	/**
	 * Load the google font for the typography fields.
	 *
	 * @return 	void
	 * @since 	4.0.0
	 */
	public function loadGoogleFont(string $fontName)
	{
		$systemFonts = array(
			'Arial',
			'Tahoma',
			'Verdana',
			'Helvetica',
			'Times New Roman',
			'Trebuchet MS',
			'Georgia'
		);

		if (!empty($fontName))
		{
			if (!\in_array($fontName, $systemFonts))
			{
				$fontPath =  '/media/com_sppagebuilder/assets/google-fonts/' . $fontName . '/stylesheet.css';
				$params = ComponentHelper::getParams('com_sppagebuilder');
				$disableGoogleFonts = (bool) $params->get('disable_google_fonts', 0);

				if ($disableGoogleFonts)
				{
					return;
				}

				if (file_exists(JPATH_ROOT . $fontPath))
				{
					Factory::getDocument()->addStylesheet(Uri::root(true) . $fontPath);
				}
				else
				{
					$linkTagUrl = "https://fonts.googleapis.com/css?family=\"" . $fontName . "\":100,100italic,200,200italic,300,300italic,400,400italic,500,500italic,600,600italic,700,700italic,800,800italic,900,900italic&display=swap";
					Factory::getDocument()->addStylesheet($linkTagUrl);
				}
			}
		}
	}

	public function loadLocalFont(string $fontName)
	{
		$fontPath =  '/media/com_sppagebuilder/assets/custom-fonts/' . $fontName . '/stylesheet.css';

		if (file_exists(JPATH_ROOT . $fontPath))
		{
			Factory::getDocument()->addStylesheet(Uri::root(true) . $fontPath);
		}
	}

	private function purifyTypographyObject($obj)
	{
		$device = SpPgaeBuilderBase::$defaultDevice;
		$obj = $obj ?? '';

		if (!\is_object($obj))
		{
			if (preg_match("@[^-|\d+]@", $obj))
			{
				$obj = \preg_replace("@\D+$@", '', $obj);
			}

			$newObject = AddonHelper::initDeviceObject();

			foreach ($newObject as $k => &$v)
			{
				// Todo: need to replace unit value "px" with dynamic $obj unit value.
				$v =  (object) ['value' => $k === $device ? $obj : '', 'unit' => 'px'];
			}

			unset($v);

			return $newObject;
		}
		else
		{
			foreach ($obj as $k => &$v)
			{
				if (!\is_object($v))
				{
					$v = (object) ['value' => $v, 'unit' => 'px'];
				}
			}

			unset($v);
		}

		return $obj;
	}

	public function generate_layout_position_css($image_icon_position_device, $addon_id, $settings, $imageProps, $imageUnits) {
		if (!isset($image_icon_position_device)) {
			return '';
		}
		$feature_type = (isset($settings->feature_type) && $settings->feature_type) ? $settings->feature_type : 'icon';

		if ($image_icon_position_device === 'before') {
			$image_icon_position_device = 'after';
		} else if ($image_icon_position_device === 'after') {
			$image_icon_position_device = 'before';
		}
		$positions = ['before', 'after', 'left', 'right'];
	
		$css_output = '';
	
		foreach ($positions as $position) {
			if ($image_icon_position_device === $position) {
				$css_output .= $addon_id . ' .sppb-addon-content-align-' . $position . ' {
					display: block;
				} ';
			} else {
				$css_output .= $addon_id . ' .sppb-addon-content-align-' . $position . ' {
					display: none;
				} ';
			}
		}

		$isContainer = false;

		$cssStyle = '';

		$featureImageStyle = '';

		if ($feature_type === 'image' || $feature_type === 'both') {
			if (\in_array($image_icon_position_device, ['left', 'right'])) {
				$imageMarginSelector = '.sppb-media .pull-left, .sppb-media .pull-right';
				$cssStyle = $this->generateStyle($imageMarginSelector, $settings, ['feature_image_width' => 'width'], ['feature_image_width' => '%']);
			} elseif (\in_array($image_icon_position_device, ['before', 'after'])) {
				$imageMarginSelector = '.sppb-img-container';
				$isContainer = true;
			}
	
			if (!empty($imageMarginSelector)) {
				$featureImageStyle = $this->generateStyle($imageMarginSelector, $settings, $imageProps, $imageUnits, ['feature_image_margin' => 'spacing'], null, false, $isContainer ? 'display: block;' : '');
			}
		}

		$css_output .= $cssStyle;
		$css_output .= $featureImageStyle;

		return $css_output;
	}

	public function getTypographyPresetValue($preset)
	{
		if (empty($preset) || !is_string($preset) || !preg_match('/^\d+\.\d+$/', $preset)) {
			return null;
		}

		$elementNumber = (int) explode('.', $preset)[0];
		$elementIndex = (int) explode('.', $preset)[1];

		$db = Factory::getDbo();
		$query = $db->getQuery(true);
		$query->select('*')
			->from('#__sppagebuilder_typography');
		$db->setQuery($query);
		$result = $db->loadObjectList();

		if (empty($result)) {
			return null;
		}

		$result = !empty(json_decode(!empty($result[$elementNumber]->typography) ? $result[$elementNumber]->typography : '[]')) ? json_decode(!empty($result[$elementNumber]->typography) ? $result[$elementNumber]->typography : '[]')[$elementIndex] : null;

		if (empty($result)) {
			return null;
		}

		return $result;
	}

	/**
	 * Typography style generation by using the settings and fallback array.
	 *
	 * @param 	string 	$selector	The CSS selector.
	 * @param 	object 	$settings	The settings object.
	 * @param 	string 	$prop		The settings prop or the typography field name.
	 * @param 	array 	$fallback	The fallback array.
	 *
	 * @return 	string
	 * @since 	4.0.0
	 */
	public function typography($selector, $settings, $prop, $fallback = [])
	{
		$hasFallback = !empty($fallback) && !isset($settings->$prop);

		if ($hasFallback)
		{
			$font          = array_key_exists('font', $fallback) ? $fallback['font'] : "";
			$size          = array_key_exists('size', $fallback) ? $fallback['size'] : "";
			$lineHeight    = array_key_exists('line_height', $fallback) ? $fallback['line_height'] : "";
			$letterSpacing = array_key_exists('letter_spacing', $fallback) ? $fallback['letter_spacing'] : "";
			$uppercase     = array_key_exists('uppercase', $fallback) ? $fallback['uppercase'] : "";
			$italic        = array_key_exists('italic', $fallback) ? $fallback['italic'] : "";
			$underline     = array_key_exists('underline', $fallback) ? $fallback['underline'] : "";
			$weight        = array_key_exists('weight', $fallback) ? $fallback['weight'] : "";

			$settings->$prop = new \stdClass;
			$settings->$prop->font = $this->getFallbackValue($settings, $font);
			$settings->$prop->weight = $this->getFallbackValue($settings, $weight);
			$settings->$prop->uppercase = $this->getFallbackValue($settings, $uppercase);
			$settings->$prop->italic = $this->getFallbackValue($settings, $italic);
			$settings->$prop->underline = $this->getFallbackValue($settings, $underline);
			$settings->$prop->size = $this->getFallbackValue($settings, $size);
			$settings->$prop->line_height = $this->getFallbackValue($settings, $lineHeight);
			$settings->$prop->letter_spacing = $this->getFallbackValue($settings, $letterSpacing);
		}

		if (!isset($settings->$prop)) return '';

		$typography = $settings->$prop;

		if (!empty($typography->preset)) {
			$typography = $this->getTypographyPresetValue($typography->preset) ?? $typography;
		}

		$objectKeys = ["letter_spacing", "line_height", "size"];

		foreach ($objectKeys as $key)
		{
			if (isset($typography->$key))
			{
				$typography->$key = $this->purifyTypographyObject($typography->$key);
			}
		}

		if (!empty($typography->weight) && \preg_match("@[^\d]+@", $typography->weight))
		{
			$typography->weight = (int) $typography->weight;
		}

		/** If font exists to the typography field then register the font and load it. */
		if (!empty($typography->font))
		{
			$this->registerFont($typography->font);

			if (isset($typography->type) && $typography->type === 'local')
			{
				$this->loadLocalFont($typography->font);
			}
			else
			{
				$this->loadGoogleFont($typography->font);
			}
		}

		$props = [
			'font'           => isset($typography->font) && !empty($typography->font) ? 'font-family' : null,
			'weight'         => isset($typography->weight) && !empty($typography->weight) ?  'font-weight' : null,
			'uppercase'      => isset($typography->uppercase) && !empty($typography->uppercase)  ? 'text-transform' : null,
			'italic'         => isset($typography->italic) && !empty($typography->italic) ? 'font-style' : null,
			'underline'      => isset($typography->underline) && !empty($typography->underline) ? 'text-decoration' : null,
			'size'           => isset($typography->size) && !empty($typography->size) ? 'font-size' : null,
			'line_height'    => isset($typography->line_height) && !empty($typography->line_height) ? 'line-height' : null,
			'letter_spacing' => isset($typography->letter_spacing) && !empty($typography->letter_spacing) ? 'letter-spacing' : null
		];
		$units = ['font' => false, 'weight' => false, 'size' => false, 'uppercase' => false, 'italic' => false, 'underline' => false];
		$modifiers = [];
		$defaults = ['uppercase' => 'uppercase', 'italic' => 'italic', 'underline' => 'underline'];
		$typographyStyle = $this->generateStyle($selector, $typography, $props, $units, $modifiers, $defaults);

		return $typographyStyle;
	}

	/**
	 * Parse the color and generate a valid color property value.
	 *
	 * @param 	mixed 	$color	Object or string value of the color.
	 *
	 * @return 	string 	Returns the color value string.
	 * @since 	4.0.0
	 */
	public static function parseColor($settings, $prop): string
	{
		$originalProp = $prop . '_original';

		if (isset($settings->$originalProp))
		{
			$prop = $originalProp;
		}

		$color = isset($settings->$prop) ? $settings->$prop : '';

		if (\is_string($color))
		{
			return $color;
		}

		if (\is_object($color))
		{
			if (isset($color->type))
			{
				$color1 = "#398AF1";
				$color2 = "#5EDCED";

				if (!empty($color->color))
				{
					$color1 = !empty(preg_replace("@\s+@", "", $color->color)) ? $color->color : '#398AF1';
				}

				if (!empty($color->color2))
				{
					$color2 = !empty(preg_replace("@\s+@", "", $color->color2)) ? $color->color2 : '#5EDCED';
				}

				switch ($color->type)
				{
					case 'solid':
						return preg_replace("@\s+@", "", $color->color);
					case 'linear':
						$start = $color->pos ?? 0;
						$end = $color->pos2 ?? 100;
						return 'linear-gradient(' . ($color->deg ?? 0) . 'deg, ' . $color1 . ' ' . $start . '%, ' . $color2 . ' ' . $end . '%)';
					case 'radial':
						$start = $color->pos ?? 0;
						$end = $color->pos2 ?? 100;
						$position = $color->radialPos ?? 'center center';
						return 'radial-gradient(at ' . $position . ', ' . $color1 . ' ' . $start . '%, ' . $color2 . ' ' . $end . '%)';
					default:
						return $color->color ?? '';
				}
			}
		}

		return '';
	}

	/**
	 * Parse the alignment prop and generate the alignment value.
	 *
	 * @param 	object 	$settings	The settings object.
	 * @param 	string 	$prop		The alignment prop name.
	 * @param 	bool 	$flex		If the alignment for the flex or not.
	 *
	 * @return 	string 	The alignment value.
	 * @since 	4.0.0
	 */
	public static function parseAlignment($settings, $prop, $flex = false)
	{
		$primitiveProp = $prop;
		$originalProp = $prop . '_original';

		$prop = isset($settings->$originalProp) ? $originalProp : $prop;

		if (!isset($settings->$prop))
		{
			return '';
		}

		$alignmentMap = [
			'sppb-text-center' => 'center',
			'sppb-text-left'   => 'left',
			'sppb-text-right'  => 'right',
		];

		$flexMap = [
			'center' => 'center',
			'left'   => 'flex-start',
			'right'  => 'flex-end'
		];

		$alignment = $settings->$prop;

		if (self::hasMultiDeviceSettings($alignment))
		{
			if ($flex)
			{
				foreach ($alignment as &$value)
				{
					$value = isset($flexMap[$value]) ? $flexMap[$value] : $value;
				}

				unset($value);
			}
			else
			{
				foreach ($alignment as &$value)
				{
					$value = isset($alignmentMap[$value]) ? $alignmentMap[$value] : $value;
				}

				unset($value);
			}


			return $alignment;
		}

		$align =  isset($alignmentMap[$alignment]) ? $alignmentMap[$alignment] : $alignment;

		return $flex && isset($flexMap[$align]) ? $flexMap[$align] : $align;
	}

	private static function isEnabledBoxShadow($shadow)
	{
		if (empty($shadow))
		{
			return false;
		}

		if (\is_string($shadow))
		{
			$shadow = preg_replace("@\s+@", ' ', $shadow);
			$shadow = explode(' ', $shadow);
			$shadow = (object) $shadow;
		}

		$numberKeys = ['ho', 'vo', 'blur', 'spread'];

		if (\is_object($shadow))
		{

			if (isset($shadow->enabled))
			{
				return $shadow->enabled;
			}

			foreach ($shadow as $key => &$value)
			{
				if (\in_array($key, $numberKeys))
				{
					$value = (float) $value;

					if (!empty($value))
					{
						return true;
					}
				}

				if ($key === 'color')
				{
					$value = strtolower($value);

					return !($value === '#fff' || $value === '#ffffff');
				}
			}

			unset($value);
		}

		return false;
	}

	/**
	 * Parse the box shadow values and generate the box-shadow CSS property.
	 *
	 * @param 	object 	$settings		The addon settings.
	 * @param 	string 	$prop			The box-shadow settings key inside the $settings object.
	 * @param 	boolean $isTextShadow	Data comes from text-shadow or box shadow.
	 *
	 * @return 	string 	The generated box-shadow.
	 * @since 	4.0.0
	 */
	public static function parseBoxShadow($settings, string $prop, $isTextShadow = false): string
	{
		if (!isset($settings->$prop))
		{
			return '';
		}

		$box = $settings->$prop;

		if (\is_object($box))
		{
			$horizontalOffset = !empty($box->ho) ? $box->ho . 'px' : '0px';
			$verticalOffset = !empty($box->vo) ? $box->vo . 'px' : '0px';
			$blur = !empty($box->blur) ? $box->blur . 'px' : '0px';
			$spread = (!$isTextShadow) ? (!empty($box->spread) ? $box->spread . 'px' : '0px') : ' ';
			$color = !empty($box->color) ? $box->color : '';

			return self::isEnabledBoxShadow($box) ? $horizontalOffset . " " . $verticalOffset . " " . $blur . " " . $spread . " " . $color : '';
		}

		if ($box === '0 0 0 0 #fff' || $box === '0 0 0 #ffffff' || $box === '0 0 0 transparent' || $box === '0 0 0 0 transparent')
		{
			return '';
		}

		return $box;
	}

	/**
	 * Check if the value has a multi-device settings.
	 *
	 * @param 	mixed 		$value		The settings value.
	 *
	 * @return 	boolean
	 * @since	4.0.0
	 */
	private static function hasMultiDeviceSettings($value): bool
	{
		return isset($value->xl)
			|| isset($value->lg)
			|| isset($value->md)
			|| isset($value->sm)
			|| isset($value->xs);
	}

	/**
	 * Extract the value field, if the field has a unit property then add the unit with it.
	 *
	 * @param 	object 	$value	The value object.
	 *
	 * @return 	string 	The extracted string value.
	 * @since 	4.0.0
	 */
	private function extractValue($value): string
	{
		if (\is_object($value))
		{
			$_value = '';

			if (isset($value->value))
			{
				$_value = is_object($value->value) ? $value->value->value : $value->value;
			}

			if (!empty($_value) && isset($value->unit))
			{
				$_value .= is_object($value->unit) ? $value->unit->unit : $value->unit;
			}

			return $_value;
		}

		if (\is_array($value) && empty($value))
		{
			return $value = '';
		}

		return (string) $value;
	}

	/**
	 * Generate style for a specific selector with help of settings object, prop map, units etc.
	 *
	 * @param 	string 		$selector	The selector string where to apply the styles.
	 * @param 	\stdClass 	$settings	The settings object.
	 * @param 	array 		$propMap	The property map. The structure of the array is [prop => cssProp | [cssProps]]
	 * @param 	mixed 		$unit		The unit array. The structure of the array is [prop => unitValue | false]
	 * @param 	array 		$modifier	The modifier array. This array says if any modifier is needed to apply
	 * 									to this property. Currently we are covering the spacing property.
	 * 									if [prop => 'spacing'] is provided then handle the value as spacing value.
	 * @param 	mixed 		$default	The default values. This would be useful if we don't want to
	 * 									use the $settings->$prop value as a result but want
	 * 									user specific value as a value.
	 * @param 	boolean 	$important	The important specifier says if the property need
	 *									to append !important; at the end or not.
	 * @param 	string 		$static		Provided any static style value. If provided that would be contacted.
	 *
	 * @return string 					The CSS style with media query.
	 * @since 4.0.0
	 */
	public function generateStyle(string $selector, $settings, $propMap, $unit = 'px', $modifier = [], $default = null, $important = false, $static = ''): string
	{
		$device = self::$device;
		$selector = $this->generateSelector($selector);
		$css = [];
		$media = [];
		$_unit = 'px';
		$css[] = $selector . "{";

		if (!empty($static))
		{
			$css[] = $static;
		}

		foreach ($propMap as $prop => $cssProp)
		{
			if (\is_null($cssProp))
			{
				continue;
			}

			$primitiveProp = $prop;
			$originalProp = $prop . '_original';

			if (isset($settings->$originalProp))
			{
				$prop = $originalProp;
			}

			$_unit      = \is_array($unit) ? ($unit[$primitiveProp] ?? 'px') : $unit;
			$_important = \is_array($important) ? ($important[$primitiveProp] ?? false) : $important;
			$_default   = \is_array($default) ? ($default[$primitiveProp] ?? null) : $default;

			if (!isset($settings->$prop) && \is_null($_default))
			{
				continue;
			}

			if (isset($settings->$prop) && \is_string($settings->$prop) && preg_replace("@\s+@", '', $settings->$prop) === '' && \is_null($_default))
			{
				continue;
			}

			if (\is_string($cssProp))
			{
				$cssProp = [$cssProp];
			}

			if (!\is_null($_default))
			{
				$str = '';

				foreach ($cssProp as $attr)
				{
					$str .= $attr . ': ' . $_default . ';';
				}

				$css[] = $str;

				continue;
			}

			if (self::hasMultiDeviceSettings($settings->$prop))
			{
				$multiDeviceData = null;

				if (isset($modifier[$primitiveProp]) && $modifier[$primitiveProp] === 'spacing')
				{
					$multiDeviceData = AddonHelper::generateSpacingObject($settings, $prop, $cssProp, $device);
				}
				else
				{
					$multiDeviceData = AddonHelper::generateMultiDeviceObject($settings, $prop, $cssProp, $device, $_important, $_unit);
				}

				$media[] = $multiDeviceData;
				$css[] = $multiDeviceData->$device;
				unset($multiDeviceData);
			}
			else
			{
				if (isset($settings->$prop))
				{
					if (isset($modifier[$primitiveProp]) && $modifier[$primitiveProp] === 'spacing')
					{
						$_object = AddonHelper::generateSpacingObject($settings, $prop, $cssProp, $device);

						$media[] = $_object;
					}

					$val = $this->extractValue($settings->$prop);

					if (isset($val) && $val !== '')
					{
						foreach ($cssProp as $attr)
						{
							$str = "";

							if (!empty($_object) && !empty($_object->$device))
							{
								$str .= $_object->$device;
								unset($_object);
							}
							else
							{
								$str .= (strpos($attr, '%1$s') || strpos($attr, '%s')) !== false
									? \sprintf($attr, $this->extractValue($settings->$prop) ?? '')
									: $attr . ': ' . $this->extractValue($settings->$prop) ?? '';
							}

							if (!empty($_unit))
							{
								$str .= $_unit;
							}

							$str .= $_important ? ' !important' : '';

							if (substr($str, -1) !== ';')
							{
								$str .= ';';
							}

							$css[] = $str;
						}
					}
				}
			}
		}

		$css[] = "}";

		if (!empty($media))
		{
			$mediaStyle = array_map(function ($key) use ($selector, $media)
			{
				$str = AddonHelper::mediaQuery($key);
				$str .= $selector . "{";

				foreach ($media as $object)
				{
					$str .= $object->$key;
				}

				$str .= "}";
				$str .= "}";

				return $str;
			}, $this->getDeviceListExcludeDefault());

			$css[] = implode("\r\n", $mediaStyle);
		}

		$css = array_filter($css, function ($style)
		{
			return !empty($style);
		});

		return implode("\r\n", $css);
	}

	function getFormattedValue($transformFunctionCssValue, $value)
	{
		if (empty($value)) {
			return '';
		}

		$axises = ['x', 'y', 'z', 'top', 'left'];
		$values = [];
		$valueOfAxis = null;

		foreach($axises as $axis) {
			if(empty($value->$axis)) {
				continue;
			}

			if(is_object($value->$axis)) {
				$valueOfAxis = isset($value->$axis->value) ? $value->$axis->value : null;
				$unitOfAxis = isset($value->$axis->unit) ? $value->$axis->unit : null;
			} else if (is_string($value->$axis)) {
				$valueOfAxis = isset($value->$axis) ? $value->$axis : null;
				$unitOfAxis = '';
			}

			if(empty($valueOfAxis) && $valueOfAxis !== 0 && $valueOfAxis !== '0') {
				continue;
			}

			if($transformFunctionCssValue === 'transform_origin') {
				$values[] = $valueOfAxis . $unitOfAxis;
			} else {
				$values[] = $transformFunctionCssValue . strtoupper($axis) . '(' . $valueOfAxis . $unitOfAxis . ')';
			}
		}

		return implode(' ', $values);
	}

	/**
	 * Parse style for transform property
	 * @since 5.2.10
	 * 
	 * @param 	string 		$selector	The selector string where to apply the styles.
	 * @param	\stdClass	$settings 	The settings object
	 * @param	string		$prop		The filter settings key inside the $settings object
	 * 
	 * @return string 					
	 */
	public function generateTransformStyle(string $selector, $settings, $prop): string
	{
		$selector = $this->generateSelector($selector);
		$transform = isset($settings->$prop) ? $settings->$prop : null;

		if (!isset($transform)) {
			return '';
		}

		// Define an array to store transform functions
		$transformFunctions = [];
		$transformFunctionMap = [
			'move' => 'translate',
			'rotate' => 'rotate',
			'scale' => 'scale',
			'skew' => 'skew',
		];

		foreach ($transformFunctionMap as $transformFunction => $transformFunctionCssValue) {
			if (!empty($transform->$transformFunction)) {
				$unitWithValue = $this->getFormattedValue($transformFunctionCssValue, $transform->$transformFunction);

				if(!empty($unitWithValue)) {
					$transformFunctions[] = $unitWithValue;
				}
			}
		}

		$transformOriginValue = '';
		if(!empty($transform->transform_origin)) {
			$value = $this->getFormattedValue('transform_origin', $transform->transform_origin);

			if(!empty($value)) {
				$transformOriginValue = 'transform-origin: ' . $value . ';';
			}
		}

		$finalCssStyle = '';
		if (!empty($transformFunctions) || !empty($transformOriginValue)) {
			$finalCssStyle .= $selector . '{ ';
				
			if(!empty($transformFunctions)) {
				$finalCssStyle .= 'transform: ' .  implode(' ', $transformFunctions) . '; ';
			}

			if(!empty($transformOriginValue)) {
				$finalCssStyle .= $transformOriginValue;
			}

			$finalCssStyle .= ' }';
		}

		return $finalCssStyle;
	}

	/**
	 * Parse style for css filter property
	 * @since 5.2.8
	 * 
	 * @param	\stdClass	$settings 	The settings object
	 * @param	string		$prop		The filter settings key inside the $settings object
	 * 
	 * @return string 					
	 */
	public static function parseCssEffects($settings, $prop): string {
		$effects = $settings->$prop;

		if (!isset($effects))
		{
			return '';
		}

		// Define an array to store filter functions
		$filterFunctions = [];

		// CSS unit definitions
		$effectsKeyUnit = [
			'opacity' => '%',
			'blur' => 'px',
			'brightness' => '%',
			'contrast' => '%',
			'saturate' => '%',
			'grayscale' => '%',
			'invert' => '%',
			'sepia' => '%',
			'hue_rotate' => 'deg',
		];
	
		foreach ($effectsKeyUnit as $filterFunction => $unit) {
			// Ensure property is valid and exists in $effectsKeyUnit
			if (!empty($effects->$filterFunction)) {
				$updatedFunction = $filterFunction === 'hue_rotate' ? 'hue-rotate' : $filterFunction;
				$filterFunctions[] = $updatedFunction . '(' . $effects->$filterFunction . $unit . ')';
			}
		}
	
		$parsedFilterCssValue = '';

		// If there are filter functions, construct the CSS rule
		if (!empty($filterFunctions)) {
			$parsedFilterCssValue = implode(' ', $filterFunctions);
		}

		return $parsedFilterCssValue;
	}

	/**
	 * Parse the backdrop filter values and generate the backdrop filter CSS property.
	 *
	 * @param object $settings			The Add-On settings.
	 * @param string $property			The backdrop-filter settings key inside the $settings object.
	 * @param string $propertyValue		The backdrop settings value.
	 * @since  4.0.8
	 * @return string
	 */
	public static function parseBackDropFilter($settings, string $property, string $propertyValue)
	{
		if (!isset($settings->$property))
		{
			return '';
		}

		$unit 		 = ($settings->$property == 'blur') ? 'px' : '%';
		$parsedValue = $settings->$property . '(' . $settings->$propertyValue . $unit . ')';

		return $parsedValue;
	}

	    /**
     * Parse responsive property and return value for the current device
     *
     * @param  mixed $property   The responsive property object or value
     * @param  string $device    Optional - specific device to target (defaults to current device)
     * @return mixed             The value for the current or specified device
     * @since  5.5.8
     */
    public static function getResponsiveValue($property, $device = null)
    {
        if (empty($property)) {
            return '';
        }
        
        if ($device === null) {
            $device = self::$device;
        }
        
        if (!is_object($property)) {
            return $property;
        }
        
        $deviceKeys = ['xl', 'lg', 'md', 'sm', 'xs'];
        $hasResponsiveValues = false;
        
        foreach ($deviceKeys as $key) {
            if (isset($property->$key)) {
                $hasResponsiveValues = true;
                break;
            }
        }
        
        if (!$hasResponsiveValues) {
            if (isset($property->value)) {
                return isset($property->unit) ? $property->value . $property->unit : $property->value;
            }
            
            return $property;
        }
        
        if (isset($property->$device)) {
            $deviceValue = $property->$device;
            
            if (!is_object($deviceValue)) {
                return $deviceValue;
            }
            
            if (isset($deviceValue->value)) {
                return isset($deviceValue->unit) ? $deviceValue->value . $deviceValue->unit : $deviceValue->value;
            }
            
            return $deviceValue;
        }
        
        $deviceIndex = array_search($device, $deviceKeys);
        
        for ($i = $deviceIndex - 1; $i >= 0; $i--) {
            $largerDevice = $deviceKeys[$i];
            if (isset($property->$largerDevice)) {
                $value = $property->$largerDevice;
                
                if (!is_object($value)) {
                    return $value;
                }
                
                if (isset($value->value)) {
                    return isset($value->unit) ? $value->value . $value->unit : $value->value;
                }
                
                return $value;
            }
        }
        
        for ($i = $deviceIndex + 1; $i < count($deviceKeys); $i++) {
            $smallerDevice = $deviceKeys[$i];
            if (isset($property->$smallerDevice)) {
                $value = $property->$smallerDevice;
                
                if (!is_object($value)) {
                    return $value;
                }
                
                if (isset($value->value)) {
                    return isset($value->unit) ? $value->value . $value->unit : $value->value;
                }
                
                return $value;
            }
        }
        
        return '';
    }

	/**
	 * Generate missing break points of field width for old layouts.
	 *
	 * @param  object $fieldWidth	given breakpoints of field width
	 *
	 * @return object
	 *
	 * @since  4.0.9
	 */
	public static function generateMissingBreakPoints($fieldWidth)
	{
		$missing_breakpoints = ['xl', 'lg'];

		foreach ($missing_breakpoints as $key)
		{
			if (!property_exists($fieldWidth, $key))
			{
				$fieldWidth->$key = isset($fieldWidth->md) && $fieldWidth->md ? $fieldWidth->md : "";
			}
		}

		return $fieldWidth;
	}

	public static function generateBorderWidth(array $width, $style, $color)
	{
		$positions = ['top', 'right', 'bottom', 'left'];
		$widthStyles = [];
		$slicedWidth = array_slice($width, 0, 4);

		foreach ($slicedWidth as $index => $value) {
			if (trim($value) !== '') {
				$widthStyles[] = 'border-' . $positions[$index] . ': ' . $value . ' ' . $style . ' ' . $color . ';';
			}
		}

		return implode("\n\r", $widthStyles);
	}

	public function border($selector, $settings, $prop)
	{
		$value = $settings->{$prop . '_original'} ?? $settings->$prop ?? null;
		$output = '';

		if (is_null($value))
		{
			return '';
		}

		$deviceKeys = ['xl', 'lg', 'md', 'sm', 'xs'];
		$isResponsive = false;
		foreach ($value as $key => $_) {
			if (array_key_exists($key, array_flip($deviceKeys))) {
				$isResponsive = true;
				break;
			}
		}

		if ($isResponsive)
		{
			$defaultDevice = SpPgaeBuilderBase::$defaultDevice;

			foreach ($deviceKeys as $key) {
				if (isset($value->$key))
				{
					$option = $value->$key;
					$width = isset($option->border_width) ? $option->border_width : '';
					$style = isset($option->border_style) ? $option->border_style : '';
					$color = isset($option->border_color) ? $option->border_color : '';

					$widthParts = explode(' ', $width);

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

					$borderStyle = '';

					if (count($widthParts) === 1)
					{
						$borderStyle = 'border: ' . $width . ' ' . $style . ' ' . $color . ';';
					}
					else
					{
						$borderStyle = static::generateBorderWidth($widthParts, $style, $color);
					}

					$generatedSelector = $this->generateSelector($selector);
					$str = '';

					if ($defaultDevice === $key)
					{
						$str .= $generatedSelector . '{';
						$str .= $borderStyle;
						$str .= '}';
					}
					else
					{
						$str .= AddonHelper::mediaQuery($key);
						$str .= $generatedSelector . '{';
						$str .= $borderStyle;
						$str .= '}';
						$str .= '}';
					}

					$output .= $str;
				}
			}
		}
		else
		{
			$width = isset($value->border_width) ? $value->border_width : '';
			$style = isset($value->border_style) ? $value->border_style : '';
			$color = isset($value->border_color) ? $value->border_color : '';

			$widthParts = explode(' ', $width);

			if (empty($widthParts))
			{
				return '';
			}

			$css = '';

			if (count($widthParts) === 1)
			{
				$css = 'border: ' . $width . ' ' . $style . ' ' . $color . ';';
			}
			else
			{
				$css = static::generateBorderWidth($widthParts, $style, $color);
			}

			$generatedSelector = $this->generateSelector($selector);

			$output = $generatedSelector . ' {';
			$output .= $css;
			$output .= '}';
		}

		return $output;
	}

	public static function generateCSSVariablesString(array $variables)
	{
		$variablesString = '';

		foreach ($variables as $key => $value) {
			$variablesString .= $key . ': ' . $value . ';';
		}

		return $variablesString;
	}
}
