<?php

/**
 * @package Simple Lightbox
 * @subpackage Base
 * @author Archetyped
 *
 */
class SLB_Base {
	/* Configuration */

	/**
	 * Class type
	 * Controls initialization, etc.
	 * > full - Fully-functional class
	 * > sub - Sub-class (attached to an instance)
	 * > object - Simple object class (no hooks, etc.)
	 * @var string
	 */
	protected $mode = 'full';

	/**
	 * Indicates that instance is model (main controller)
	 * @var bool
	 */
	protected $model = false;

	/* Properties */

	/**
	 * Variable name of base object in global scope
	 * @var string
	 */
	protected $base = 'slb';

	/**
	 * Prefix for plugin-related data (attributes, DB tables, etc.)
	 * @var string
	 */
	public $prefix = 'slb';

	/**
	 * Prefix to be added when creating internal hook (action/filter) tags
	 * Used by Utilities
	 * @var string
	 */
	public $hook_prefix = '';

	/**
	 * Global data
	 * Facilitates sharing between decoupled objects
	 * @var array
	 */
	private static $globals = array();

	protected $shared = array( 'options', 'admin' );

	/**
	 * Capabilities
	 * @var array
	 */
	protected $caps = null;

	protected $_init = false;

	private static $_init_passed = false;

	/* Client */

	/**
	 * Client files
	 * @var array
	 * Structure
	 * > Key: unique file ID
	 * > Properties
	 *   > file (string) File path (Relative to plugin base)
	 *   > deps (array) Script dependencies
	 *      > Internal dependencies are wrapped in square brackets ([])
	 *   > context (string|array)
	 *      > Context in which the script should be included
	 *   > in_footer (bool) optional [Default: FALSE]
	 *      > If TRUE, file will be included in footer of page, otherwise it will be included in the header
	 *
	 * Array is processed and converted to an object on init
	 */
	private $client_files = array(
		'scripts' => array(),
		'styles'  => array(),
	);

	/*-** Instances **-*/

	/**
	 * Utilities
	 * @var SLB_Utilities
	 */
	public $util = null;

	/**
	 * Options
	 * @var SLB_Options
	 */
	protected $options = null;

	/**
	 * Admin
	 * @var SLB_Admin
	 */
	public $admin = null;

	/*-** Initialization **-*/

	/**
	 * Constructor
	 */
	function __construct() {
		$this->util = new SLB_Utilities( $this );
		if ( $this->can( 'init' ) ) {
			$hook = 'init';
			if ( did_action( $hook ) || self::$_init_passed ) {
				$this->_init();
			} else {
				add_action( $hook, $this->m( '_init' ), 1 );
			}
		}
	}

	/**
	 * Default initialization method
	 * @uses _init_passed
	 * @uses _env()
	 * @uses _options()
	 * @uses _admin()
	 * @uses _hooks()
	 * @uses _client_files()
	 */
	public function _init() {
		self::$_init_passed = true;
		if ( $this->_init || ! isset( $this ) || ! $this->can( 'init' ) ) {
			return false;
		}
		$this->_init = true;
		// Environment
		$this->_env();

		if ( $this->can( 'control' ) ) {
			// Options
			$this->_options();

			// Admin
			if ( is_admin() ) {
				$this->_admin();
			}
		}

		// Hooks
		$this->_hooks();

		// Client files
		$this->_client_files();
	}

	/**
	 * Initialize environment (Localization, etc.)
	 */
	private function _env() {
		if ( ! $this->can( 'singleton' ) ) {
			return false;
		}
		// Localization
		$ldir      = 'l10n';
		$lpath     = $this->util->get_plugin_file_path( $ldir, array( false, false ) );
		$lpath_abs = $this->util->get_file_path( $ldir );
		if ( is_dir( $lpath_abs ) ) {
			load_plugin_textdomain( 'simple-lightbox', false, $lpath );
		}

		// Context
		add_action( ( is_admin() ) ? 'admin_print_footer_scripts' : 'wp_footer', $this->util->m( 'set_client_context' ), $this->util->priority( 'client_footer_output' ) );
	}

	/**
	 * Initialize options
	 * To be implemented in child classes
	 */
	protected function _options() {}

	/**
	 * Initialize options
	 * To be called by child class
	 */
	protected function _set_options( $options_config = null ) {
		$class = $this->util->get_class( 'Options' );
		$key   = 'options';
		if ( $this->shares( $key ) ) {
			$opts = $this->gvar( $key );
			// Setup options instance
			if ( ! ( $opts instanceof $class ) ) {
				$opts = $this->gvar( $key, new $class() );
			}
		} else {
			$opts = new $class();
		}
		// Load options
		if ( $this->is_options_valid( $options_config, false ) ) {
			$opts->load( $options_config );
		}
		// Set instance property
		$this->options = $opts;
	}

	/**
	 * Initialize admin
	 * To be called by child class
	 */
	private function _admin() {
		if ( ! is_admin() ) {
			return false;
		}
		$class = $this->util->get_class( 'Admin' );
		$key   = 'admin';
		if ( $this->shares( $key ) ) {
			$adm = $this->gvar( $key );
			// Setup options instance
			if ( ! ( $adm instanceof $class ) ) {
				$adm = $this->gvar( $key, new $class( $this ) );
			}
		} else {
			$adm = new $class( $this );
		}
		// Set instance property
		$this->admin = $adm;
	}

	/**
	 * Register default hooks
	 */
	protected function _hooks() {
		$base = $this->util->get_plugin_base_file();
		// Activation
		$func_activate = '_activate';
		if ( method_exists( $this, $func_activate ) ) {
			register_activation_hook( $base, $this->m( $func_activate ) );
		}

		// Deactivation
		$func_deactivate = '_deactivate';
		if ( method_exists( $this, $func_deactivate ) ) {
			register_deactivation_hook( $base, $this->m( $func_deactivate ) );
		}
	}

	/**
	 * Initialize client files
	 */
	protected function _client_files( $files = null ) {
		// Validation
		if ( ! is_array( $files ) || empty( $files ) ) {
			return false;
		}
		foreach ( $this->client_files as $key => $val ) {
			if ( isset( $files[ $key ] ) && is_array( $files[ $key ] ) || ! empty( $files[ $key ] ) ) {
				$this->client_files[ $key ] = $this->util->parse_client_files( $files[ $key ], $key );
			}
			// Remove empty file groups
			if ( empty( $this->client_files[ $key ] ) ) {
				unset( $this->client_files[ $key ] );
			}
		}

		// Stop if no files are set for registration
		if ( empty( $this->client_files ) ) {
			return false;
		}

		// Register
		add_action( 'init', $this->m( 'register_client_files' ) );

		// Enqueue
		$hk_prfx       = ( ( is_admin() ) ? 'admin' : 'wp' );
		$hk_enqueue    = $hk_prfx . '_enqueue_scripts';
		$hk_enqueue_ft = $hk_prfx . '_footer';
		add_action( $hk_enqueue, $this->m( 'enqueue_client_files' ), 10, 0 );
		add_action( $hk_enqueue_ft, $this->m( 'enqueue_client_files_footer' ), 1 );
	}

	/**
	 * Register client files
	 * @see enqueue_client_files() for actual loading of files based on context
	 * @uses `init` Action hook for execution
	 * @return void
	 */
	public function register_client_files() {
		$v = $this->util->get_plugin_version();
		foreach ( $this->client_files as $type => $files ) {
			$func = $this->get_client_files_handler( $type, 'register' );
			if ( ! $func ) {
				continue;
			}
			foreach ( $files as $f ) {
				// Get file URI
				$f->file = ( ! $this->util->is_file( $f->file ) && is_callable( $f->file ) ) ? call_user_func( $f->file ) : $this->util->get_file_url( $f->file, true );
				$params  = array( $f->id, $f->file, $f->deps, $v );
				// Set additional parameters based on file type (script, style, etc.)
				switch ( $type ) {
					case 'scripts':
						$params[] = $f->in_footer;
						break;
					case 'styles':
						$params[] = $f->media;
						break;
				}
				// Register file
				call_user_func_array( $func, $params );
			}
		}
	}

	/**
	 * Enqueues files for client output (scripts/styles) based on context
	 * @uses `admin_enqueue_scripts` Action hook depending on context
	 * @uses `wp_enqueue_scripts` Action hook depending on context
	 * @param bool $footer (optional) Whether to enqueue footer files (Default: No)
	 * @return void
	 */
	function enqueue_client_files( $footer = false ) {
		// Validate
		if ( ! is_bool( $footer ) ) {
			$footer = false;
		}
		// Enqueue files
		foreach ( $this->client_files as $type => $files ) {
			$func = $this->get_client_files_handler( $type, 'enqueue' );
			if ( ! $func ) {
				continue;
			}
			foreach ( $files as $fkey => $f ) {
				// Skip previously-enqueued files and shadow files
				if ( $f->enqueued || ! $f->enqueue ) {
					continue;
				}
				// Enqueue files only for current location (header/footer)
				if ( isset( $f->in_footer ) ) {
					if ( $f->in_footer !== $footer ) {
						continue;
					}
				} elseif ( $footer ) {
					continue;
				}
				$load = true;
				// Global Callback
				if ( is_callable( $f->callback ) && ! call_user_func( $f->callback ) ) {
					$load = false;
				}
				// Context
				if ( $load && ! empty( $f->context ) ) {
					// Reset $load before evaluating context
					$load = false;
					// Iterate through contexts
					foreach ( $f->context as $ctx ) {
						// Context + Callback
						if ( is_array( $ctx ) ) {
							// Stop checking context if callback is invalid
							if ( ! is_callable( $ctx[1] ) || ! call_user_func( $ctx[1] ) ) {
								continue;
							}
							$ctx = $ctx[0];
						}
						// Stop checking context if valid context found
						if ( $this->util->is_context( $ctx ) ) {
							$load = true;
							break;
						}
					}
				}
				// Load valid file
				if ( $load ) {
					// Mark file as enqueued
					$this->client_files[ $type ]->{$fkey}->enqueued = true;
					$func( $f->id );
				}
			}
		}
	}

	/**
	 * Enqueue client files in the footer
	 */
	public function enqueue_client_files_footer() {
		$this->enqueue_client_files( true );
	}

	/**
	 * Build function name for handling client operations
	 */
	function get_client_files_handler( $type, $action ) {
		$func = 'wp_' . $action . '_' . substr( $type, 0, -1 );
		if ( ! function_exists( $func ) ) {
			$func = false;
		}
		return $func;
	}

	/*-** Reflection **-*/

	/**
	 * Retrieve base object
	 * @return object|bool Base object (FALSE if object does not exist)
	 */
	function &get_base() {
		$base = false;
		if ( isset( $GLOBALS[ $this->base ] ) ) {
			$base =& $GLOBALS[ $this->base ];
		}
		return $base;
	}

	/*-** Method/Function calling **-*/

	/**
	 * Returns callback to instance method
	 * @param string $method Method name
	 * @return array Callback array
	 */
	function m( $method ) {
		return $this->util->m( $this, $method );
	}

	/*-** Prefix **-*/

	/**
	 * Retrieve class prefix (with separator if set)
	 * @param bool|string $sep Separator to append to class prefix (Default: no separator)
	 * @return string Class prefix
	 */
	function get_prefix( $sep = null ) {
		$args = func_get_args();
		return call_user_func_array( $this->util->m( $this->util, 'get_prefix' ), $args );
	}

	/**
	 * Check if a string is prefixed
	 * @param string $text Text to check for prefix
	 * @param string $sep (optional) Separator used
	 */
	function has_prefix( $text, $sep = null ) {
		$args = func_get_args();
		return call_user_func_array( $this->util->m( $this->util, 'has_prefix' ), $args );
	}

	/**
	 * Prepend plugin prefix to some text
	 * @param string $text Text to add to prefix
	 * @param string $sep (optional) Text used to separate prefix and text
	 * @param bool $once (optional) Whether to add prefix to text that already contains a prefix or not
	 * @return string Text with prefix prepended
	 */
	function add_prefix( $text, $sep = null, $once = true ) {
		$args = func_get_args();
		return call_user_func_array( $this->util->m( $this->util, 'add_prefix' ), $args );
	}

	/**
	 * Prepend uppercased plugin prefix to some text
	 * @param string $text Text to add to prefix
	 * @param string $sep (optional) Text used to separate prefix and text
	 * @param bool $once (optional) Whether to add prefix to text that already contains a prefix or not
	 * @return string Text with prefix prepended
	 */
	function add_prefix_uc( $text, $sep = null, $once = true ) {
		$args = func_get_args();
		return call_user_func_array( $this->util->m( $this->util, 'add_prefix_uc' ), $args );
	}

	/**
	 * Add prefix to variable reference
	 * Updates actual variable rather than return value
	 * @uses SLB_Utilities::add_prefix_ref();
	 * @param string $var Variable to add prefix to
	 * @param string $sep (optional) Separator text
	 * @param bool $once (optional) Add prefix only once
	 * @return void
	 */
	function add_prefix_ref( &$var, $sep = null, $once = true ) {
		$args    = func_get_args();
		$args[0] =& $var;
		call_user_func_array( $this->util->m( $this->util, 'add_prefix_ref' ), $args );
	}

	/**
	 * Remove prefix from specified string
	 * @param string $text String to remove prefix from
	 * @param string $sep (optional) Separator used with prefix
	 */
	function remove_prefix( $text, $sep = null ) {
		$args = func_get_args();
		return call_user_func_array( $this->util->m( $this->util, 'remove_prefix' ), $args );
	}

	/*-** Capabilities **-*/

	protected function can( $cap ) {
		if ( is_null( $this->caps ) ) {
			// Build capabilities based on instance properties
			$this->caps = array(
				'init'      => ( 'object' !== $this->mode ) ? true : false,
				'singleton' => ( ! ! $this->model ) ? true : false,
				'control'   => ( 'sub' === $this->mode || 'object' === $this->mode ) ? false : true,
			);
		}
		return ( isset( $this->caps[ $cap ] ) ) ? $this->caps[ $cap ] : false;
	}

	/*-** Globals **-*/

	/**
	 * Get/Set (internal) global variables
	 * @uses $globals to get/set global variables
	 * @param string $name Variable name - If no name is specified, entire globals array is returned
	 * @param mixed $val (optional) Set the value of a variable (Returns variable value if omitted)
	 * @return mixed Variable value
	 */
	private function gvar( $name = null, $val = null ) {
		$g =& self::$globals;
		if ( ! is_array( $g ) ) {
			$g = array();
		}
		if ( ! is_string( $name ) || empty( $name ) ) {
			return $g;
		}
		$ret = $val;
		if ( null !== $val ) {
			// Set Value
			$g[ $name ] = $val;
		} elseif ( isset( $g[ $name ] ) ) {
			// Retrieve variable
			$ret = $g[ $name ];
		}
		return $ret;
	}

	private function shares( $name ) {
		return ( ! empty( $this->shared ) && in_array( $name, $this->shared, true ) ) ? true : false;
	}

	/*-** Options **-*/

	/**
	 * Checks if options are valid
	 * @param array $data Data to be used on options
	 * @return bool TRUE if options are valid, FALSE otherwise
	 */
	function is_options_valid( $data, $check_var = true ) {
		$class = $this->util->get_class( 'Options' );
		$ret   = ( empty( $data ) || ! is_array( $data ) || ! class_exists( $class ) ) ? false : true;
		if ( $ret && $check_var && ! ( $this->options instanceof $class ) ) {
			$ret = false;
		}
		return $ret;
	}
}