<?php

/*
*  acf_is_array
*
*  This function will return true for a non empty array
*
*  @type    function
*  @date    6/07/2016
*  @since   5.4.0
*
*  @param   $array (array)
*  @return  (boolean)
*/

function acf_is_array( $array ) {

	return ( is_array( $array ) && ! empty( $array ) );

}

/**
 *  acf_has_setting
 *
 *  alias of acf()->has_setting()
 *
 *  @date    2/2/18
 *  @since   5.6.5
 *
 *  @param   n/a
 *  @return  n/a
 */

function acf_has_setting( $name = '' ) {
	return acf()->has_setting( $name );
}


/**
 *  acf_raw_setting
 *
 *  alias of acf()->get_setting()
 *
 *  @date    2/2/18
 *  @since   5.6.5
 *
 *  @param   n/a
 *  @return  n/a
 */

function acf_raw_setting( $name = '' ) {
	return acf()->get_setting( $name );
}


/*
*  acf_update_setting
*
*  alias of acf()->update_setting()
*
*  @type    function
*  @date    28/09/13
*  @since   5.0.0
*
*  @param   $name (string)
*  @param   $value (mixed)
*  @return  n/a
*/

function acf_update_setting( $name, $value ) {

	// validate name
	$name = acf_validate_setting( $name );

	// update
	return acf()->update_setting( $name, $value );
}


/**
 *  acf_validate_setting
 *
 *  Returns the changed setting name if available.
 *
 *  @date    2/2/18
 *  @since   5.6.5
 *
 *  @param   n/a
 *  @return  n/a
 */

function acf_validate_setting( $name = '' ) {
	return apply_filters( 'acf/validate_setting', $name );
}


/*
*  acf_get_setting
*
*  alias of acf()->get_setting()
*
*  @type    function
*  @date    28/09/13
*  @since   5.0.0
*
*  @param   n/a
*  @return  n/a
*/

function acf_get_setting( $name, $value = null ) {

	// validate name
	$name = acf_validate_setting( $name );

	// check settings
	if ( acf_has_setting( $name ) ) {
		$value = acf_raw_setting( $name );
	}

	// filter
	$value = apply_filters( "acf/settings/{$name}", $value );

	// return
	return $value;
}


/*
*  acf_append_setting
*
*  This function will add a value into the settings array found in the acf object
*
*  @type    function
*  @date    28/09/13
*  @since   5.0.0
*
*  @param   $name (string)
*  @param   $value (mixed)
*  @return  n/a
*/

function acf_append_setting( $name, $value ) {

	// vars
	$setting = acf_raw_setting( $name );

	// bail ealry if not array
	if ( ! is_array( $setting ) ) {
		$setting = array();
	}

	// append
	$setting[] = $value;

	// update
	return acf_update_setting( $name, $setting );
}


/**
 *  acf_get_data
 *
 *  Returns data.
 *
 *  @date    28/09/13
 *  @since   5.0.0
 *
 *  @param   string $name
 *  @return  mixed
 */

function acf_get_data( $name ) {
	return acf()->get_data( $name );
}


/**
 *  acf_set_data
 *
 *  Sets data.
 *
 *  @date    28/09/13
 *  @since   5.0.0
 *
 *  @param   string $name
 *  @param   mixed  $value
 *  @return  n/a
 */

function acf_set_data( $name, $value ) {
	return acf()->set_data( $name, $value );
}

/**
 * Appends data to an existing key.
 *
 * @date    11/06/2020
 * @since   5.9.0
 *
 * @param   string $name The data name.
 * @return  array $data The data array.
 */
function acf_append_data( $name, $data ) {
	$prev_data = acf()->get_data( $name );
	if ( is_array( $prev_data ) ) {
		$data = array_merge( $prev_data, $data );
	}
	acf()->set_data( $name, $data );
}

/*
*  acf_init
*
*  alias of acf()->init()
*
*  @type    function
*  @date    28/09/13
*  @since   5.0.0
*
*  @param   n/a
*  @return  n/a
*/

function acf_init() {

	acf()->init();

}


/*
*  acf_has_done
*
*  This function will return true if this action has already been done
*
*  @type    function
*  @date    16/12/2015
*  @since   5.3.2
*
*  @param   $name (string)
*  @return  (boolean)
*/

function acf_has_done( $name ) {

	// return true if already done
	if ( acf_raw_setting( "has_done_{$name}" ) ) {
		return true;
	}

	// update setting and return
	acf_update_setting( "has_done_{$name}", true );
	return false;
}




/*
*  acf_get_external_path
*
*  This function will return the path to a file within an external folder
*
*  @type    function
*  @date    22/2/17
*  @since   5.5.8
*
*  @param   $file (string)
*  @param   $path (string)
*  @return  (string)
*/

function acf_get_external_path( $file, $path = '' ) {

	return plugin_dir_path( $file ) . $path;

}


/*
*  acf_get_external_dir
*
*  This function will return the url to a file within an external folder
*
*  @type    function
*  @date    22/2/17
*  @since   5.5.8
*
*  @param   $file (string)
*  @param   $path (string)
*  @return  (string)
*/

function acf_get_external_dir( $file, $path = '' ) {

	return acf_plugin_dir_url( $file ) . $path;

}


/**
 *  acf_plugin_dir_url
 *
 *  This function will calculate the url to a plugin folder.
 *  Different to the WP plugin_dir_url(), this function can calculate for urls outside of the plugins folder (theme include).
 *
 *  @date    13/12/17
 *  @since   5.6.8
 *
 *  @param   type $var Description. Default.
 *  @return  type Description.
 */

function acf_plugin_dir_url( $file ) {

	// vars
	$path = plugin_dir_path( $file );
	$path = wp_normalize_path( $path );

	// check plugins
	$check_path = wp_normalize_path( realpath( WP_PLUGIN_DIR ) );
	if ( strpos( $path, $check_path ) === 0 ) {
		return str_replace( $check_path, plugins_url(), $path );
	}

	// check wp-content
	$check_path = wp_normalize_path( realpath( WP_CONTENT_DIR ) );
	if ( strpos( $path, $check_path ) === 0 ) {
		return str_replace( $check_path, content_url(), $path );
	}

	// check root
	$check_path = wp_normalize_path( realpath( ABSPATH ) );
	if ( strpos( $path, $check_path ) === 0 ) {
		return str_replace( $check_path, site_url( '/' ), $path );
	}

	// return
	return plugin_dir_url( $file );

}


/*
*  acf_parse_args
*
*  This function will merge together 2 arrays and also convert any numeric values to ints
*
*  @type    function
*  @date    18/10/13
*  @since   5.0.0
*
*  @param   $args (array)
*  @param   $defaults (array)
*  @return  $args (array)
*/

function acf_parse_args( $args, $defaults = array() ) {

	// parse args
	$args = wp_parse_args( $args, $defaults );

	// parse types
	$args = acf_parse_types( $args );

	// return
	return $args;

}


/*
*  acf_parse_types
*
*  This function will convert any numeric values to int and trim strings
*
*  @type    function
*  @date    18/10/13
*  @since   5.0.0
*
*  @param   $var (mixed)
*  @return  $var (mixed)
*/

function acf_parse_types( $array ) {
	return array_map( 'acf_parse_type', $array );
}


/*
*  acf_parse_type
*
*  description
*
*  @type    function
*  @date    11/11/2014
*  @since   5.0.9
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_parse_type( $v ) {

	// Check if is string.
	if ( is_string( $v ) ) {

		// Trim ("Word " = "Word").
		$v = trim( $v );

		// Convert int strings to int ("123" = 123).
		if ( is_numeric( $v ) && strval( intval( $v ) ) === $v ) {
			$v = intval( $v );
		}
	}

	// return.
	return $v;
}


/*
*  acf_get_view
*
*  This function will load in a file from the 'admin/views' folder and allow variables to be passed through
*
*  @type    function
*  @date    28/09/13
*  @since   5.0.0
*
*  @param   $view_name (string)
*  @param   $args (array)
*  @return  n/a
*/

function acf_get_view( $path = '', $args = array() ) {

	// allow view file name shortcut
	if ( substr( $path, -4 ) !== '.php' ) {

		$path = acf_get_path( "includes/admin/views/{$path}.php" );

	}

	// include
	if ( file_exists( $path ) ) {

		extract( $args );
		include $path;

	}

}


/*
*  acf_merge_atts
*
*  description
*
*  @type    function
*  @date    2/11/2014
*  @since   5.0.9
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_merge_atts( $atts, $extra = array() ) {

	// bail ealry if no $extra
	if ( empty( $extra ) ) {
		return $atts;
	}

	// trim
	$extra = array_map( 'trim', $extra );
	$extra = array_filter( $extra );

	// merge in new atts
	foreach ( $extra as $k => $v ) {

		// append
		if ( $k == 'class' || $k == 'style' ) {

			$atts[ $k ] .= ' ' . $v;

			// merge
		} else {

			$atts[ $k ] = $v;

		}
	}

	// return
	return $atts;

}


/*
*  acf_nonce_input
*
*  This function will create a basic nonce input
*
*  @type    function
*  @date    24/5/17
*  @since   5.6.0
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_nonce_input( $nonce = '' ) {

	echo '<input type="hidden" name="_acf_nonce" value="' . wp_create_nonce( $nonce ) . '" />';

}


/*
*  acf_extract_var
*
*  This function will remove the var from the array, and return the var
*
*  @type    function
*  @date    2/10/13
*  @since   5.0.0
*
*  @param   $array (array)
*  @param   $key (string)
*  @return  (mixed)
*/

function acf_extract_var( &$array, $key, $default = null ) {

	// check if exists
	// - uses array_key_exists to extract NULL values (isset will fail)
	if ( is_array( $array ) && array_key_exists( $key, $array ) ) {

		// store value
		$v = $array[ $key ];

		// unset
		unset( $array[ $key ] );

		// return
		return $v;

	}

	// return
	return $default;
}


/*
*  acf_extract_vars
*
*  This function will remove the vars from the array, and return the vars
*
*  @type    function
*  @date    8/10/13
*  @since   5.0.0
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_extract_vars( &$array, $keys ) {

	$r = array();

	foreach ( $keys as $key ) {

		$r[ $key ] = acf_extract_var( $array, $key );

	}

	return $r;
}


/*
*  acf_get_sub_array
*
*  This function will return a sub array of data
*
*  @type    function
*  @date    15/03/2016
*  @since   5.3.2
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_get_sub_array( $array, $keys ) {

	$r = array();

	foreach ( $keys as $key ) {

		$r[ $key ] = $array[ $key ];

	}

	return $r;

}


/**
 *  acf_get_post_types
 *
 *  Returns an array of post type names.
 *
 *  @date    7/10/13
 *  @since   5.0.0
 *
 *  @param   array $args Optional. An array of key => value arguments to match against the post type objects. Default empty array.
 *  @return  array A list of post type names.
 */

function acf_get_post_types( $args = array() ) {

	// vars
	$post_types = array();

	// extract special arg
	$exclude   = acf_extract_var( $args, 'exclude', array() );
	$exclude[] = 'acf-field';
	$exclude[] = 'acf-field-group';

	// get post type objects
	$objects = get_post_types( $args, 'objects' );

	// loop
	foreach ( $objects as $i => $object ) {

		// bail early if is exclude
		if ( in_array( $i, $exclude ) ) {
			continue;
		}

		// bail early if is builtin (WP) private post type
		// - nav_menu_item, revision, customize_changeset, etc
		if ( $object->_builtin && ! $object->public ) {
			continue;
		}

		// append
		$post_types[] = $i;
	}

	// filter
	$post_types = apply_filters( 'acf/get_post_types', $post_types, $args );

	// return
	return $post_types;
}

function acf_get_pretty_post_types( $post_types = array() ) {

	// get post types
	if ( empty( $post_types ) ) {

		// get all custom post types
		$post_types = acf_get_post_types();

	}

	// get labels
	$ref = array();
	$r   = array();

	foreach ( $post_types as $post_type ) {

		// vars
		$label = acf_get_post_type_label( $post_type );

		// append to r
		$r[ $post_type ] = $label;

		// increase counter
		if ( ! isset( $ref[ $label ] ) ) {

			$ref[ $label ] = 0;

		}

		$ref[ $label ]++;
	}

	// get slugs
	foreach ( array_keys( $r ) as $i ) {

		// vars
		$post_type = $r[ $i ];

		if ( $ref[ $post_type ] > 1 ) {

			$r[ $i ] .= ' (' . $i . ')';

		}
	}

	// return
	return $r;

}



/*
*  acf_get_post_type_label
*
*  This function will return a pretty label for a specific post_type
*
*  @type    function
*  @date    5/07/2016
*  @since   5.4.0
*
*  @param   $post_type (string)
*  @return  (string)
*/

function acf_get_post_type_label( $post_type ) {

	// vars
	$label = $post_type;

	// check that object exists
	// - case exists when importing field group from another install and post type does not exist
	if ( post_type_exists( $post_type ) ) {

		$obj   = get_post_type_object( $post_type );
		$label = $obj->labels->singular_name;

	}

	// return
	return $label;

}


/*
*  acf_verify_nonce
*
*  This function will look at the $_POST['_acf_nonce'] value and return true or false
*
*  @type    function
*  @date    15/10/13
*  @since   5.0.0
*
*  @param   $nonce (string)
*  @return  (boolean)
*/

function acf_verify_nonce( $value ) {

	// vars
	$nonce = acf_maybe_get_POST( '_acf_nonce' );

	// bail early nonce does not match (post|user|comment|term)
	if ( ! $nonce || ! wp_verify_nonce( $nonce, $value ) ) {
		return false;
	}

	// reset nonce (only allow 1 save)
	$_POST['_acf_nonce'] = false;

	// return
	return true;

}


/*
*  acf_verify_ajax
*
*  This function will return true if the current AJAX request is valid
*  It's action will also allow WPML to set the lang and avoid AJAX get_posts issues
*
*  @type    function
*  @date    7/08/2015
*  @since   5.2.3
*
*  @param   n/a
*  @return  (boolean)
*/

function acf_verify_ajax() {

	// vars
	$nonce = isset( $_REQUEST['nonce'] ) ? $_REQUEST['nonce'] : '';

	// bail early if not acf nonce
	if ( ! $nonce || ! wp_verify_nonce( $nonce, 'acf_nonce' ) ) {
		return false;
	}

	// action for 3rd party customization
	do_action( 'acf/verify_ajax' );

	// return
	return true;
}


/*
*  acf_get_image_sizes
*
*  This function will return an array of available image sizes
*
*  @type    function
*  @date    23/10/13
*  @since   5.0.0
*
*  @param   n/a
*  @return  (array)
*/

function acf_get_image_sizes() {

	// vars
	$sizes = array(
		'thumbnail' => __( 'Thumbnail', 'acf' ),
		'medium'    => __( 'Medium', 'acf' ),
		'large'     => __( 'Large', 'acf' ),
	);

	// find all sizes
	$all_sizes = get_intermediate_image_sizes();

	// add extra registered sizes
	if ( ! empty( $all_sizes ) ) {

		foreach ( $all_sizes as $size ) {

			// bail early if already in array
			if ( isset( $sizes[ $size ] ) ) {

				continue;

			}

			// append to array
			$label          = str_replace( '-', ' ', $size );
			$label          = ucwords( $label );
			$sizes[ $size ] = $label;

		}
	}

	// add sizes
	foreach ( array_keys( $sizes ) as $s ) {

		// vars
		$data = acf_get_image_size( $s );

		// append
		if ( $data['width'] && $data['height'] ) {

			$sizes[ $s ] .= ' (' . $data['width'] . ' x ' . $data['height'] . ')';

		}
	}

	// add full end
	$sizes['full'] = __( 'Full Size', 'acf' );

	// filter for 3rd party customization
	$sizes = apply_filters( 'acf/get_image_sizes', $sizes );

	// return
	return $sizes;

}

function acf_get_image_size( $s = '' ) {

	// global
	global $_wp_additional_image_sizes;

	// rename for nicer code
	$_sizes = $_wp_additional_image_sizes;

	// vars
	$data = array(
		'width'  => isset( $_sizes[ $s ]['width'] ) ? $_sizes[ $s ]['width'] : get_option( "{$s}_size_w" ),
		'height' => isset( $_sizes[ $s ]['height'] ) ? $_sizes[ $s ]['height'] : get_option( "{$s}_size_h" ),
	);

	// return
	return $data;

}

/**
 * acf_version_compare
 *
 * Similar to the version_compare() function but with extra functionality.
 *
 * @date    21/11/16
 * @since   5.5.0
 *
 * @param   string $left The left version number.
 * @param   string $compare The compare operator.
 * @param   string $right The right version number.
 * @return  bool
 */
function acf_version_compare( $left = '', $compare = '>', $right = '' ) {

	// Detect 'wp' placeholder.
	if ( $left === 'wp' ) {
		global $wp_version;
		$left = $wp_version;
	}

	// Return result.
	return version_compare( $left, $right, $compare );
}


/*
*  acf_get_full_version
*
*  This function will remove any '-beta1' or '-RC1' strings from a version
*
*  @type    function
*  @date    24/11/16
*  @since   5.5.0
*
*  @param   $version (string)
*  @return  (string)
*/

function acf_get_full_version( $version = '1' ) {

	// remove '-beta1' or '-RC1'
	if ( $pos = strpos( $version, '-' ) ) {

		$version = substr( $version, 0, $pos );

	}

	// return
	return $version;

}


/*
*  acf_get_terms
*
*  This function is a wrapper for the get_terms() function
*
*  @type    function
*  @date    28/09/2016
*  @since   5.4.0
*
*  @param   $args (array)
*  @return  (array)
*/

function acf_get_terms( $args ) {

	// defaults
	$args = wp_parse_args(
		$args,
		array(
			'taxonomy'               => null,
			'hide_empty'             => false,
			'update_term_meta_cache' => false,
		)
	);

	// parameters changed in version 4.5
	if ( acf_version_compare( 'wp', '<', '4.5' ) ) {
		return get_terms( $args['taxonomy'], $args );
	}

	// return
	return get_terms( $args );
}


/*
*  acf_get_taxonomy_terms
*
*  This function will return an array of available taxonomy terms
*
*  @type    function
*  @date    7/10/13
*  @since   5.0.0
*
*  @param   $taxonomies (array)
*  @return  (array)
*/

function acf_get_taxonomy_terms( $taxonomies = array() ) {

	// force array
	$taxonomies = acf_get_array( $taxonomies );

	// get pretty taxonomy names
	$taxonomies = acf_get_pretty_taxonomies( $taxonomies );

	// vars
	$r = array();

	// populate $r
	foreach ( array_keys( $taxonomies ) as $taxonomy ) {

		// vars
		$label           = $taxonomies[ $taxonomy ];
		$is_hierarchical = is_taxonomy_hierarchical( $taxonomy );
		$terms           = acf_get_terms(
			array(
				'taxonomy'   => $taxonomy,
				'hide_empty' => false,
			)
		);

		// bail early i no terms
		if ( empty( $terms ) ) {
			continue;
		}

		// sort into hierachial order!
		if ( $is_hierarchical ) {

			$terms = _get_term_children( 0, $terms, $taxonomy );

		}

		// add placeholder
		$r[ $label ] = array();

		// add choices
		foreach ( $terms as $term ) {

			$k                 = "{$taxonomy}:{$term->slug}";
			$r[ $label ][ $k ] = acf_get_term_title( $term );

		}
	}

	// return
	return $r;

}


/*
*  acf_decode_taxonomy_terms
*
*  This function decodes the $taxonomy:$term strings into a nested array
*
*  @type    function
*  @date    27/02/2014
*  @since   5.0.0
*
*  @param   $terms (array)
*  @return  (array)
*/

function acf_decode_taxonomy_terms( $strings = false ) {

	// bail early if no terms
	if ( empty( $strings ) ) {
		return false;
	}

	// vars
	$terms = array();

	// loop
	foreach ( $strings as $string ) {

		// vars
		$data     = acf_decode_taxonomy_term( $string );
		$taxonomy = $data['taxonomy'];
		$term     = $data['term'];

		// create empty array
		if ( ! isset( $terms[ $taxonomy ] ) ) {

			$terms[ $taxonomy ] = array();

		}

		// append
		$terms[ $taxonomy ][] = $term;

	}

	// return
	return $terms;

}


/*
*  acf_decode_taxonomy_term
*
*  This function will return the taxonomy and term slug for a given value
*
*  @type    function
*  @date    31/03/2014
*  @since   5.0.0
*
*  @param   $string (string)
*  @return  (array)
*/

function acf_decode_taxonomy_term( $value ) {

	// vars
	$data = array(
		'taxonomy' => '',
		'term'     => '',
	);

	// int
	if ( is_numeric( $value ) ) {

		$data['term'] = $value;

		// string
	} elseif ( is_string( $value ) ) {

		$value            = explode( ':', $value );
		$data['taxonomy'] = isset( $value[0] ) ? $value[0] : '';
		$data['term']     = isset( $value[1] ) ? $value[1] : '';

		// error
	} else {

		return false;

	}

	// allow for term_id (Used by ACF v4)
	if ( is_numeric( $data['term'] ) ) {

		// global
		global $wpdb;

		// find taxonomy
		if ( ! $data['taxonomy'] ) {

			$data['taxonomy'] = $wpdb->get_var( $wpdb->prepare( "SELECT taxonomy FROM $wpdb->term_taxonomy WHERE term_id = %d LIMIT 1", $data['term'] ) );

		}

		// find term (may have numeric slug '123')
		$term = get_term_by( 'slug', $data['term'], $data['taxonomy'] );

		// attempt get term via ID (ACF4 uses ID)
		if ( ! $term ) {
			$term = get_term( $data['term'], $data['taxonomy'] );
		}

		// bail early if no term
		if ( ! $term ) {
			return false;
		}

		// update
		$data['taxonomy'] = $term->taxonomy;
		$data['term']     = $term->slug;

	}

	// return
	return $data;

}

/**
 * acf_array
 *
 * Casts the value into an array.
 *
 * @date    9/1/19
 * @since   5.7.10
 *
 * @param   mixed $val The value to cast.
 * @return  array
 */
function acf_array( $val = array() ) {
	return (array) $val;
}

/**
 * Returns a non-array value.
 *
 * @date    11/05/2020
 * @since   5.8.10
 *
 * @param   mixed $val The value to review.
 * @return  mixed
 */
function acf_unarray( $val ) {
	if ( is_array( $val ) ) {
		return reset( $val );
	}
	return $val;
}

/*
*  acf_get_array
*
*  This function will force a variable to become an array
*
*  @type    function
*  @date    4/02/2014
*  @since   5.0.0
*
*  @param   $var (mixed)
*  @return  (array)
*/

function acf_get_array( $var = false, $delimiter = '' ) {

	// array
	if ( is_array( $var ) ) {
		return $var;
	}

	// bail early if empty
	if ( acf_is_empty( $var ) ) {
		return array();
	}

	// string
	if ( is_string( $var ) && $delimiter ) {
		return explode( $delimiter, $var );
	}

	// place in array
	return (array) $var;

}


/*
*  acf_get_numeric
*
*  This function will return numeric values
*
*  @type    function
*  @date    15/07/2016
*  @since   5.4.0
*
*  @param   $value (mixed)
*  @return  (mixed)
*/

function acf_get_numeric( $value = '' ) {

	// vars
	$numbers  = array();
	$is_array = is_array( $value );

	// loop
	foreach ( (array) $value as $v ) {

		if ( is_numeric( $v ) ) {
			$numbers[] = (int) $v;
		}
	}

	// bail early if is empty
	if ( empty( $numbers ) ) {
		return false;
	}

	// convert array
	if ( ! $is_array ) {
		$numbers = $numbers[0];
	}

	// return
	return $numbers;

}


/**
 * acf_get_posts
 *
 * Similar to the get_posts() function but with extra functionality.
 *
 * @date    3/03/15
 * @since   5.1.5
 *
 * @param   array $args The query args.
 * @return  array
 */
function acf_get_posts( $args = array() ) {

	// Vars.
	$posts = array();

	// Apply default args.
	$args = wp_parse_args(
		$args,
		array(
			'posts_per_page'         => -1,
			'post_type'              => '',
			'post_status'            => 'any',
			'update_post_meta_cache' => false,
			'update_post_term_cache' => false,
		)
	);

	// Avoid default 'post' post_type by providing all public types.
	if ( ! $args['post_type'] ) {
		$args['post_type'] = acf_get_post_types();
	}

	// Check if specifc post ID's have been provided.
	if ( $args['post__in'] ) {

		// Clean value into an array of IDs.
		$args['post__in'] = array_map( 'intval', acf_array( $args['post__in'] ) );
	}

	// Query posts.
	$posts = get_posts( $args );

	// Remove any potential empty results.
	$posts = array_filter( $posts );

	// Manually order results.
	if ( $posts && $args['post__in'] ) {
		$order = array();
		foreach ( $posts as $i => $post ) {
			$order[ $i ] = array_search( $post->ID, $args['post__in'] );
		}
		array_multisort( $order, $posts );
	}

	// Return posts.
	return $posts;
}


/*
*  _acf_query_remove_post_type
*
*  This function will remove the 'wp_posts.post_type' WHERE clause completely
*  When using 'post__in', this clause is unneccessary and slow.
*
*  @type    function
*  @date    4/03/2015
*  @since   5.1.5
*
*  @param   $sql (string)
*  @return  $sql
*/

function _acf_query_remove_post_type( $sql ) {

	// global
	global $wpdb;

	// bail ealry if no 'wp_posts.ID IN'
	if ( strpos( $sql, "$wpdb->posts.ID IN" ) === false ) {

		return $sql;

	}

	// get bits
	$glue = 'AND';
	$bits = explode( $glue, $sql );

	// loop through $where and remove any post_type queries
	foreach ( $bits as $i => $bit ) {

		if ( strpos( $bit, "$wpdb->posts.post_type" ) !== false ) {

			unset( $bits[ $i ] );

		}
	}

	// join $where back together
	$sql = implode( $glue, $bits );

	// return
	return $sql;

}


/*
*  acf_get_grouped_posts
*
*  This function will return all posts grouped by post_type
*  This is handy for select settings
*
*  @type    function
*  @date    27/02/2014
*  @since   5.0.0
*
*  @param   $args (array)
*  @return  (array)
*/

function acf_get_grouped_posts( $args ) {

	// vars
	$data = array();

	// defaults
	$args = wp_parse_args(
		$args,
		array(
			'posts_per_page'         => -1,
			'paged'                  => 0,
			'post_type'              => 'post',
			'orderby'                => 'menu_order title',
			'order'                  => 'ASC',
			'post_status'            => 'any',
			'suppress_filters'       => false,
			'update_post_meta_cache' => false,
		)
	);

	// find array of post_type
	$post_types          = acf_get_array( $args['post_type'] );
	$post_types_labels   = acf_get_pretty_post_types( $post_types );
	$is_single_post_type = ( count( $post_types ) == 1 );

	// attachment doesn't work if it is the only item in an array
	if ( $is_single_post_type ) {
		$args['post_type'] = reset( $post_types );
	}

	// add filter to orderby post type
	if ( ! $is_single_post_type ) {
		add_filter( 'posts_orderby', '_acf_orderby_post_type', 10, 2 );
	}

	// get posts
	$posts = get_posts( $args );

	// remove this filter (only once)
	if ( ! $is_single_post_type ) {
		remove_filter( 'posts_orderby', '_acf_orderby_post_type', 10, 2 );
	}

	// loop
	foreach ( $post_types as $post_type ) {

		// vars
		$this_posts = array();
		$this_group = array();

		// populate $this_posts
		foreach ( $posts as $post ) {
			if ( $post->post_type == $post_type ) {
				$this_posts[] = $post;
			}
		}

		// bail early if no posts for this post type
		if ( empty( $this_posts ) ) {
			continue;
		}

		// sort into hierachial order!
		// this will fail if a search has taken place because parents wont exist
		if ( is_post_type_hierarchical( $post_type ) && empty( $args['s'] ) ) {

			// vars
			$post_id   = $this_posts[0]->ID;
			$parent_id = acf_maybe_get( $args, 'post_parent', 0 );
			$offset    = 0;
			$length    = count( $this_posts );

			// get all posts from this post type
			$all_posts = get_posts(
				array_merge(
					$args,
					array(
						'posts_per_page' => -1,
						'paged'          => 0,
						'post_type'      => $post_type,
					)
				)
			);

			// find starting point (offset)
			foreach ( $all_posts as $i => $post ) {
				if ( $post->ID == $post_id ) {
					$offset = $i;
					break;
				}
			}

			// order posts
			$ordered_posts = get_page_children( $parent_id, $all_posts );

			// compare aray lengths
			// if $ordered_posts is smaller than $all_posts, WP has lost posts during the get_page_children() function
			// this is possible when get_post( $args ) filter out parents (via taxonomy, meta and other search parameters)
			if ( count( $ordered_posts ) == count( $all_posts ) ) {
				$this_posts = array_slice( $ordered_posts, $offset, $length );
			}
		}

		// populate $this_posts
		foreach ( $this_posts as $post ) {
			$this_group[ $post->ID ] = $post;
		}

		// group by post type
		$label          = $post_types_labels[ $post_type ];
		$data[ $label ] = $this_group;

	}

	// return
	return $data;

}


function _acf_orderby_post_type( $ordeby, $wp_query ) {

	// global
	global $wpdb;

	// get post types
	$post_types = $wp_query->get( 'post_type' );

	// prepend SQL
	if ( is_array( $post_types ) ) {

		$post_types = implode( "','", $post_types );
		$ordeby     = "FIELD({$wpdb->posts}.post_type,'$post_types')," . $ordeby;

	}

	// return
	return $ordeby;

}


function acf_get_post_title( $post = 0, $is_search = false ) {

	// vars
	$post    = get_post( $post );
	$title   = '';
	$prepend = '';
	$append  = '';

	// bail early if no post
	if ( ! $post ) {
		return '';
	}

	// title
	$title = get_the_title( $post->ID );

	// empty
	if ( $title === '' ) {

		$title = __( '(no title)', 'acf' );

	}

	// status
	if ( get_post_status( $post->ID ) != 'publish' ) {

		$append .= ' (' . get_post_status( $post->ID ) . ')';

	}

	// ancestors
	if ( $post->post_type !== 'attachment' ) {

		// get ancestors
		$ancestors = get_ancestors( $post->ID, $post->post_type );
		$prepend  .= str_repeat( '- ', count( $ancestors ) );

		// add parent
		/*
		removed in 5.6.5 as not used by the UI
		if( $is_search && !empty($ancestors) ) {

			// reverse
			$ancestors = array_reverse($ancestors);


			// convert id's into titles
			foreach( $ancestors as $i => $id ) {

				$ancestors[ $i ] = get_the_title( $id );

			}


			// append
			$append .= ' | ' . __('Parent', 'acf') . ': ' . implode(' / ', $ancestors);

		}
		*/

	}

	// merge
	$title = $prepend . $title . $append;

	// return
	return $title;

}


function acf_order_by_search( $array, $search ) {

	// vars
	$weights = array();
	$needle  = strtolower( $search );

	// add key prefix
	foreach ( array_keys( $array ) as $k ) {

		$array[ '_' . $k ] = acf_extract_var( $array, $k );

	}

	// add search weight
	foreach ( $array as $k => $v ) {

		// vars
		$weight   = 0;
		$haystack = strtolower( $v );
		$strpos   = strpos( $haystack, $needle );

		// detect search match
		if ( $strpos !== false ) {

			// set eright to length of match
			$weight = strlen( $search );

			// increase weight if match starts at begining of string
			if ( $strpos == 0 ) {

				$weight++;

			}
		}

		// append to wights
		$weights[ $k ] = $weight;

	}

	// sort the array with menu_order ascending
	array_multisort( $weights, SORT_DESC, $array );

	// remove key prefix
	foreach ( array_keys( $array ) as $k ) {

		$array[ substr( $k, 1 ) ] = acf_extract_var( $array, $k );

	}

	// return
	return $array;
}


/*
*  acf_get_pretty_user_roles
*
*  description
*
*  @type    function
*  @date    23/02/2016
*  @since   5.3.2
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_get_pretty_user_roles( $allowed = false ) {

	// vars
	$editable_roles = get_editable_roles();
	$allowed        = acf_get_array( $allowed );
	$roles          = array();

	// loop
	foreach ( $editable_roles as $role_name => $role_details ) {

		// bail early if not allowed
		if ( ! empty( $allowed ) && ! in_array( $role_name, $allowed ) ) {
			continue;
		}

		// append
		$roles[ $role_name ] = translate_user_role( $role_details['name'] );

	}

	// return
	return $roles;

}


/*
*  acf_get_grouped_users
*
*  This function will return all users grouped by role
*  This is handy for select settings
*
*  @type    function
*  @date    27/02/2014
*  @since   5.0.0
*
*  @param   $args (array)
*  @return  (array)
*/

function acf_get_grouped_users( $args = array() ) {

	// vars
	$r = array();

	// defaults
	$args = wp_parse_args(
		$args,
		array(
			'users_per_page' => -1,
			'paged'          => 0,
			'role'           => '',
			'orderby'        => 'login',
			'order'          => 'ASC',
		)
	);

	// offset
	$i              = 0;
	$min            = 0;
	$max            = 0;
	$users_per_page = acf_extract_var( $args, 'users_per_page' );
	$paged          = acf_extract_var( $args, 'paged' );

	if ( $users_per_page > 0 ) {

		// prevent paged from being -1
		$paged = max( 0, $paged );

		// set min / max
		$min = ( ( $paged - 1 ) * $users_per_page ) + 1; // 1,  11
		$max = ( $paged * $users_per_page ); // 10, 20

	}

	// find array of post_type
	$user_roles = acf_get_pretty_user_roles( $args['role'] );

	// fix role
	if ( is_array( $args['role'] ) ) {

		// global
		global $wp_version, $wpdb;

		// vars
		$roles = acf_extract_var( $args, 'role' );

		// new WP has role__in
		if ( version_compare( $wp_version, '4.4', '>=' ) ) {

			$args['role__in'] = $roles;

			// old WP doesn't have role__in
		} else {

			// vars
			$blog_id    = get_current_blog_id();
			$meta_query = array( 'relation' => 'OR' );

			// loop
			foreach ( $roles as $role ) {

				$meta_query[] = array(
					'key'     => $wpdb->get_blog_prefix( $blog_id ) . 'capabilities',
					'value'   => '"' . $role . '"',
					'compare' => 'LIKE',
				);

			}

			// append
			$args['meta_query'] = $meta_query;

		}
	}

	// get posts
	$users = get_users( $args );

	// loop
	foreach ( $user_roles as $user_role_name => $user_role_label ) {

		// vars
		$this_users = array();
		$this_group = array();

		// populate $this_posts
		foreach ( array_keys( $users ) as $key ) {

			// bail ealry if not correct role
			if ( ! in_array( $user_role_name, $users[ $key ]->roles ) ) {
				continue;
			}

			// extract user
			$user = acf_extract_var( $users, $key );

			// increase
			$i++;

			// bail ealry if too low
			if ( $min && $i < $min ) {
				continue;
			}

			// bail early if too high (don't bother looking at any more users)
			if ( $max && $i > $max ) {
				break;
			}

			// group by post type
			$this_users[ $user->ID ] = $user;

		}

		// bail early if no posts for this post type
		if ( empty( $this_users ) ) {
			continue;
		}

		// append
		$r[ $user_role_label ] = $this_users;

	}

	// return
	return $r;

}

/**
 * acf_json_encode
 *
 * Returns json_encode() ready for file / database use.
 *
 * @date    29/4/19
 * @since   5.0.0
 *
 * @param   array $json The array of data to encode.
 * @return  string
 */
function acf_json_encode( $json ) {
	return json_encode( $json, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE );
}


/*
*  acf_str_exists
*
*  This function will return true if a sub string is found
*
*  @type    function
*  @date    1/05/2014
*  @since   5.0.0
*
*  @param   $needle (string)
*  @param   $haystack (string)
*  @return  (boolean)
*/

function acf_str_exists( $needle, $haystack ) {

	// return true if $haystack contains the $needle
	if ( is_string( $haystack ) && strpos( $haystack, $needle ) !== false ) {

		return true;

	}

	// return
	return false;
}


/*
*  acf_debug
*
*  description
*
*  @type    function
*  @date    2/05/2014
*  @since   5.0.0
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_debug() {

	// vars
	$args = func_get_args();
	$s    = array_shift( $args );
	$o    = '';
	$nl   = "\r\n";

	// start script
	$o .= '<script type="text/javascript">' . $nl;

	$o .= 'console.log("' . $s . '"';

	if ( ! empty( $args ) ) {

		foreach ( $args as $arg ) {

			if ( is_object( $arg ) || is_array( $arg ) ) {

				$arg = json_encode( $arg );

			} elseif ( is_bool( $arg ) ) {

				$arg = $arg ? 'true' : 'false';

			} elseif ( is_string( $arg ) ) {

				$arg = '"' . $arg . '"';

			}

			$o .= ', ' . $arg;

		}
	}

	$o .= ');' . $nl;

	// end script
	$o .= '</script>' . $nl;

	// echo
	echo $o;
}

function acf_debug_start() {

	acf_update_setting( 'debug_start', memory_get_usage() );

}

function acf_debug_end() {

	$start = acf_get_setting( 'debug_start' );
	$end   = memory_get_usage();

	return $end - $start;

}


/*
*  acf_encode_choices
*
*  description
*
*  @type    function
*  @date    4/06/2014
*  @since   5.0.0
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_encode_choices( $array = array(), $show_keys = true ) {

	// bail early if not array (maybe a single string)
	if ( ! is_array( $array ) ) {
		return $array;
	}

	// bail early if empty array
	if ( empty( $array ) ) {
		return '';
	}

	// vars
	$string = '';

	// if allowed to show keys (good for choices, not for default values)
	if ( $show_keys ) {

		// loop
		foreach ( $array as $k => $v ) {

			// ignore if key and value are the same
			if ( strval( $k ) == strval( $v ) ) {
				continue;
			}

			// show key in the value
			$array[ $k ] = $k . ' : ' . $v;

		}
	}

	// implode
	$string = implode( "\n", $array );

	// return
	return $string;

}

function acf_decode_choices( $string = '', $array_keys = false ) {

	// bail early if already array
	if ( is_array( $string ) ) {

		return $string;

		// allow numeric values (same as string)
	} elseif ( is_numeric( $string ) ) {

		// do nothing

		// bail early if not a string
	} elseif ( ! is_string( $string ) ) {

		return array();

		// bail early if is empty string
	} elseif ( $string === '' ) {

		return array();

	}

	// vars
	$array = array();

	// explode
	$lines = explode( "\n", $string );

	// key => value
	foreach ( $lines as $line ) {

		// vars
		$k = trim( $line );
		$v = trim( $line );

		// look for ' : '
		if ( acf_str_exists( ' : ', $line ) ) {

			$line = explode( ' : ', $line );

			$k = trim( $line[0] );
			$v = trim( $line[1] );

		}

		// append
		$array[ $k ] = $v;

	}

	// return only array keys? (good for checkbox default_value)
	if ( $array_keys ) {

		return array_keys( $array );

	}

	// return
	return $array;

}


/*
*  acf_str_replace
*
*  This function will replace an array of strings much like str_replace
*  The difference is the extra logic to avoid replacing a string that has alread been replaced
*  This is very useful for replacing date characters as they overlap with eachother
*
*  @type    function
*  @date    21/06/2016
*  @since   5.3.8
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_str_replace( $string = '', $search_replace = array() ) {

	// vars
	$ignore = array();

	// remove potential empty search to avoid PHP error
	unset( $search_replace[''] );

	// loop over conversions
	foreach ( $search_replace as $search => $replace ) {

		// ignore this search, it was a previous replace
		if ( in_array( $search, $ignore ) ) {
			continue;
		}

		// bail early if subsctring not found
		if ( strpos( $string, $search ) === false ) {
			continue;
		}

		// replace
		$string = str_replace( $search, $replace, $string );

		// append to ignore
		$ignore[] = $replace;

	}

	// return
	return $string;

}


/*
*  date & time formats
*
*  These settings contain an association of format strings from PHP => JS
*
*  @type    function
*  @date    21/06/2016
*  @since   5.3.8
*
*  @param   n/a
*  @return  n/a
*/

acf_update_setting(
	'php_to_js_date_formats',
	array(

		// Year
		'Y' => 'yy',    // Numeric, 4 digits                                1999, 2003
		'y' => 'y',     // Numeric, 2 digits                                99, 03


	// Month
		'm' => 'mm',    // Numeric, with leading zeros                      01–12
		'n' => 'm',     // Numeric, without leading zeros                   1–12
		'F' => 'MM',    // Textual full                                     January – December
		'M' => 'M',     // Textual three letters                            Jan - Dec


	// Weekday
		'l' => 'DD',    // Full name  (lowercase 'L')                       Sunday – Saturday
		'D' => 'D',     // Three letter name                                Mon – Sun


	// Day of Month
		'd' => 'dd',    // Numeric, with leading zeros                      01–31
		'j' => 'd',     // Numeric, without leading zeros                   1–31
		'S' => '',      // The English suffix for the day of the month      st, nd or th in the 1st, 2nd or 15th.

	)
);

acf_update_setting(
	'php_to_js_time_formats',
	array(

		'a' => 'tt',    // Lowercase Ante meridiem and Post meridiem        am or pm
		'A' => 'TT',    // Uppercase Ante meridiem and Post meridiem        AM or PM
		'h' => 'hh',    // 12-hour format of an hour with leading zeros     01 through 12
		'g' => 'h',     // 12-hour format of an hour without leading zeros  1 through 12
		'H' => 'HH',    // 24-hour format of an hour with leading zeros     00 through 23
		'G' => 'H',     // 24-hour format of an hour without leading zeros  0 through 23
		'i' => 'mm',    // Minutes with leading zeros                       00 to 59
		's' => 'ss',    // Seconds, with leading zeros                      00 through 59

	)
);


/*
*  acf_split_date_time
*
*  This function will split a format string into seperate date and time
*
*  @type    function
*  @date    26/05/2016
*  @since   5.3.8
*
*  @param   $date_time (string)
*  @return  $formats (array)
*/

function acf_split_date_time( $date_time = '' ) {

	// vars
	$php_date = acf_get_setting( 'php_to_js_date_formats' );
	$php_time = acf_get_setting( 'php_to_js_time_formats' );
	$chars    = str_split( $date_time );
	$type     = 'date';

	// default
	$data = array(
		'date' => '',
		'time' => '',
	);

	// loop
	foreach ( $chars as $i => $c ) {

		// find type
		// - allow misc characters to append to previous type
		if ( isset( $php_date[ $c ] ) ) {

			$type = 'date';

		} elseif ( isset( $php_time[ $c ] ) ) {

			$type = 'time';

		}

		// append char
		$data[ $type ] .= $c;

	}

	// trim
	$data['date'] = trim( $data['date'] );
	$data['time'] = trim( $data['time'] );

	// return
	return $data;

}


/*
*  acf_convert_date_to_php
*
*  This fucntion converts a date format string from JS to PHP
*
*  @type    function
*  @date    20/06/2014
*  @since   5.0.0
*
*  @param   $date (string)
*  @return  (string)
*/

function acf_convert_date_to_php( $date = '' ) {

	// vars
	$php_to_js = acf_get_setting( 'php_to_js_date_formats' );
	$js_to_php = array_flip( $php_to_js );

	// return
	return acf_str_replace( $date, $js_to_php );

}

/*
*  acf_convert_date_to_js
*
*  This fucntion converts a date format string from PHP to JS
*
*  @type    function
*  @date    20/06/2014
*  @since   5.0.0
*
*  @param   $date (string)
*  @return  (string)
*/

function acf_convert_date_to_js( $date = '' ) {

	// vars
	$php_to_js = acf_get_setting( 'php_to_js_date_formats' );

	// return
	return acf_str_replace( $date, $php_to_js );

}


/*
*  acf_convert_time_to_php
*
*  This fucntion converts a time format string from JS to PHP
*
*  @type    function
*  @date    20/06/2014
*  @since   5.0.0
*
*  @param   $time (string)
*  @return  (string)
*/

function acf_convert_time_to_php( $time = '' ) {

	// vars
	$php_to_js = acf_get_setting( 'php_to_js_time_formats' );
	$js_to_php = array_flip( $php_to_js );

	// return
	return acf_str_replace( $time, $js_to_php );

}


/*
*  acf_convert_time_to_js
*
*  This fucntion converts a date format string from PHP to JS
*
*  @type    function
*  @date    20/06/2014
*  @since   5.0.0
*
*  @param   $time (string)
*  @return  (string)
*/

function acf_convert_time_to_js( $time = '' ) {

	// vars
	$php_to_js = acf_get_setting( 'php_to_js_time_formats' );

	// return
	return acf_str_replace( $time, $php_to_js );

}


/*
*  acf_update_user_setting
*
*  description
*
*  @type    function
*  @date    15/07/2014
*  @since   5.0.0
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_update_user_setting( $name, $value ) {

	// get current user id
	$user_id = get_current_user_id();

	// get user settings
	$settings = get_user_meta( $user_id, 'acf_user_settings', true );

	// ensure array
	$settings = acf_get_array( $settings );

	// delete setting (allow 0 to save)
	if ( acf_is_empty( $value ) ) {

		unset( $settings[ $name ] );

		// append setting
	} else {

		$settings[ $name ] = $value;

	}

	// update user data
	return update_metadata( 'user', $user_id, 'acf_user_settings', $settings );

}


/*
*  acf_get_user_setting
*
*  description
*
*  @type    function
*  @date    15/07/2014
*  @since   5.0.0
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_get_user_setting( $name = '', $default = false ) {

	// get current user id
	$user_id = get_current_user_id();

	// get user settings
	$settings = get_user_meta( $user_id, 'acf_user_settings', true );

	// ensure array
	$settings = acf_get_array( $settings );

	// bail arly if no settings
	if ( ! isset( $settings[ $name ] ) ) {
		return $default;
	}

	// return
	return $settings[ $name ];

}


/*
*  acf_in_array
*
*  description
*
*  @type    function
*  @date    22/07/2014
*  @since   5.0.0
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_in_array( $value = '', $array = false ) {

	// bail early if not array
	if ( ! is_array( $array ) ) {
		return false;
	}

	// find value in array
	return in_array( $value, $array );

}


/*
*  acf_get_valid_post_id
*
*  This function will return a valid post_id based on the current screen / parameter
*
*  @type    function
*  @date    8/12/2013
*  @since   5.0.0
*
*  @param   $post_id (mixed)
*  @return  $post_id (mixed)
*/

function acf_get_valid_post_id( $post_id = 0 ) {

	// allow filter to short-circuit load_value logic
	$preload = apply_filters( 'acf/pre_load_post_id', null, $post_id );
	if ( $preload !== null ) {
		return $preload;
	}

	// vars
	$_post_id = $post_id;

	// if not $post_id, load queried object
	if ( ! $post_id ) {

		// try for global post (needed for setup_postdata)
		$post_id = (int) get_the_ID();

		// try for current screen
		if ( ! $post_id ) {

			$post_id = get_queried_object();

		}
	}

	// $post_id may be an object.
	// todo: Compare class types instead.
	if ( is_object( $post_id ) ) {

		// post
		if ( isset( $post_id->post_type, $post_id->ID ) ) {

			$post_id = $post_id->ID;

			// user
		} elseif ( isset( $post_id->roles, $post_id->ID ) ) {

			$post_id = 'user_' . $post_id->ID;

			// term
		} elseif ( isset( $post_id->taxonomy, $post_id->term_id ) ) {

			$post_id = 'term_' . $post_id->term_id;

			// comment
		} elseif ( isset( $post_id->comment_ID ) ) {

			$post_id = 'comment_' . $post_id->comment_ID;

			// default
		} else {

			$post_id = 0;

		}
	}

	// allow for option == options
	if ( $post_id === 'option' ) {

		$post_id = 'options';

	}

	// append language code
	if ( $post_id == 'options' ) {

		$dl = acf_get_setting( 'default_language' );
		$cl = acf_get_setting( 'current_language' );

		if ( $cl && $cl !== $dl ) {

			$post_id .= '_' . $cl;

		}
	}

	// filter for 3rd party
	$post_id = apply_filters( 'acf/validate_post_id', $post_id, $_post_id );

	// return
	return $post_id;

}



/*
*  acf_get_post_id_info
*
*  This function will return the type and id for a given $post_id string
*
*  @type    function
*  @date    2/07/2016
*  @since   5.4.0
*
*  @param   $post_id (mixed)
*  @return  $info (array)
*/

function acf_get_post_id_info( $post_id = 0 ) {

	// vars
	$info = array(
		'type' => 'post',
		'id'   => 0,
	);

	// bail early if no $post_id
	if ( ! $post_id ) {
		return $info;
	}

	// check cache
	// - this function will most likely be called multiple times (saving loading fields from post)
	// $cache_key = "get_post_id_info/post_id={$post_id}";

	// if( acf_isset_cache($cache_key) ) return acf_get_cache($cache_key);

	// numeric
	if ( is_numeric( $post_id ) ) {

		$info['id'] = (int) $post_id;

		// string
	} elseif ( is_string( $post_id ) ) {

		// vars
		$glue = '_';
		$type = explode( $glue, $post_id );
		$id   = array_pop( $type );
		$type = implode( $glue, $type );
		$meta = array( 'post', 'user', 'comment', 'term' );

		// check if is taxonomy (ACF < 5.5)
		// - avoid scenario where taxonomy exists with name of meta type
		if ( ! in_array( $type, $meta ) && acf_isset_termmeta( $type ) ) {
			$type = 'term';
		}

		// meta
		if ( is_numeric( $id ) && in_array( $type, $meta ) ) {

			$info['type'] = $type;
			$info['id']   = (int) $id;

			// option
		} else {

			$info['type'] = 'option';
			$info['id']   = $post_id;

		}
	}

	// update cache
	// acf_set_cache($cache_key, $info);

	// filter
	$info = apply_filters( 'acf/get_post_id_info', $info, $post_id );

	// return
	return $info;

}


/*
acf_log( acf_get_post_id_info(4) );

acf_log( acf_get_post_id_info('post_4') );

acf_log( acf_get_post_id_info('user_123') );

acf_log( acf_get_post_id_info('term_567') );

acf_log( acf_get_post_id_info('category_204') );

acf_log( acf_get_post_id_info('comment_6') );

acf_log( acf_get_post_id_info('options_lol!') );

acf_log( acf_get_post_id_info('option') );

acf_log( acf_get_post_id_info('options') );

*/


/*
*  acf_isset_termmeta
*
*  This function will return true if the termmeta table exists
*  https://developer.wordpress.org/reference/functions/get_term_meta/
*
*  @type    function
*  @date    3/09/2016
*  @since   5.4.0
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_isset_termmeta( $taxonomy = '' ) {

	// bail ealry if no table
	if ( get_option( 'db_version' ) < 34370 ) {
		return false;
	}

	// check taxonomy
	if ( $taxonomy && ! taxonomy_exists( $taxonomy ) ) {
		return false;
	}

	// return
	return true;

}


/*
*  acf_upload_files
*
*  This function will walk througfh the $_FILES data and upload each found
*
*  @type    function
*  @date    25/10/2014
*  @since   5.0.9
*
*  @param   $ancestors (array) an internal parameter, not required
*  @return  n/a
*/

function acf_upload_files( $ancestors = array() ) {

	// vars
	$file = array(
		'name'     => '',
		'type'     => '',
		'tmp_name' => '',
		'error'    => '',
		'size'     => '',
	);

	// populate with $_FILES data
	foreach ( array_keys( $file ) as $k ) {

		$file[ $k ] = $_FILES['acf'][ $k ];

	}

	// walk through ancestors
	if ( ! empty( $ancestors ) ) {

		foreach ( $ancestors as $a ) {

			foreach ( array_keys( $file ) as $k ) {

				$file[ $k ] = $file[ $k ][ $a ];

			}
		}
	}

	// is array?
	if ( is_array( $file['name'] ) ) {

		foreach ( array_keys( $file['name'] ) as $k ) {

			$_ancestors = array_merge( $ancestors, array( $k ) );

			acf_upload_files( $_ancestors );

		}

		return;

	}

	// bail ealry if file has error (no file uploaded)
	if ( $file['error'] ) {

		return;

	}

	// assign global _acfuploader for media validation
	$_POST['_acfuploader'] = end( $ancestors );

	// file found!
	$attachment_id = acf_upload_file( $file );

	// update $_POST
	array_unshift( $ancestors, 'acf' );
	acf_update_nested_array( $_POST, $ancestors, $attachment_id );

}


/*
*  acf_upload_file
*
*  This function will uploade a $_FILE
*
*  @type    function
*  @date    27/10/2014
*  @since   5.0.9
*
*  @param   $uploaded_file (array) array found from $_FILE data
*  @return  $id (int) new attachment ID
*/

function acf_upload_file( $uploaded_file ) {

	// required
	// require_once( ABSPATH . "/wp-load.php" ); // WP should already be loaded
	require_once ABSPATH . '/wp-admin/includes/media.php'; // video functions
	require_once ABSPATH . '/wp-admin/includes/file.php';
	require_once ABSPATH . '/wp-admin/includes/image.php';

	// required for wp_handle_upload() to upload the file
	$upload_overrides = array( 'test_form' => false );

	// upload
	$file = wp_handle_upload( $uploaded_file, $upload_overrides );

	// bail ealry if upload failed
	if ( isset( $file['error'] ) ) {

		return $file['error'];

	}

	// vars
	$url      = $file['url'];
	$type     = $file['type'];
	$file     = $file['file'];
	$filename = basename( $file );

	// Construct the object array
	$object = array(
		'post_title'     => $filename,
		'post_mime_type' => $type,
		'guid'           => $url,
	);

	// Save the data
	$id = wp_insert_attachment( $object, $file );

	// Add the meta-data
	wp_update_attachment_metadata( $id, wp_generate_attachment_metadata( $id, $file ) );

	/** This action is documented in wp-admin/custom-header.php */
	do_action( 'wp_create_file_in_uploads', $file, $id ); // For replication

	// return new ID
	return $id;

}


/*
*  acf_update_nested_array
*
*  This function will update a nested array value. Useful for modifying the $_POST array
*
*  @type    function
*  @date    27/10/2014
*  @since   5.0.9
*
*  @param   $array (array) target array to be updated
*  @param   $ancestors (array) array of keys to navigate through to find the child
*  @param   $value (mixed) The new value
*  @return  (boolean)
*/

function acf_update_nested_array( &$array, $ancestors, $value ) {

	// if no more ancestors, update the current var
	if ( empty( $ancestors ) ) {

		$array = $value;

		// return
		return true;

	}

	// shift the next ancestor from the array
	$k = array_shift( $ancestors );

	// if exists
	if ( isset( $array[ $k ] ) ) {

		return acf_update_nested_array( $array[ $k ], $ancestors, $value );

	}

	// return
	return false;
}


/*
*  acf_is_screen
*
*  This function will return true if all args are matched for the current screen
*
*  @type    function
*  @date    9/12/2014
*  @since   5.1.5
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_is_screen( $id = '' ) {

	// bail early if not defined
	if ( ! function_exists( 'get_current_screen' ) ) {
		return false;
	}

	// vars
	$current_screen = get_current_screen();

	// no screen
	if ( ! $current_screen ) {
		return false;

		// array
	} elseif ( is_array( $id ) ) {
		return in_array( $current_screen->id, $id );

		// string
	} else {
		return ( $id === $current_screen->id );
	}
}


/*
*  acf_maybe_get
*
*  This function will return a var if it exists in an array
*
*  @type    function
*  @date    9/12/2014
*  @since   5.1.5
*
*  @param   $array (array) the array to look within
*  @param   $key (key) the array key to look for. Nested values may be found using '/'
*  @param   $default (mixed) the value returned if not found
*  @return  $post_id (int)
*/

function acf_maybe_get( $array = array(), $key = 0, $default = null ) {

	return isset( $array[ $key ] ) ? $array[ $key ] : $default;

}

function acf_maybe_get_POST( $key = '', $default = null ) {

	return isset( $_POST[ $key ] ) ? $_POST[ $key ] : $default;

}

function acf_maybe_get_GET( $key = '', $default = null ) {

	return isset( $_GET[ $key ] ) ? $_GET[ $key ] : $default;

}

/**
 * Returns an array of attachment data.
 *
 * @date    05/01/2015
 * @since   5.1.5
 *
 * @param   int|WP_Post The attachment ID or object.
 * @return  array|false
 */
function acf_get_attachment( $attachment ) {

	// Allow filter to short-circuit load attachment logic.
	// Alternatively, this filter may be used to switch blogs for multisite media functionality.
	$response = apply_filters( 'acf/pre_load_attachment', null, $attachment );
	if ( $response !== null ) {
		return $response;
	}

	// Get the attachment post object.
	$attachment = get_post( $attachment );
	if ( ! $attachment ) {
		return false;
	}
	if ( $attachment->post_type !== 'attachment' ) {
		return false;
	}

	// Load various attachment details.
	$meta          = wp_get_attachment_metadata( $attachment->ID );
	$attached_file = get_attached_file( $attachment->ID );
	if ( strpos( $attachment->post_mime_type, '/' ) !== false ) {
		list( $type, $subtype ) = explode( '/', $attachment->post_mime_type );
	} else {
		list( $type, $subtype ) = array( $attachment->post_mime_type, '' );
	}

	// Generate response.
	$response = array(
		'ID'          => $attachment->ID,
		'id'          => $attachment->ID,
		'title'       => $attachment->post_title,
		'filename'    => wp_basename( $attached_file ),
		'filesize'    => 0,
		'url'         => wp_get_attachment_url( $attachment->ID ),
		'link'        => get_attachment_link( $attachment->ID ),
		'alt'         => get_post_meta( $attachment->ID, '_wp_attachment_image_alt', true ),
		'author'      => $attachment->post_author,
		'description' => $attachment->post_content,
		'caption'     => $attachment->post_excerpt,
		'name'        => $attachment->post_name,
		'status'      => $attachment->post_status,
		'uploaded_to' => $attachment->post_parent,
		'date'        => $attachment->post_date_gmt,
		'modified'    => $attachment->post_modified_gmt,
		'menu_order'  => $attachment->menu_order,
		'mime_type'   => $attachment->post_mime_type,
		'type'        => $type,
		'subtype'     => $subtype,
		'icon'        => wp_mime_type_icon( $attachment->ID ),
	);

	// Append filesize data.
	if ( isset( $meta['filesize'] ) ) {
		$response['filesize'] = $meta['filesize'];
	} elseif ( file_exists( $attached_file ) ) {
		$response['filesize'] = filesize( $attached_file );
	}

	// Restrict the loading of image "sizes".
	$sizes_id = 0;

	// Type specific logic.
	switch ( $type ) {
		case 'image':
			$sizes_id = $attachment->ID;
			$src      = wp_get_attachment_image_src( $attachment->ID, 'full' );
			if ( $src ) {
				$response['url']    = $src[0];
				$response['width']  = $src[1];
				$response['height'] = $src[2];
			}
			break;
		case 'video':
			$response['width']  = acf_maybe_get( $meta, 'width', 0 );
			$response['height'] = acf_maybe_get( $meta, 'height', 0 );
			if ( $featured_id = get_post_thumbnail_id( $attachment->ID ) ) {
				$sizes_id = $featured_id;
			}
			break;
		case 'audio':
			if ( $featured_id = get_post_thumbnail_id( $attachment->ID ) ) {
				$sizes_id = $featured_id;
			}
			break;
	}

	// Load array of image sizes.
	if ( $sizes_id ) {
		$sizes      = get_intermediate_image_sizes();
		$sizes_data = array();
		foreach ( $sizes as $size ) {
			$src = wp_get_attachment_image_src( $sizes_id, $size );
			if ( $src ) {
				$sizes_data[ $size ]             = $src[0];
				$sizes_data[ $size . '-width' ]  = $src[1];
				$sizes_data[ $size . '-height' ] = $src[2];
			}
		}
		$response['sizes'] = $sizes_data;
	}

	/**
	 * Filters the attachment $response after it has been loaded.
	 *
	 * @date    16/06/2020
	 * @since   5.9.0
	 *
	 * @param   array $response Array of loaded attachment data.
	 * @param   WP_Post $attachment Attachment object.
	 * @param   array|false $meta Array of attachment meta data, or false if there is none.
	 */
	return apply_filters( 'acf/load_attachment', $response, $attachment, $meta );
}


/*
*  acf_get_truncated
*
*  This function will truncate and return a string
*
*  @type    function
*  @date    8/08/2014
*  @since   5.0.0
*
*  @param   $text (string)
*  @param   $length (int)
*  @return  (string)
*/

function acf_get_truncated( $text, $length = 64 ) {

	// vars
	$text       = trim( $text );
	$the_length = strlen( $text );

	// cut
	$return = substr( $text, 0, ( $length - 3 ) );

	// ...
	if ( $the_length > ( $length - 3 ) ) {

		$return .= '...';

	}

	// return
	return $return;

}

/*
*  acf_current_user_can_admin
*
*  This function will return true if the current user can administrate the ACF field groups
*
*  @type    function
*  @date    9/02/2015
*  @since   5.1.5
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_current_user_can_admin() {

	if ( acf_get_setting( 'show_admin' ) && current_user_can( acf_get_setting( 'capability' ) ) ) {

		return true;

	}

	// return
	return false;

}


/*
*  acf_get_filesize
*
*  This function will return a numeric value of bytes for a given filesize string
*
*  @type    function
*  @date    18/02/2015
*  @since   5.1.5
*
*  @param   $size (mixed)
*  @return  (int)
*/

function acf_get_filesize( $size = 1 ) {

	// vars
	$unit  = 'MB';
	$units = array(
		'TB' => 4,
		'GB' => 3,
		'MB' => 2,
		'KB' => 1,
	);

	// look for $unit within the $size parameter (123 KB)
	if ( is_string( $size ) ) {

		// vars
		$custom = strtoupper( substr( $size, -2 ) );

		foreach ( $units as $k => $v ) {

			if ( $custom === $k ) {

				$unit = $k;
				$size = substr( $size, 0, -2 );

			}
		}
	}

	// calc bytes
	$bytes = floatval( $size ) * pow( 1024, $units[ $unit ] );

	// return
	return $bytes;

}


/*
*  acf_format_filesize
*
*  This function will return a formatted string containing the filesize and unit
*
*  @type    function
*  @date    18/02/2015
*  @since   5.1.5
*
*  @param   $size (mixed)
*  @return  (int)
*/

function acf_format_filesize( $size = 1 ) {

	// convert
	$bytes = acf_get_filesize( $size );

	// vars
	$units = array(
		'TB' => 4,
		'GB' => 3,
		'MB' => 2,
		'KB' => 1,
	);

	// loop through units
	foreach ( $units as $k => $v ) {

		$result = $bytes / pow( 1024, $v );

		if ( $result >= 1 ) {

			return $result . ' ' . $k;

		}
	}

	// return
	return $bytes . ' B';

}


/*
*  acf_get_valid_terms
*
*  This function will replace old terms with new split term ids
*
*  @type    function
*  @date    27/02/2015
*  @since   5.1.5
*
*  @param   $terms (int|array)
*  @param   $taxonomy (string)
*  @return  $terms
*/

function acf_get_valid_terms( $terms = false, $taxonomy = 'category' ) {

	// force into array
	$terms = acf_get_array( $terms );

	// force ints
	$terms = array_map( 'intval', $terms );

	// bail early if function does not yet exist or
	if ( ! function_exists( 'wp_get_split_term' ) || empty( $terms ) ) {

		return $terms;

	}

	// attempt to find new terms
	foreach ( $terms as $i => $term_id ) {

		$new_term_id = wp_get_split_term( $term_id, $taxonomy );

		if ( $new_term_id ) {

			$terms[ $i ] = $new_term_id;

		}
	}

	// return
	return $terms;

}


/*
*  acf_validate_attachment
*
*  This function will validate an attachment based on a field's restrictions and return an array of errors
*
*  @type    function
*  @date    3/07/2015
*  @since   5.2.3
*
*  @param   $attachment (array) attachment data. Changes based on context
*  @param   $field (array) field settings containing restrictions
*  @param   $context (string) $file is different when uploading / preparing
*  @return  $errors (array)
*/

function acf_validate_attachment( $attachment, $field, $context = 'prepare' ) {

	// vars
	$errors = array();
	$file   = array(
		'type'   => '',
		'width'  => 0,
		'height' => 0,
		'size'   => 0,
	);

	// upload
	if ( $context == 'upload' ) {

		// vars
		$file['type'] = pathinfo( $attachment['name'], PATHINFO_EXTENSION );
		$file['size'] = filesize( $attachment['tmp_name'] );

		if ( strpos( $attachment['type'], 'image' ) !== false ) {

			$size           = getimagesize( $attachment['tmp_name'] );
			$file['width']  = acf_maybe_get( $size, 0 );
			$file['height'] = acf_maybe_get( $size, 1 );

		}

		// prepare
	} elseif ( $context == 'prepare' ) {

		$use_path       = isset( $attachment['filename'] ) ? $attachment['filename'] : $attachment['url'];
		$file['type']   = pathinfo( $use_path, PATHINFO_EXTENSION );
		$file['size']   = acf_maybe_get( $attachment, 'filesizeInBytes', 0 );
		$file['width']  = acf_maybe_get( $attachment, 'width', 0 );
		$file['height'] = acf_maybe_get( $attachment, 'height', 0 );

		// custom
	} else {

		$file         = array_merge( $file, $attachment );
		$use_path     = isset( $attachment['filename'] ) ? $attachment['filename'] : $attachment['url'];
		$file['type'] = pathinfo( $use_path, PATHINFO_EXTENSION );

	}

	// image
	if ( $file['width'] || $file['height'] ) {

		// width
		$min_width = (int) acf_maybe_get( $field, 'min_width', 0 );
		$max_width = (int) acf_maybe_get( $field, 'max_width', 0 );

		if ( $file['width'] ) {

			if ( $min_width && $file['width'] < $min_width ) {

				// min width
				$errors['min_width'] = sprintf( __( 'Image width must be at least %dpx.', 'acf' ), $min_width );

			} elseif ( $max_width && $file['width'] > $max_width ) {

				// min width
				$errors['max_width'] = sprintf( __( 'Image width must not exceed %dpx.', 'acf' ), $max_width );

			}
		}

		// height
		$min_height = (int) acf_maybe_get( $field, 'min_height', 0 );
		$max_height = (int) acf_maybe_get( $field, 'max_height', 0 );

		if ( $file['height'] ) {

			if ( $min_height && $file['height'] < $min_height ) {

				// min height
				$errors['min_height'] = sprintf( __( 'Image height must be at least %dpx.', 'acf' ), $min_height );

			} elseif ( $max_height && $file['height'] > $max_height ) {

				// min height
				$errors['max_height'] = sprintf( __( 'Image height must not exceed %dpx.', 'acf' ), $max_height );

			}
		}
	}

	// file size
	if ( $file['size'] ) {

		$min_size = acf_maybe_get( $field, 'min_size', 0 );
		$max_size = acf_maybe_get( $field, 'max_size', 0 );

		if ( $min_size && $file['size'] < acf_get_filesize( $min_size ) ) {

			// min width
			$errors['min_size'] = sprintf( __( 'File size must be at least %s.', 'acf' ), acf_format_filesize( $min_size ) );

		} elseif ( $max_size && $file['size'] > acf_get_filesize( $max_size ) ) {

			// min width
			$errors['max_size'] = sprintf( __( 'File size must not exceed %s.', 'acf' ), acf_format_filesize( $max_size ) );

		}
	}

	// file type
	if ( $file['type'] ) {

		$mime_types = acf_maybe_get( $field, 'mime_types', '' );

		// lower case
		$file['type'] = strtolower( $file['type'] );
		$mime_types   = strtolower( $mime_types );

		// explode
		$mime_types = str_replace( array( ' ', '.' ), '', $mime_types );
		$mime_types = explode( ',', $mime_types ); // split pieces
		$mime_types = array_filter( $mime_types ); // remove empty pieces

		if ( ! empty( $mime_types ) && ! in_array( $file['type'], $mime_types ) ) {

			// glue together last 2 types
			if ( count( $mime_types ) > 1 ) {

				$last1 = array_pop( $mime_types );
				$last2 = array_pop( $mime_types );

				$mime_types[] = $last2 . ' ' . __( 'or', 'acf' ) . ' ' . $last1;

			}

			$errors['mime_types'] = sprintf( __( 'File type must be %s.', 'acf' ), implode( ', ', $mime_types ) );

		}
	}

	/**
	*  Filters the errors for a file before it is uploaded or displayed in the media modal.
	*
	*  @date    3/07/2015
	*  @since   5.2.3
	*
	*  @param   array $errors An array of errors.
	*  @param   array $file An array of data for a single file.
	*  @param   array $attachment An array of attachment data which differs based on the context.
	*  @param   array $field The field array.
	*  @param   string $context The curent context (uploading, preparing)
	*/
	$errors = apply_filters( "acf/validate_attachment/type={$field['type']}", $errors, $file, $attachment, $field, $context );
	$errors = apply_filters( "acf/validate_attachment/name={$field['_name']}", $errors, $file, $attachment, $field, $context );
	$errors = apply_filters( "acf/validate_attachment/key={$field['key']}", $errors, $file, $attachment, $field, $context );
	$errors = apply_filters( 'acf/validate_attachment', $errors, $file, $attachment, $field, $context );

	// return
	return $errors;

}


/*
*  _acf_settings_uploader
*
*  Dynamic logic for uploader setting
*
*  @type    function
*  @date    7/05/2015
*  @since   5.2.3
*
*  @param   $uploader (string)
*  @return  $uploader
*/

add_filter( 'acf/settings/uploader', '_acf_settings_uploader' );

function _acf_settings_uploader( $uploader ) {

	// if can't upload files
	if ( ! current_user_can( 'upload_files' ) ) {

		$uploader = 'basic';

	}

	// return
	return $uploader;
}


/*
*  acf_translate_keys
*
*  description
*
*  @type    function
*  @date    7/12/2015
*  @since   5.3.2
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

/*
function acf_translate_keys( $array, $keys ) {

	// bail early if no keys
	if( empty($keys) ) return $array;


	// translate
	foreach( $keys as $k ) {

		// bail ealry if not exists
		if( !isset($array[ $k ]) ) continue;


		// translate
		$array[ $k ] = acf_translate( $array[ $k ] );

	}


	// return
	return $array;

}
*/


/*
*  acf_translate
*
*  This function will translate a string using the new 'l10n_textdomain' setting
*  Also works for arrays which is great for fields - select -> choices
*
*  @type    function
*  @date    4/12/2015
*  @since   5.3.2
*
*  @param   $string (mixed) string or array containins strings to be translated
*  @return  $string
*/

function acf_translate( $string ) {

	// vars
	$l10n       = acf_get_setting( 'l10n' );
	$textdomain = acf_get_setting( 'l10n_textdomain' );

	// bail early if not enabled
	if ( ! $l10n ) {
		return $string;
	}

	// bail early if no textdomain
	if ( ! $textdomain ) {
		return $string;
	}

	// is array
	if ( is_array( $string ) ) {

		return array_map( 'acf_translate', $string );

	}

	// bail early if not string
	if ( ! is_string( $string ) ) {
		return $string;
	}

	// bail early if empty
	if ( $string === '' ) {
		return $string;
	}

	// allow for var_export export
	if ( acf_get_setting( 'l10n_var_export' ) ) {

		// bail early if already translated
		if ( substr( $string, 0, 7 ) === '!!__(!!' ) {
			return $string;
		}

		// return
		return "!!__(!!'" . $string . "!!', !!'" . $textdomain . "!!')!!";

	}

	// vars
	return __( $string, $textdomain );

}


/*
*  acf_maybe_add_action
*
*  This function will determine if the action has already run before adding / calling the function
*
*  @type    function
*  @date    13/01/2016
*  @since   5.3.2
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_maybe_add_action( $tag, $function_to_add, $priority = 10, $accepted_args = 1 ) {

	// if action has already run, execute it
	// - if currently doing action, allow $tag to be added as per usual to allow $priority ordering needed for 3rd party asset compatibility
	if ( did_action( $tag ) && ! doing_action( $tag ) ) {

		call_user_func( $function_to_add );

		// if action has not yet run, add it
	} else {

		add_action( $tag, $function_to_add, $priority, $accepted_args );

	}

}


/*
*  acf_is_row_collapsed
*
*  This function will return true if the field's row is collapsed
*
*  @type    function
*  @date    2/03/2016
*  @since   5.3.2
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_is_row_collapsed( $field_key = '', $row_index = 0 ) {

	// collapsed
	$collapsed = acf_get_user_setting( 'collapsed_' . $field_key, '' );

	// cookie fallback ( version < 5.3.2 )
	if ( $collapsed === '' ) {

		$collapsed = acf_extract_var( $_COOKIE, "acf_collapsed_{$field_key}", '' );
		$collapsed = str_replace( '|', ',', $collapsed );

		// update
		acf_update_user_setting( 'collapsed_' . $field_key, $collapsed );

	}

	// explode
	$collapsed = explode( ',', $collapsed );
	$collapsed = array_filter( $collapsed, 'is_numeric' );

	// collapsed class
	return in_array( $row_index, $collapsed );

}


/*
*  acf_get_attachment_image
*
*  description
*
*  @type    function
*  @date    24/10/16
*  @since   5.5.0
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_get_attachment_image( $attachment_id = 0, $size = 'thumbnail' ) {

	// vars
	$url = wp_get_attachment_image_src( $attachment_id, 'thumbnail' );
	$alt = get_post_meta( $attachment_id, '_wp_attachment_image_alt', true );

	// bail early if no url
	if ( ! $url ) {
		return '';
	}

	// return
	$value = '<img src="' . $url . '" alt="' . $alt . '" />';

}


/*
*  acf_get_post_thumbnail
*
*  This function will return a thumbail image url for a given post
*
*  @type    function
*  @date    3/05/2016
*  @since   5.3.8
*
*  @param   $post (obj)
*  @param   $size (mixed)
*  @return  (string)
*/

function acf_get_post_thumbnail( $post = null, $size = 'thumbnail' ) {

	// vars
	$data = array(
		'url'  => '',
		'type' => '',
		'html' => '',
	);

	// post
	$post = get_post( $post );

	// bail early if no post
	if ( ! $post ) {
		return $data;
	}

	// vars
	$thumb_id  = $post->ID;
	$mime_type = acf_maybe_get( explode( '/', $post->post_mime_type ), 0 );

	// attachment
	if ( $post->post_type === 'attachment' ) {

		// change $thumb_id
		if ( $mime_type === 'audio' || $mime_type === 'video' ) {

			$thumb_id = get_post_thumbnail_id( $post->ID );

		}

		// post
	} else {

		$thumb_id = get_post_thumbnail_id( $post->ID );

	}

	// try url
	$data['url'] = wp_get_attachment_image_src( $thumb_id, $size );
	$data['url'] = acf_maybe_get( $data['url'], 0 );

	// default icon
	if ( ! $data['url'] && $post->post_type === 'attachment' ) {

		$data['url']  = wp_mime_type_icon( $post->ID );
		$data['type'] = 'icon';

	}

	// html
	$data['html'] = '<img src="' . $data['url'] . '" alt="" />';

	// return
	return $data;

}

/**
 * acf_get_browser
 *
 * Returns the name of the current browser.
 *
 * @date    17/01/2014
 * @since   5.0.0
 *
 * @param   void
 * @return  string
 */
function acf_get_browser() {

	// Check server var.
	if ( isset( $_SERVER['HTTP_USER_AGENT'] ) ) {
		$agent = $_SERVER['HTTP_USER_AGENT'];

		// Loop over search terms.
		$browsers = array(
			'Firefox' => 'firefox',
			'Trident' => 'msie',
			'MSIE'    => 'msie',
			'Edge'    => 'edge',
			'Chrome'  => 'chrome',
			'Safari'  => 'safari',
		);
		foreach ( $browsers as $k => $v ) {
			if ( strpos( $agent, $k ) !== false ) {
				return $v;
			}
		}
	}

	// Return default.
	return '';
}


/*
*  acf_is_ajax
*
*  This function will reutrn true if performing a wp ajax call
*
*  @type    function
*  @date    7/06/2016
*  @since   5.3.8
*
*  @param   n/a
*  @return  (boolean)
*/

function acf_is_ajax( $action = '' ) {

	// vars
	$is_ajax = false;

	// check if is doing ajax
	if ( defined( 'DOING_AJAX' ) && DOING_AJAX ) {

		$is_ajax = true;

	}

	// check $action
	if ( $action && acf_maybe_get( $_POST, 'action' ) !== $action ) {

		$is_ajax = false;

	}

	// return
	return $is_ajax;

}




/*
*  acf_format_date
*
*  This function will accept a date value and return it in a formatted string
*
*  @type    function
*  @date    16/06/2016
*  @since   5.3.8
*
*  @param   $value (string)
*  @return  $format (string)
*/

function acf_format_date( $value, $format ) {

	// bail early if no value
	if ( ! $value ) {
		return $value;
	}

	// vars
	$unixtimestamp = 0;

	// numeric (either unix or YYYYMMDD)
	if ( is_numeric( $value ) && strlen( $value ) !== 8 ) {

		$unixtimestamp = $value;

	} else {

		$unixtimestamp = strtotime( $value );

	}

	// return
	return date_i18n( $format, $unixtimestamp );

}

/**
 * acf_clear_log
 *
 * Deletes the debug.log file.
 *
 * @date    21/1/19
 * @since   5.7.10
 *
 * @param   type $var Description. Default.
 * @return  type Description.
 */
function acf_clear_log() {
	unlink( WP_CONTENT_DIR . '/debug.log' );
}

/*
*  acf_log
*
*  description
*
*  @type    function
*  @date    24/06/2016
*  @since   5.3.8
*
*  @param   $post_id (int)
*  @return  $post_id (int)
*/

function acf_log() {

	// vars
	$args = func_get_args();

	// loop
	foreach ( $args as $i => $arg ) {

		// array | object
		if ( is_array( $arg ) || is_object( $arg ) ) {
			$arg = print_r( $arg, true );

			// bool
		} elseif ( is_bool( $arg ) ) {
			$arg = 'bool(' . ( $arg ? 'true' : 'false' ) . ')';
		}

		// update
		$args[ $i ] = $arg;
	}

	// log
	error_log( implode( ' ', $args ) );
}

/**
 *  acf_dev_log
 *
 *  Used to log variables only if ACF_DEV is defined
 *
 *  @date    25/8/18
 *  @since   5.7.4
 *
 *  @param   mixed
 *  @return  void
 */
function acf_dev_log() {
	if ( defined( 'ACF_DEV' ) && ACF_DEV ) {
		call_user_func_array( 'acf_log', func_get_args() );
	}
}

/*
*  acf_doing
*
*  This function will tell ACF what task it is doing
*
*  @type    function
*  @date    28/06/2016
*  @since   5.3.8
*
*  @param   $event (string)
*  @param   context (string)
*  @return  n/a
*/

function acf_doing( $event = '', $context = '' ) {

	acf_update_setting( 'doing', $event );
	acf_update_setting( 'doing_context', $context );

}


/*
*  acf_is_doing
*
*  This function can be used to state what ACF is doing, or to check
*
*  @type    function
*  @date    28/06/2016
*  @since   5.3.8
*
*  @param   $event (string)
*  @param   context (string)
*  @return  (boolean)
*/

function acf_is_doing( $event = '', $context = '' ) {

	// vars
	$doing = false;

	// task
	if ( acf_get_setting( 'doing' ) === $event ) {

		$doing = true;

	}

	// context
	if ( $context && acf_get_setting( 'doing_context' ) !== $context ) {

		$doing = false;

	}

	// return
	return $doing;

}


/*
*  acf_is_plugin_active
*
*  This function will return true if the ACF plugin is active
*  - May be included within a theme or other plugin
*
*  @type    function
*  @date    13/07/2016
*  @since   5.4.0
*
*  @param   $basename (int)
*  @return  $post_id (int)
*/


function acf_is_plugin_active() {

	// vars
	$basename = acf_get_setting( 'basename' );

	// ensure is_plugin_active() exists (not on frontend)
	if ( ! function_exists( 'is_plugin_active' ) ) {

		include_once ABSPATH . 'wp-admin/includes/plugin.php';

	}

	// return
	return is_plugin_active( $basename );

}

/*
*  acf_send_ajax_results
*
*  This function will print JSON data for a Select2 AJAX query
*
*  @type    function
*  @date    19/07/2016
*  @since   5.4.0
*
*  @param   $response (array)
*  @return  n/a
*/

function acf_send_ajax_results( $response ) {

	// validate
	$response = wp_parse_args(
		$response,
		array(
			'results' => array(),
			'more'    => false,
			'limit'   => 0,
		)
	);

	// limit
	if ( $response['limit'] && $response['results'] ) {

		// vars
		$total = 0;

		foreach ( $response['results'] as $result ) {

			// parent
			$total++;

			// children
			if ( ! empty( $result['children'] ) ) {

				$total += count( $result['children'] );

			}
		}

		// calc
		if ( $total >= $response['limit'] ) {

			$response['more'] = true;

		}
	}

	// return
	wp_send_json( $response );

}


/*
*  acf_is_sequential_array
*
*  This function will return true if the array contains only numeric keys
*
*  @source  http://stackoverflow.com/questions/173400/how-to-check-if-php-array-is-associative-or-sequential
*  @type    function
*  @date    9/09/2016
*  @since   5.4.0
*
*  @param   $array (array)
*  @return  (boolean)
*/

function acf_is_sequential_array( $array ) {

	// bail ealry if not array
	if ( ! is_array( $array ) ) {
		return false;
	}

	// loop
	foreach ( $array as $key => $value ) {

		// bail ealry if is string
		if ( is_string( $key ) ) {
			return false;
		}
	}

	// return
	return true;

}


/*
*  acf_is_associative_array
*
*  This function will return true if the array contains one or more string keys
*
*  @source  http://stackoverflow.com/questions/173400/how-to-check-if-php-array-is-associative-or-sequential
*  @type    function
*  @date    9/09/2016
*  @since   5.4.0
*
*  @param   $array (array)
*  @return  (boolean)
*/

function acf_is_associative_array( $array ) {

	// bail ealry if not array
	if ( ! is_array( $array ) ) {
		return false;
	}

	// loop
	foreach ( $array as $key => $value ) {

		// bail ealry if is string
		if ( is_string( $key ) ) {
			return true;
		}
	}

	// return
	return false;

}


/*
*  acf_add_array_key_prefix
*
*  This function will add a prefix to all array keys
*  Useful to preserve numeric keys when performing array_multisort
*
*  @type    function
*  @date    15/09/2016
*  @since   5.4.0
*
*  @param   $array (array)
*  @param   $prefix (string)
*  @return  (array)
*/

function acf_add_array_key_prefix( $array, $prefix ) {

	// vars
	$array2 = array();

	// loop
	foreach ( $array as $k => $v ) {

		$k2            = $prefix . $k;
		$array2[ $k2 ] = $v;

	}

	// return
	return $array2;

}


/*
*  acf_remove_array_key_prefix
*
*  This function will remove a prefix to all array keys
*  Useful to preserve numeric keys when performing array_multisort
*
*  @type    function
*  @date    15/09/2016
*  @since   5.4.0
*
*  @param   $array (array)
*  @param   $prefix (string)
*  @return  (array)
*/

function acf_remove_array_key_prefix( $array, $prefix ) {

	// vars
	$array2 = array();
	$l      = strlen( $prefix );

	// loop
	foreach ( $array as $k => $v ) {

		$k2            = ( substr( $k, 0, $l ) === $prefix ) ? substr( $k, $l ) : $k;
		$array2[ $k2 ] = $v;

	}

	// return
	return $array2;

}


/*
*  acf_strip_protocol
*
*  This function will remove the proticol from a url
*  Used to allow licences to remain active if a site is switched to https
*
*  @type    function
*  @date    10/01/2017
*  @since   5.5.4
*  @author  Aaron
*
*  @param   $url (string)
*  @return  (string)
*/

function acf_strip_protocol( $url ) {

	// strip the protical
	return str_replace( array( 'http://', 'https://' ), '', $url );

}


/*
*  acf_connect_attachment_to_post
*
*  This function will connect an attacment (image etc) to the post
*  Used to connect attachements uploaded directly to media that have not been attaced to a post
*
*  @type    function
*  @date    11/01/2017
*  @since   5.8.0 Added filter to prevent connection.
*  @since   5.5.4
*
*  @param   int $attachment_id The attachment ID.
*  @param   int $post_id The post ID.
*  @return  bool True if attachment was connected.
*/
function acf_connect_attachment_to_post( $attachment_id = 0, $post_id = 0 ) {

	// Bail ealry if $attachment_id is not valid.
	if ( ! $attachment_id || ! is_numeric( $attachment_id ) ) {
		return false;
	}

	// Bail ealry if $post_id is not valid.
	if ( ! $post_id || ! is_numeric( $post_id ) ) {
		return false;
	}

	/**
	*  Filters whether or not to connect the attachment.
	*
	*  @date    8/11/18
	*  @since   5.8.0
	*
	*  @param   bool $bool Returning false will prevent the connection. Default true.
	*  @param   int $attachment_id The attachment ID.
	*  @param   int $post_id The post ID.
	*/
	if ( ! apply_filters( 'acf/connect_attachment_to_post', true, $attachment_id, $post_id ) ) {
		return false;
	}

	// vars
	$post = get_post( $attachment_id );

	// Check if is valid post.
	if ( $post && $post->post_type == 'attachment' && $post->post_parent == 0 ) {

		// update
		wp_update_post(
			array(
				'ID'          => $post->ID,
				'post_parent' => $post_id,
			)
		);

		// return
		return true;
	}

	// return
	return true;
}


/*
*  acf_encrypt
*
*  This function will encrypt a string using PHP
*  https://bhoover.com/using-php-openssl_encrypt-openssl_decrypt-encrypt-decrypt-data/
*
*  @type    function
*  @date    27/2/17
*  @since   5.5.8
*
*  @param   $data (string)
*  @return  (string)
*/


function acf_encrypt( $data = '' ) {

	// bail ealry if no encrypt function
	if ( ! function_exists( 'openssl_encrypt' ) ) {
		return base64_encode( $data );
	}

	// generate a key
	$key = wp_hash( 'acf_encrypt' );

	// Generate an initialization vector
	$iv = openssl_random_pseudo_bytes( openssl_cipher_iv_length( 'aes-256-cbc' ) );

	// Encrypt the data using AES 256 encryption in CBC mode using our encryption key and initialization vector.
	$encrypted_data = openssl_encrypt( $data, 'aes-256-cbc', $key, 0, $iv );

	// The $iv is just as important as the key for decrypting, so save it with our encrypted data using a unique separator (::)
	return base64_encode( $encrypted_data . '::' . $iv );

}


/*
*  acf_decrypt
*
*  This function will decrypt an encrypted string using PHP
*  https://bhoover.com/using-php-openssl_encrypt-openssl_decrypt-encrypt-decrypt-data/
*
*  @type    function
*  @date    27/2/17
*  @since   5.5.8
*
*  @param   $data (string)
*  @return  (string)
*/

function acf_decrypt( $data = '' ) {

	// bail ealry if no decrypt function
	if ( ! function_exists( 'openssl_decrypt' ) ) {
		return base64_decode( $data );
	}

	// generate a key
	$key = wp_hash( 'acf_encrypt' );

	// To decrypt, split the encrypted data from our IV - our unique separator used was "::"
	list($encrypted_data, $iv) = explode( '::', base64_decode( $data ), 2 );

	// decrypt
	return openssl_decrypt( $encrypted_data, 'aes-256-cbc', $key, 0, $iv );

}

/**
 *  acf_parse_markdown
 *
 *  A very basic regex-based Markdown parser function based off [slimdown](https://gist.github.com/jbroadway/2836900).
 *
 *  @date    6/8/18
 *  @since   5.7.2
 *
 *  @param   string $text The string to parse.
 *  @return  string
 */

function acf_parse_markdown( $text = '' ) {

	// trim
	$text = trim( $text );

	// rules
	$rules = array(
		'/=== (.+?) ===/'            => '<h2>$1</h2>',                   // headings
		'/== (.+?) ==/'              => '<h3>$1</h3>',                   // headings
		'/= (.+?) =/'                => '<h4>$1</h4>',                   // headings
		'/\[([^\[]+)\]\(([^\)]+)\)/' => '<a href="$2">$1</a>',           // links
		'/(\*\*)(.*?)\1/'            => '<strong>$2</strong>',           // bold
		'/(\*)(.*?)\1/'              => '<em>$2</em>',                   // intalic
		'/`(.*?)`/'                  => '<code>$1</code>',               // inline code
		'/\n\*(.*)/'                 => "\n<ul>\n\t<li>$1</li>\n</ul>",  // ul lists
		'/\n[0-9]+\.(.*)/'           => "\n<ol>\n\t<li>$1</li>\n</ol>",  // ol lists
		'/<\/ul>\s?<ul>/'            => '',                              // fix extra ul
		'/<\/ol>\s?<ol>/'            => '',                              // fix extra ol
	);
	foreach ( $rules as $k => $v ) {
		$text = preg_replace( $k, $v, $text );
	}

	// autop
	$text = wpautop( $text );

	// return
	return $text;
}

/**
 *  acf_get_sites
 *
 *  Returns an array of sites for a network.
 *
 *  @date    29/08/2016
 *  @since   5.4.0
 *
 *  @param   void
 *  @return  array
 */
function acf_get_sites() {
	$results = array();
	$sites   = get_sites( array( 'number' => 0 ) );
	if ( $sites ) {
		foreach ( $sites as $site ) {
			$results[] = get_site( $site )->to_array();
		}
	}
	return $results;
}

/**
 *  acf_convert_rules_to_groups
 *
 *  Converts an array of rules from ACF4 to an array of groups for ACF5
 *
 *  @date    25/8/18
 *  @since   5.7.4
 *
 *  @param   array  $rules An array of rules.
 *  @param   string $anyorall The anyorall setting used in ACF4. Defaults to 'any'.
 *  @return  array
 */
function acf_convert_rules_to_groups( $rules, $anyorall = 'any' ) {

	// vars
	$groups = array();
	$index  = 0;

	// loop
	foreach ( $rules as $rule ) {

		// extract vars
		$group = acf_extract_var( $rule, 'group_no' );
		$order = acf_extract_var( $rule, 'order_no' );

		// calculate group if not defined
		if ( $group === null ) {
			$group = $index;

			// use $anyorall to determine if a new group is needed
			if ( $anyorall == 'any' ) {
				$index++;
			}
		}

		// calculate order if not defined
		if ( $order === null ) {
			$order = isset( $groups[ $group ] ) ? count( $groups[ $group ] ) : 0;
		}

		// append to group
		$groups[ $group ][ $order ] = $rule;

		// sort groups
		ksort( $groups[ $group ] );
	}

	// sort groups
	ksort( $groups );

	// return
	return $groups;
}

/**
 *  acf_register_ajax
 *
 *  Regsiters an ajax callback.
 *
 *  @date    5/10/18
 *  @since   5.7.7
 *
 *  @param   string $name The ajax action name.
 *  @param   array  $callback The callback function or array.
 *  @param   bool   $public Whether to allow access to non logged in users.
 *  @return  void
 */
function acf_register_ajax( $name = '', $callback = false, $public = false ) {

	// vars
	$action = "acf/ajax/$name";

	// add action for logged-in users
	add_action( "wp_ajax_$action", $callback );

	// add action for non logged-in users
	if ( $public ) {
		add_action( "wp_ajax_nopriv_$action", $callback );
	}
}

/**
 *  acf_str_camel_case
 *
 *  Converts a string into camelCase.
 *  Thanks to https://stackoverflow.com/questions/31274782/convert-array-keys-from-underscore-case-to-camelcase-recursively
 *
 *  @date    24/10/18
 *  @since   5.8.0
 *
 *  @param   string $string The string ot convert.
 *  @return  string
 */
function acf_str_camel_case( $string = '' ) {
	return lcfirst( str_replace( ' ', '', ucwords( str_replace( '_', ' ', $string ) ) ) );
}

/**
 *  acf_array_camel_case
 *
 *  Converts all aray keys to camelCase.
 *
 *  @date    24/10/18
 *  @since   5.8.0
 *
 *  @param   array $array The array to convert.
 *  @return  array
 */
function acf_array_camel_case( $array = array() ) {
	$array2 = array();
	foreach ( $array as $k => $v ) {
		$array2[ acf_str_camel_case( $k ) ] = $v;
	}
	return $array2;
}

/**
 * Returns true if the current screen is using the block editor.
 *
 * @date 13/12/18
 * @since 5.8.0
 *
 * @return bool
 */
function acf_is_block_editor() {
	if ( function_exists( 'get_current_screen' ) ) {
		$screen = get_current_screen();
		if ( $screen && method_exists( $screen, 'is_block_editor' ) ) {
			return $screen->is_block_editor();
		}
	}
	return false;
}
