class Connections extends \lithium\core\Adaptable {

	/**
	 * A Collection of the configurations you add through Connections::add().
	 *
	 * @var `lithium\util\Collection`
	 */
	protected static $_configurations = [];

	/**
	 * Libraries::locate() compatible path to adapters for this class.
	 *
	 * @var string Dot-delimited path.
	 */
	protected static $_adapters = 'data.source';

	/**
	 * Add connection configurations to your app in `config/bootstrap/connections.php`
	 *
	 * For example:
	 * ```
	 * Connections::add('default', [
	 *	'type' => 'database',
	 *	'adapter' => 'MySql',
	 *	'host' => 'localhost',
	 *	'login' => 'root',
	 *	'password' => '',
	 *	'database' => 'my_blog'
	 * ]);
	 * ```
	 *
	 * or
	 *
	 * ```
	 * Connections::add('couch', [
	 *	'type' => 'http',
	 *	'adapter' => 'CouchDb',
	 *	'host' => '127.0.0.1',
	 *	'port' => 5984
	 * ]);
	 * ```
	 *
	 * or
	 *
	 * ```
	 * Connections::add('mongo', [
	 *	'type' => 'MongoDb',
	 *	'database' => 'my_app'
	 * ]);
	 * ```
	 *
	 * @see lithium\data\Model::$_meta
	 * @param string $name The name by which this connection is referenced. Use this name to
	 *        retrieve the connection again using `Connections::get()`, or to bind a model to it
	 *        using `Model::$_meta['connection']`.
	 * @param array $config Contains all additional configuration information used by the
	 *        connection, including the name of the adapter class where applicable (i.e. `MySql`),
	 *        and typcially the server host/socket to connect to, the name of the database or
	 *        other entity to use. Each adapter has its own specific configuration settings for
	 *        handling things like connection persistence, data encoding, etc. See the
	 *        individual adapter or data source class for more information on what configuration
	 *        settings it supports. Basic / required options supported are:
	 *        - `'type'` _string_: The type of data source that defines this connection; typically a
	 *          class or namespace name. Relational database data sources, use `'database'`, while
	 *          CouchDB and other HTTP-related data sources use `'http'`, etc. For classes which
	 *          directly extend `lithium\data\Source`, and do not use an adapter, simply use the
	 *          name of the class, i.e. `'MongoDb'`.
	 *        - `'adapter'` _string_: For `type`s such as `'database'` which are adapter-driven,
	 *          provides the name of the adapter associated with this configuration.
	 * @return array Returns the final post-processed connection information, as stored in the
	 *         internal configuration array used by `Connections`.
	 */
	public static function add($name, array $config = []) {
		$defaults = [
			'type'     => null,
			'adapter'  => null
		];
		return static::$_configurations[$name] = $config + $defaults;
	}

	/**
	 * Removing a configuration.
	 *
	 * @param string $name The name by which this connection is referenced.
	 */
	public static function remove($name) {
		unset(static::$_configurations[$name]);
	}

	/**
	 * Read the configuration or access the connections you have set up.
	 *
	 * Usage:
	 * ```
	 * // Gets the names of all available configurations
	 * $configurations = Connections::get();
	 *
	 * // Gets the configuration array for the connection named 'db'
	 * $config = Connections::get('db', ['config' => true]);
	 *
	 * // Gets the instance of the connection object, configured with the settings defined for
	 * // this object in Connections::add()
	 * $dbConnection = Connections::get('db');
	 *
	 * // Gets the connection object, but only if it has already been built.
	 * // Otherwise returns null.
	 * $dbConnection = Connections::get('db', ['autoCreate' => false]);
	 * ```
	 *
	 * @param string $name The name of the connection to get, as defined in the first parameter of
	 *        `add()`, when the connection was initially created.
	 * @param array $options Options to use when returning the connection:
	 *        - `'autoCreate'`: If `false`, the connection object is only returned if it has
	 *          already been instantiated by a previous call.
	 *        - `'config'`: If `true`, returns an array representing the connection's internal
	 *          configuration, instead of the connection itself.
	 * @return mixed A configured instance of the connection, or an array of the configuration used.
	 */
	public static function get($name = null, array $options = []) {
		static $mockAdapter;

		$defaults = ['config' => false, 'autoCreate' => true];
		$options += $defaults;

		if ($name === false) {
			if (!$mockAdapter) {
				$class = Libraries::locate('data.source', 'Mock');
				$mockAdapter = new $class();
			}
			return $mockAdapter;
		}

		if (!$name) {
			return array_keys(static::$_configurations);
		}

		if (!isset(static::$_configurations[$name])) {
			return null;
		}
		if ($options['config']) {
			return static::_config($name);
		}
		$settings = static::$_configurations[$name];

		if (!isset($settings[0]['object']) && !$options['autoCreate']) {
			return null;
		}
		return static::adapter($name);
	}

	/**
	 * Constructs a data source or adapter object instance from a configuration array.
	 *
	 * @param array $config
	 * @param array $paths
	 * @return object
	 */
	protected static function _class($config, $paths = []) {
		if (!$config['adapter']) {
			$config['adapter'] = $config['type'];
		} else {
			$paths = array_merge(["adapter.data.source.{$config['type']}"], (array) $paths);
		}
		return parent::_class($config, $paths);
	}
}