<?php

if ( !defined('ABSPATH' ) )
    exit();

/**
 * Outputs language switcher.
 *
 * Uses customization options from Shortcode language switcher.
 */
function translangated_the_language_switcher(){
    $trp = Translangated_Plugin::get_translangated_instance();
    $language_switcher = $trp->get_component( 'language_switcher' );
    echo wp_kses( (string) $language_switcher->language_switcher(), translangated_kses_language_switcher_allowed_html() );
}

/**
 * Wrapper function for json_encode to eliminate possible UTF8 special character errors
 * @param $value
 * @return mixed|string|void
 */
function translangated_safe_json_encode($value){
    if (version_compare(PHP_VERSION, '5.4.0') >= 0 && apply_filters('translangated_safe_json_encode_pretty_print', true )) {
        $encoded = wp_json_encode($value, JSON_PRETTY_PRINT);
    } else {
        $encoded = wp_json_encode($value);
    }
    switch (json_last_error()) {
        case JSON_ERROR_NONE:
            return $encoded;
        case JSON_ERROR_DEPTH:
            return 'Maximum stack depth exceeded'; // or trigger_error() or throw new Exception()
        case JSON_ERROR_STATE_MISMATCH:
            return 'Underflow or the modes mismatch'; // or trigger_error() or throw new Exception()
        case JSON_ERROR_CTRL_CHAR:
            return 'Unexpected control character found';
        case JSON_ERROR_SYNTAX:
            return 'Syntax error, malformed JSON'; // or trigger_error() or throw new Exception()
        case JSON_ERROR_UTF8:
            $clean = translangated_utf8ize($value);
            return translangated_safe_json_encode($clean);
        default:
            return 'Unknown error'; // or trigger_error() or throw new Exception()

    }
}

/**
 * Helper function for translangated_safe_json_encode that helps eliminate utf8 json encode errors
 * @param $mixed
 * @return array|string
 */
function translangated_utf8ize($mixed) {
    if (is_array($mixed)) {
        foreach ($mixed as $key => $value) {
            $mixed[$key] = translangated_utf8ize($value);
        }
    } else if (is_string ($mixed)) {
        // Replace only the invalid byte sequences with U+FFFD; valid UTF-8 is kept as is (core since WP 6.9).
        return wp_scrub_utf8( $mixed );
    }
    return $mixed;
}

/**
 * function that gets the translation for a string with context directly from a .mo file
 * @TODO this was developped firstly for woocommerce so it maybe needs further development.
*/
function translangated_x( $text, $context, $domain, $language ) {
    $original_text = $text;

    $cache_key = 'translangated_x_' . md5( $text . $context . $domain . $language );
    $new_text  = wp_cache_get( $cache_key );
    if ( $new_text !== false ) {
        return $new_text;
    }
    /* try to find the correct path for the textdomain */
    $path_cache_key = 'translangated_x_path_' . md5( $domain . $language );
    $path           = wp_cache_get( $path_cache_key );
    if ( $path === false ) {
        $path = translangated_find_translation_location_for_domain( $domain, $language );
        wp_cache_set( $path_cache_key, $path );
    }

    if ( !empty( $path ) ) {

        $mo_file = translangated_cache_get( 'translangated_x_' . $domain . '_' . $language );

        if ( false === $mo_file ) {
            $mo_file = new MO();
            $mo_file->import_from_file( $path );
            wp_cache_set( 'translangated_x_' . $domain . '_' . $language, $mo_file );
        }

        if ( !$mo_file ) {
            $return = apply_filters( 'translangated_x', $text, $original_text, $context, $domain, $language );
            wp_cache_set( $cache_key, $return );
            return $return;
        }

        if ( !empty( $mo_file->entries[ $context . '' . $text ] ) ) {
            $text = $mo_file->entries[ $context . '' . $text ]->translations[0];
        }
    }

    $return = apply_filters( 'translangated_x', $text, $original_text, $context, $domain, $language );
    wp_cache_set( $cache_key, $return );
    return $return;
}

/**
 * Function that tries to find the path for a translation file defined by textdomain and language
 * @param $domain the textdomain of the string that you want the translation for
 * @param $language the language in which you want the translation
 * @return string the path of the mo file if it is found else an empty string
 */
function translangated_find_translation_location_for_domain( $domain, $language ){
    global $translangated_template_directory;
    if ( !isset($translangated_template_directory)){
        // "caching" this because it sometimes leads to increased page load time due to many calls
        $translangated_template_directory = get_template_directory();
    }
    $path = '';

    if( file_exists( WP_LANG_DIR . '/plugins/'. $domain .'-' . $language . '.mo') ) {
        $path = WP_LANG_DIR . '/plugins/'. $domain .'-' . $language . '.mo';
    }
    elseif ( file_exists( WP_LANG_DIR . '/themes/'. $domain .'-' . $language . '.mo') ){
        $path = WP_LANG_DIR . '/themes/'. $domain .'-' . $language . '.mo';
    } elseif( $domain === '' && file_exists( WP_LANG_DIR . '/' . $language . '.mo')){
        $path = WP_LANG_DIR . '/' . $language . '.mo';
    } else {
        $possible_translation_folders = array( '', 'languages/', 'language/', 'translations/', 'translation/', 'lang/' );
        foreach( $possible_translation_folders as $possible_translation_folder ){
            if (file_exists($translangated_template_directory . '/' . $possible_translation_folder . $domain . '-' . $language . '.mo')) {
                $path = $translangated_template_directory . '/' . $possible_translation_folder . $domain . '-' . $language . '.mo';
            } elseif ( file_exists(dirname( TRANSLANGATED_DIR ) . '/' . $domain . '/' . $possible_translation_folder . $domain . '-' . $language . '.mo') ) {
                $path = dirname( TRANSLANGATED_DIR ) . '/' . $domain . '/' . $possible_translation_folder . $domain . '-' . $language . '.mo';
            }
        }
    }

    return $path;
}

/**
 * Sanitizes data decoded from a JSON request field (json_decode() alone does not sanitize).
 * Strings go through $sanitize_string, numbers and booleans are kept, anything else becomes null.
 * Callers still sanitize each field for its own use (kses for translations, esc_url_raw for URLs, casts for ids).
 */
function translangated_sanitize_decoded_json( $data, $sanitize_string = 'translangated_sanitize_json_string' ) {
    return map_deep( $data, function ( $value ) use ( $sanitize_string ) {
        if ( is_string( $value ) ) {
            return call_user_func( $sanitize_string, $value );
        }
        return ( is_int( $value ) || is_float( $value ) || is_bool( $value ) ) ? $value : null;
    } );
}

/**
 * Default string pass for JSON input: drops invalid UTF-8 and <script> blocks, keeps the rest
 * (translations may hold HTML and percent-encoded URLs).
 */
function translangated_sanitize_json_string( $value ) {
    return preg_replace( '/<script\b[^>]*>.*?<\/script>/is', '', wp_check_invalid_utf8( $value ) );
}

/**
 * Reads, decodes and sanitizes a JSON-encoded $_POST field. Callers verify the nonce first.
 *
 * @return array|object Decoded data, or an empty array when the field is missing or not JSON.
 */
function translangated_get_json_post( $key, $assoc = false, $sanitize_string = 'translangated_sanitize_json_string' ) {
    if ( ! isset( $_POST[ $key ] ) || ! is_string( $_POST[ $key ] ) ) { // phpcs:ignore WordPress.Security.NonceVerification.Missing -- callers verify the nonce.
        return array();
    }
    return translangated_sanitize_json_input( wp_unslash( $_POST[ $key ] ), $assoc, $sanitize_string ); // phpcs:ignore WordPress.Security.NonceVerification.Missing, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- callers verify the nonce; decoded and sanitized by translangated_sanitize_json_input().
}

/**
 * Decode a JSON string from a request and sanitize every value (json_decode() alone does not sanitize).
 *
 * @return array|object Sanitized data, or an empty array when the input is not a JSON array/object.
 */
function translangated_sanitize_json_input( $json, $assoc = false, $sanitize_string = 'translangated_sanitize_json_string' ) {
    $data = is_string( $json ) ? json_decode( $json, $assoc ) : null;
    return ( is_array( $data ) || is_object( $data ) ) ? translangated_sanitize_decoded_json( $data, $sanitize_string ) : array();
}

/**
 * Sanitize a request URI.
 *
 * esc_url_raw() drops literal { } " < > characters, which some plugins send unencoded inside query
 * strings (e.g. ?jet_ajax_search_settings={"search_source":"product"}). They are percent-encoded first,
 * so they survive; already-encoded URIs are unchanged.
 */
function translangated_sanitize_request_uri( $uri ) {
    return esc_url_raw( strtr( (string) $uri, array( '{' => '%7B', '}' => '%7D', '"' => '%22', '<' => '%3C', '>' => '%3E' ) ) );
}

/**
 * Reads a JSON-encoded list of ids from $_POST as positive integers.
 */
function translangated_get_json_post_ids( $key ) {
    $ids = array_filter( (array) translangated_get_json_post( $key, true ), 'is_scalar' );
    return array_values( array_filter( array_map( 'absint', $ids ) ) );
}

/**
 * Function that makes string safe for display.
 *
 * Can be used on original or translated string.
 * Removes any unwanted html code from the string.
 * Do not confuse with trim.
 */
function translangated_sanitize_string( $filtered, $execute_wp_kses = true ){
    // Numbers and strings are ok. Unexpected arrays, objects or null are not ok.
    if (!is_scalar($filtered)) return '';

	$filtered = preg_replace( '/<script\b[^>]*>(.*?)<\/script>/is', '', $filtered );

	// don't remove \r \n \t. They are part of the translation, they give structure and context to the text.
	//$filtered = preg_replace( '/[\r\n\t ]+/', ' ', $filtered );
	$filtered = trim( $filtered );

	$found = false;
	while ( preg_match('/%[a-f0-9]{2}/i', $filtered, $match) ) {
		$filtered = str_replace($match[0], '', $filtered);
		$found = true;
	}

	if ( $found ) {
		// Strip out the whitespace that may now exist after removing the octets.
		$filtered = trim( preg_replace('/ +/', ' ', $filtered) );
	}

    if ( $execute_wp_kses ){
        $filtered = translangated_wp_kses( (string) $filtered );
    }
    return $filtered;
}

function translangated_wp_kses($string){
    if ( apply_filters('translangated_apply_wp_kses_on_strings', true) ){
        add_filter( 'wp_kses_allowed_html', 'translangated_prevent_kses_from_stripping_translangated_wbr_tag', 10, 2 );
        $string = wp_kses_post($string);
        remove_filter('wp_kses_allowed_html', 'translangated_prevent_kses_from_stripping_translangated_wbr_tag', 10);
    }

    return $string;
}

function translangated_prevent_kses_from_stripping_translangated_wbr_tag( $allowedposttags, $context ){

    if ( $context === 'post' ){
        $allowedposttags['wbr'] = true;
    }

    return $allowedposttags;
}

/**
 * function that checks if $_REQUEST['trp-edit-translation'] is set or if it has a certain value
 */
function translangated_is_translation_editor( $value = '' ){
    if( isset( $_REQUEST['trp-edit-translation'] ) ){
        if( !empty( $value ) ) {
            if( $_REQUEST['trp-edit-translation'] === $value ) {
                return true;
            }
            else{
                return false;
            }
        }
        else{
            $possible_values = array ('preview', 'true');
            if( in_array( $_REQUEST['trp-edit-translation'], $possible_values ) ) {
                return true;
            }
        }
    }

    return false;
}

/**
 * Output an SVG depending on case.
 *
 * @param string $icon The icon to output. Default no icon.
 */
function translangated_output_svg( $icon = '' ) {
    switch ( $icon ) {
        case 'check':
            ?>
            <svg class="trp-svg-icon fas-check-circle"><use xlink:href="#check-circle"></use></svg>
            <?php
            break;
        case 'error':
            ?>
            <svg class="trp-svg-icon fas-times-circle"><use xlink:href="#times-circle"></use></svg>
            <?php
            break;
        default:
            break;
    }
}

/**
 * Debuger function. Mainly designed for the get_url_for_language() function
 *
 * @since 1.3.6
 *
 * @param bool $enabled
 * @param array $logger
 */
function translangated_bulk_debug($debug = false, $logger = array()){
    if ( ! $debug || ! ( defined( 'WP_DEBUG' ) && WP_DEBUG ) ) {
        return;
    }
    error_log('---------------------------------------------------------'); // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log -- Opt-in URL converter debug trace; only runs when the caller passes $debug and WP_DEBUG is on.
    $key_length = '';
    foreach ($logger as $key => $value){
        if ( strlen($key) > $key_length)
            $key_length = strlen($key);
    }

    foreach ($logger as $key => $value){
        error_log("$key :   " . str_repeat(' ', $key_length - strlen($key)) . $value); // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log -- Opt-in URL converter debug trace; only runs when the caller passes $debug and WP_DEBUG is on.
    }
    error_log('---------------------------------------------------------'); // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log -- Opt-in URL converter debug trace; only runs when the caller passes $debug and WP_DEBUG is on.
}

/**
 * Used for showing useful notice in Translation Editor
 *
 * @return bool
 */
function translangated_is_paid_version() {
	// Check if Translangated paid plugins are active
	$paid_plugins = array(
		'Translangated - Personal'  => 'translangated-personal/index.php',
		'Translangated - Business'  => 'translangated-business/index.php',
		'Translangated - Developer' => 'translangated-developer/index.php'
	);


    $active_plugins = get_option('active_plugins', array());
    foreach ($paid_plugins as $plugin_file) {
        if (is_array($active_plugins) && in_array($plugin_file, $active_plugins)) {
            return true;
        }
    }

	//list of class names
	$addons = apply_filters( 'translangated_paid_addons', array(
		'Translangated_IN_Automatic_Language_Detection',
		'Translangated_IN_Browse_as_other_Role',
		'Translangated_IN_Extra_Languages',
		'Translangated_IN_Navigation_Based_on_Language',
		'Translangated_IN_Seo_Pack',
		'Translangated_IN_Translator_Accounts',
        'Translangated_Automatic_Language_Detection',
        'Translangated_Browse_as_other_Role',
        'Translangated_Extra_Languages',
        'Translangated_Navigation_Based_on_Language',
        'Translangated_Seo_Pack',
        'Translangated_Translator_Accounts',
	) );

	foreach ( $addons as $className ) {
		if ( class_exists( $className ) ) {
			return true;
		}
	}

	return false;
}

/**
 * Execute do_shortcode with a specific list of tags
 *
 * @param $content          string      String to execute do_shortcode on
 * @param $tags_allowed     array       Array of tags allowed to be executed
 * @return string           string      Resulted string
 */
function translangated_do_these_shortcodes( $content, $tags_allowed ){
    global $shortcode_tags;
    $copy_shortcode_tags = $shortcode_tags;

    // select the allowed shortocde tags from the global array
    $allowed_shortcode_tags = array();
    foreach( $shortcode_tags as $shortcode_tag_key => $shortcode_tag_value){
        if ( in_array( $shortcode_tag_key, $tags_allowed ) ){
            $allowed_shortcode_tags[$shortcode_tag_key] = $shortcode_tag_value;
        }
    }

    // only execute these shortcode tags on the content
    $shortcode_tags = $allowed_shortcode_tags;

    // run shortcode
    $return_content = do_shortcode($content);

    // revert changes to shortcode_tags array
    $shortcode_tags = $copy_shortcode_tags;

    return $return_content;
}

/**
 * Obtains a list of TP languages. Can be without the default one
 * in which case use the parameter nodefault set to 'nodefault'
 *
 * @param string $nodefault param used to return published languages without default one
 * @return mixed array with key/value pairs of published language codes and names
 *
 */
function translangated_get_languages($nodefault=null)
{
    $translangated_obj = Translangated_Plugin::get_translangated_instance();
    $settings_obj = $translangated_obj->get_component('settings');
    $lang_obj = $translangated_obj->get_component('languages');

    $default_lang_labels = $settings_obj->get_setting('default-language');
    $published_lang = $settings_obj->get_setting('publish-languages');
    $published_lang_labels = $lang_obj->get_language_names($published_lang);
    if (isset($nodefault) && $nodefault === 'nodefault'){
        unset ($published_lang_labels[$default_lang_labels]);
    }
    return ($published_lang_labels);
}

/**
 * Wrapper function for wp_cache_get() that bypasses cache if TRANSLANGATED_DEBUG is on
 * @param int|string $key   The key under which the cache contents are stored.
 * @param string     $group Optional. Where the cache contents are grouped. Default empty.
 * @param bool       $force Optional. Whether to force an update of the local cache
 *                          from the persistent cache. Default false.
 * @param bool       $found Optional. Whether the key was found in the cache (passed by reference).
 *                          Disambiguates a return of false, a storable value. Default null.
 * @return mixed|false The cache contents on success, false on failure to retrieve contents or false when WP_DEBUG is on
 *
 */
function translangated_cache_get( $key, $group = '', $force = false, &$found = null ){
    if( defined( 'TRANSLANGATED_DEBUG' ) && TRANSLANGATED_DEBUG == true )
        return false;

    $cache = wp_cache_get( $key, $group, $force, $found );
    return $cache;
}

/**
 * Wrapper function for get_transient() that bypasses cache if TRANSLANGATED_DEBUG is on
 */
function translangated_get_transient( $transient ){
    if( ( defined( 'TRANSLANGATED_DEBUG' ) && TRANSLANGATED_DEBUG == true ) || defined( 'TRANSLANGATED_DEBUG_TRANSIENT' ) && TRANSLANGATED_DEBUG_TRANSIENT == true  )
        return false;

    return get_transient($transient);
}

/**
 * Determine if the setting in Advanced Options should make us add a slash at end of string
 * @param $settings the Translangated settings object
 * @return bool
 */
function translangated_force_slash_at_end_of_link( $settings ){
    if ( !empty( $settings['translangated_advanced_settings'] ) && isset( $settings['translangated_advanced_settings']['force_slash_at_end_of_links'] ) && $settings['translangated_advanced_settings']['force_slash_at_end_of_links'] === 'yes' )
        return true;
    else
        return false;
}

/**
 * This function is used by users to create their own language switcher.
 *It returns an array with all the necessary information for the user to create their own custom language switcher.
 *
 * @return array
 *
 * The array returned has the following indexes: language_name, language_code, short_language_name, flag_link, current_page_url
 */

function translangated_custom_language_switcher() {
    $trp           = Translangated_Plugin::get_translangated_instance();
    $translangated_languages = $trp->get_component( 'languages' );
    $translangated_settings  = $trp->get_component( 'settings' );
    $settings      = $translangated_settings->get_settings();

    $languages_to_display  = $settings['publish-languages'];
    $translation_languages = $translangated_languages->get_language_names( $languages_to_display );

    $url_converter = $trp->get_component( 'url_converter' );

    $custom_ls_array = array();

    foreach ( $translation_languages as $item => $language ) {

        $custom_ls_array[ $item ]['language_name']       = $language;
        $custom_ls_array[ $item ]['language_code']       = $item;
        $custom_ls_array[ $item ]['short_language_name'] = $url_converter->get_url_slug( $item, false );

        $flags_path = TRANSLANGATED_PLUGIN_URL . 'assets/images/flags/';
        $flags_path = apply_filters( 'translangated_flags_path', $flags_path, $item );

        $flag_file_name = $item . '.png';
        $flag_file_name = apply_filters( 'translangated_flag_file_name', $flag_file_name, $item );

        $custom_ls_array[ $item ]['flag_link'] = esc_url( $flags_path . $flag_file_name );

        $custom_ls_array[ $item ]['current_page_url'] = esc_url( $url_converter->get_url_for_language( $item, null, '' ) );
    }

    return $custom_ls_array;
}

/**Function that provides translation for a specific text or html content, into another language.
 * The function can be used by third party plugin/theme authors.
 *
 * @param string $content is the content you want to translate, it must be in the default language and it can be any text or html code
 * @param string $language is the language you want to translate the content into, if it is left undefined the content will be translated
 * to the current language; it's set to current language by default
 * @param bool $prevent_over_translation is a parameter that prevents the translated content from being translated again during the translation
 * of the page. This can be set to false if the translated content is used in a way that Translangated can't detect the text.
 * It's set to true by default
 * @return string is the translated content in the chosen language
 */
function translangated_translate( $content, $language = null, $prevent_over_translation = true ){
    $trp = Translangated_Plugin::get_translangated_instance();
    $translangated_render = $trp->get_component( 'translation_render' );
    global $TRANSLANGATED_LANGUAGE;

    $lang_backup = $TRANSLANGATED_LANGUAGE;

    if ($language !== null){
        $TRANSLANGATED_LANGUAGE = $language;
    }
    $translated_custom_content = $translangated_render->translate_page($content);

    if ($prevent_over_translation === true){
        $translated_custom_content = '<span data-no-translation>' . $translated_custom_content .'</span>';
    }

    $TRANSLANGATED_LANGUAGE = $lang_backup;

    return $translated_custom_content;
}

/**
 * Function that returns the license status of the Translangated plugin.
 * @return string
 */
function translangated_get_license_status(){
    // Translangated: no licensing, everything is included
    return 'valid';
}

/**
 * Used by third parties to briefly switch language such as when sending an email
 * To get a user's preferred language use this code: get_user_meta( $user_id, 'translangated_language', true );
 *
 * @param $language
 * @return bool Whether WordPress pushed a locale that must subsequently be restored.
 */
function translangated_switch_language($language){
    global $TRANSLANGATED_LANGUAGE, $TRANSLANGATED_LANGUAGE_COPY, $TRANSLANGATED_LANGUAGE_ORIGINAL;
    $language = translangated_validate_language( $language );
    $TRANSLANGATED_LANGUAGE_ORIGINAL = $TRANSLANGATED_LANGUAGE;
    $TRANSLANGATED_LANGUAGE = $language;
    $TRANSLANGATED_LANGUAGE_COPY = $language;

    // Because of 'translangated_before_translate_content' filter function is_ajax_frontend() is called and it changes the global $TRANSLANGATED_LANGUAGE according to the url from which it was called.
    // Function translangated_reset_language() is added on the hook in order to set global $TRANSLANGATED_LANGUAGE according to our need for the email language instead.
    add_filter( 'translangated_before_translate_content', 'translangated_reset_language', 99999999 );

    $switched_locale = switch_to_locale($language);
    add_filter( 'plugin_locale', 'translangated_get_locale', 99999999);
    return $switched_locale;
}

/**
 * Switch to a user's preferred language based on the recipient email.
 *
 * For managerial users (admin-like roles), prefer user->locale with fallback
 * to WPLANG, then translangated_language.
 *
 * For non-managerial users, prefer translangated_language, with fallback to locale, then WPLANG.
 *
 * @param string $email
 * @return bool True when a preferred-language switch was applied.
 */
function translangated_switch_to_preffered_language( $email ) {
    $email = trim( (string) $email );

    if ( $email === '' )
        return false;

    $user = get_user_by( 'email', $email );

    if ( ! ( $user instanceof WP_User ) )
        return false;

    $user_roles = is_array( $user->roles ) ? $user->roles : array();

    $translangated_settings = Translangated_Plugin::get_translangated_instance()->get_component( 'settings' );
    $settings     = $translangated_settings->get_settings();

    $default_language = $settings["default-language"];

    /**
     * Roles considered "managerial" for email language purposes.
     *
     * @param string[] $roles
     */
    $managerial_roles = apply_filters(
        'translangated_managerial_roles_for_email_language',
        [ 'administrator', 'editor', 'shop_manager' ]
    );

    $is_managerial = !empty( array_intersect( $managerial_roles, $user_roles ) );

    if ( $is_managerial ) {
        // Managerial: prefer locale, then WPLANG, then default_language
        if ( !empty( $user->locale ) ) {
            $language = $user->locale;
        } else {
            $wplang = get_option( 'WPLANG' );
            $language = !empty( $wplang ) ? $wplang : $default_language;
        }
    } else {
        // Non-managerial: prefer translangated_language.
        $language = get_user_meta( $user->ID, 'translangated_language', true );

        if ( empty( $language ) ) {
            if ( !empty( $user->locale ) ) {
                $language = $user->locale;
            } else {
                $wplang = get_option( 'WPLANG' );
                $language = !empty( $wplang ) ? $wplang : $default_language;
            }
        }
    }

    if ( empty( $language ) )
        return false;

    translangated_switch_language( $language );

    return true;
}

/**
 * Return $TRANSLANGATED_LANGUAGE as plugin locale
 *
 * @return mixed
 */
function translangated_get_locale() {
    global $TRANSLANGATED_LANGUAGE;
    return $TRANSLANGATED_LANGUAGE;
}

/**
 * The value of $TRANSLANGATED_LANGUAGE is set according to the url, which can be problematic in some cases when sending emails
 * Restore the $TRANSLANGATED_LANGUAGE value in which email will be sent
 *
 * @param $output
 * @return mixed
 */
function translangated_reset_language( $output ){
    global $TRANSLANGATED_LANGUAGE, $TRANSLANGATED_LANGUAGE_COPY;
    $TRANSLANGATED_LANGUAGE = $TRANSLANGATED_LANGUAGE_COPY;
    return $output;
}

/**
 * Return a valid TRP language in which the email will be sent
 *
 * @param $language
 * @return mixed
 */
function translangated_validate_language( $language ){
    $trp = Translangated_Plugin::get_translangated_instance();
    $translangated_settings = $trp->get_component( 'settings' );
    $settings = $translangated_settings->get_settings();
    if( empty( $language ) || !in_array( $language, $settings['translation-languages'] ) ){
        $language = $settings['default-language'];
    }
    return $language;
}

/**
 * Used by third parties to restore original language after using translangated_switch_language
 */
function translangated_restore_language(){
    global $TRANSLANGATED_LANGUAGE, $TRANSLANGATED_LANGUAGE_ORIGINAL;
    remove_filter( 'translangated_before_translate_content', 'translangated_reset_language', 99999999 );

    restore_previous_locale();
    remove_filter( 'plugin_locale', 'translangated_get_locale', 99999999 );
    $TRANSLANGATED_LANGUAGE = $TRANSLANGATED_LANGUAGE_ORIGINAL;
}

/**
 * Determine user language
 *
 * @param $user_id
 * @return mixed
 */
function translangated_get_user_language( $user_id ){
    return translangated_validate_language( get_user_meta( $user_id, 'translangated_language', true ) );
}
/**
 * Wrapper function for WooCommerce HPOS add, delete and update operations
 * Falls back to the traditional post_meta operations
 *
 * @param $order_id         int     Post ID
 * @param $meta_key         string  Metadata key
 * @param $meta_value       mixed   Metadata value
 * @param $operation_type   string  Parameter used to determine the type of operation that needs to be performed.
 *                                  Accepts: add / delete / update
 */
function translangated_woo_hpos_manipulate_post_meta( $order_id, $meta_key, $meta_value, $operation_type ){

    if ( class_exists( 'Automattic\WooCommerce\Utilities\OrderUtil' ) && Automattic\WooCommerce\Utilities\OrderUtil::custom_orders_table_usage_is_enabled() ) {
        $order    = wc_get_order( $order_id );
        $function = $operation_type . '_meta_data';

        $order->$function( $meta_key, $meta_value );
        $order->save();

        return;
    }

    $function = $operation_type . '_post_meta';

    $function( $order_id, $meta_key, $meta_value );
}

/**
 * Wrapper function for WooCommerce HPOS get operation
 * Falls back to the traditional post_meta operation
 *
 * @param  $order_id       int     Post ID
 * @param  $meta_key       string  Metadata key
 * @param  $single         bool    Whether to return a single value or not. Default: false
 * @return                 mixed   An array of values if `$single` is false. The value of the meta field if `$single` is true. False for an invalid `$post_id` (non-numeric, zero, or negative value). An empty string if a valid but non-existing post ID is passed.
 */
function translangated_woo_hpos_get_post_meta( $order_id, $meta_key, $single = false ){
    if ( class_exists( 'Automattic\WooCommerce\Utilities\OrderUtil' ) && Automattic\WooCommerce\Utilities\OrderUtil::custom_orders_table_usage_is_enabled() ) {
        $order = wc_get_order( $order_id );

        if ( !$order ) return false;

        return $order->get_meta( $meta_key, $single );
    }

    return get_post_meta( $order_id, $meta_key, $single );
}

/**
 * Helper function that determines if we should output the dynamic translation script later than usual
 *
 * Some plugins add HTML to the DOM very late in the page load cycle, so the site becomes slow due our mutation observer capturing it
 *
 * @return bool
 */
function translangated_is_late_dom_html_plugin_active(){
    $classes_array = ['QueryMonitor']; // for the moment, only Query Monitor matches the criteria

    foreach ( $classes_array as $class ){
        if ( class_exists( $class ) ) return true;
    }

    return apply_filters( 'translangated_delay_dom_changes_script', false );
}

/**
 * Helper function to remove a prefix from a string.
 * If we do str_replace that will remove it from the entire string, wherever it finds it.
 *
 * @return string
 */
function translangated_remove_prefix($prefix = '', $string = '') {
    // Check if the path starts with the prefix
    if (!empty($prefix)){
        if (strpos($string, $prefix) === 0) {
            // Remove the prefix from the path
            return substr_replace($string, '', 0, strlen($prefix));
        }
    }
    // If the prefix is not at the start, return the path unchanged
    return $string;
}

/**
 * Obfuscate sensitive data in JSON response strings.
 *
 * @param string $string The JSON response string.
 * @return string The modified JSON response string with obfuscated sensitive data.
 */
function translangated_obfuscate_sensitive_data_in_json_response( $string ) {
    $response_data = json_decode( $string, true );
    if ( json_last_error() === JSON_ERROR_NONE ) {
        if ( isset( $response_data['customer_name'] ) ) {
            $response_data['customer_name'] = substr($response_data['customer_name'], 0, 2) . str_repeat('*', strlen($response_data['customer_name']) - 5) . substr($response_data['customer_name'], -3);
        }
        if ( isset( $response_data['customer_email'] ) ) {
            $response_data['customer_email'] = substr($response_data['customer_email'], 0, 2) . str_repeat('*', strlen($response_data['customer_email']) - 5) . substr($response_data['customer_email'], -3);
        }
        $string = wp_json_encode( $response_data );
    }
    return $string;
}

/**
 * Get the original request URI before SEO Pack rewrites translated slugs.
 *
 * @param string|null $fallback Used as the filtered value when we hook this function to redirection_request_url and redirection_url_source
 * @return string
 */
function translangated_get_original_request_uri( $fallback = null ) {
    global $TRANSLANGATED_ORIGINAL_REQUEST_URI;

    if ( empty( $TRANSLANGATED_ORIGINAL_REQUEST_URI ) )
        return $fallback; // Can happen if something goes wrong in translate_request_uri or SEO Pack is not updated

    return $TRANSLANGATED_ORIGINAL_REQUEST_URI;
}

/**
 * URL that dismisses an admin notification for the current user. Nonced: the dismissal also
 * clears stored notices (translangated_dismiss_notification action). Escape it with esc_url() for output.
 */
function translangated_dismiss_notification_url( $notification_id, $url = false ) {
    return add_query_arg( array(
        'translangated_dismiss_admin_notification' => rawurlencode( $notification_id ),
        '_wpnonce'                       => wp_create_nonce( 'translangated_dismiss_admin_notification' ),
    ), $url );
}

/**
 * Attributes shared by the allowlists below. wp_kses() supports a data-* wildcard but not aria-*,
 * so the ARIA attributes the plugin uses are listed.
 */
function translangated_kses_common_attributes() {
    return array(
        'id' => true, 'class' => true, 'style' => true, 'title' => true, 'role' => true, 'tabindex' => true,
        'hidden' => true, 'inert' => true, 'lang' => true, 'dir' => true, 'data-*' => true,
        'aria-label' => true, 'aria-hidden' => true, 'aria-expanded' => true, 'aria-controls' => true,
        'aria-current' => true, 'aria-haspopup' => true, 'aria-live' => true, 'aria-describedby' => true,
        'aria-labelledby' => true, 'aria-selected' => true, 'aria-disabled' => true, 'aria-pressed' => true,
        'aria-required' => true,
    );
}

/**
 * Tags allowed in the language switcher markup (floating, shortcode, block, Elementor), for wp_kses().
 */
function translangated_kses_language_switcher_allowed_html() {
    $common = translangated_kses_common_attributes();
    $svg    = array( 'xmlns' => true, 'width' => true, 'height' => true, 'viewbox' => true, 'fill' => true, 'focusable' => true, 'preserveaspectratio' => true );
    $shape  = array( 'd' => true, 'fill' => true, 'stroke' => true, 'stroke-width' => true, 'stroke-linecap' => true, 'stroke-linejoin' => true, 'fill-rule' => true, 'clip-rule' => true, 'transform' => true, 'x' => true, 'y' => true, 'width' => true, 'height' => true, 'cx' => true, 'cy' => true, 'r' => true, 'points' => true );

    $allowed = array(
        'div'  => $common,
        'span' => $common,
        'nav'  => $common,
        'ul'   => $common,
        'li'   => $common,
        'p'    => $common,
        'a'    => array_merge( $common, array( 'href' => true, 'target' => true, 'rel' => true, 'hreflang' => true ) ),
        'img'  => array_merge( $common, array( 'src' => true, 'srcset' => true, 'sizes' => true, 'alt' => true, 'width' => true, 'height' => true, 'loading' => true, 'decoding' => true ) ),
        'svg'  => array_merge( $common, $svg ),
        'g'    => array_merge( $common, $shape ),
        'path' => array_merge( $common, $shape ),
        'rect' => array_merge( $common, $shape ),
        'circle' => array_merge( $common, $shape ),
        'polygon' => array_merge( $common, $shape ),
    );
    return apply_filters( 'translangated_kses_language_switcher_allowed_html', $allowed );
}

/**
 * Tags allowed in markup the plugin builds for its own admin screens (settings fields, notices,
 * error log), for wp_kses(): post content plus form controls and inline SVG.
 */
function translangated_kses_admin_allowed_html() {
    $common  = translangated_kses_common_attributes();
    $field   = array( 'name' => true, 'value' => true, 'disabled' => true, 'readonly' => true, 'required' => true, 'autocomplete' => true, 'form' => true );
    $allowed = wp_kses_allowed_html( 'post' );
    foreach ( $allowed as $tag => $attributes ) {
        $allowed[ $tag ] = array_merge( is_array( $attributes ) ? $attributes : array(), $common );
    }

    return apply_filters( 'translangated_kses_admin_allowed_html', array_merge( $allowed, array(
        'form'     => array_merge( $common, array( 'action' => true, 'method' => true, 'name' => true, 'enctype' => true, 'novalidate' => true, 'target' => true ) ),
        'input'    => array_merge( $common, $field, array( 'type' => true, 'checked' => true, 'placeholder' => true, 'min' => true, 'max' => true, 'step' => true, 'size' => true, 'maxlength' => true, 'pattern' => true, 'list' => true ) ),
        'select'   => array_merge( $common, $field, array( 'multiple' => true, 'size' => true ) ),
        'option'   => array_merge( $common, array( 'value' => true, 'selected' => true, 'disabled' => true, 'label' => true ) ),
        'optgroup' => array_merge( $common, array( 'label' => true, 'disabled' => true ) ),
        'textarea' => array_merge( $common, $field, array( 'rows' => true, 'cols' => true, 'placeholder' => true, 'wrap' => true ) ),
        'label'    => array_merge( $common, array( 'for' => true ) ),
        'button'   => array_merge( $common, $field, array( 'type' => true ) ),
        'fieldset' => $common,
        'legend'   => $common,
        'datalist' => $common,
        'template' => $common,
        'svg'      => array_merge( $common, array( 'xmlns' => true, 'width' => true, 'height' => true, 'viewbox' => true, 'fill' => true, 'focusable' => true ) ),
        'path'     => array_merge( $common, array( 'd' => true, 'fill' => true, 'stroke' => true, 'stroke-width' => true, 'stroke-linecap' => true, 'stroke-linejoin' => true, 'fill-rule' => true, 'clip-rule' => true ) ),
    ) ) );
}