<?php

namespace ActivityPhp\Type;

use Exception;

/**
 * \ActivityPhp\Type\Dialect is an abstract class for
 * dialects management.
 */
abstract class Dialect
{
	/**
	 * A list of supported dialects by their names
	 *
	 * @var array
	 */
	private static $dialects = [];

	/**
	 * A list of types => properties
	 * where properties overloads basic ones
	 *
	 * @var array
	 *
	 * [
	 *  'Person' => [
	 *      'propertyName' => [
	 *          'defaultValue' => null,
	 *          'validator'    => '',
	 *          'dialects'     => ['mastodon', 'peertube'],
	 *      ]
	 *  ]
	 * ]
	 */
	private static $definitions = [];

	/**
	 * Loaded types definitions
	 *
	 * @var array
	 */
	private static $loaded = [];


	/**
	 * Clear all dialects, definitions and loaded array
	 */
	public static function clear(): void
	{
		self::$dialects = [];
		self::$definitions = [];
		self::$loaded = [];
	}


	/**
	 * Load a dialect as an active one.
	 *
	 * @param  string $dialect Dialect name.
	 */
	public static function load(string $dialect): void
	{
		$dialects = [];

		if ($dialect === '*') {
		    $dialects = self::$dialects;
		} else {
		    $dialects[] = $dialect;
		}

		foreach ($dialects as $dialect) {
		    // Dialect does not exist
		    if (! in_array($dialect, self::$dialects)) {
		        throw new Exception(
		            "Dialect '{$dialect}' has no definition"
		        );
		    }

		    // dialect not already loaded ?
		    if (! in_array($dialect, self::$loaded)) {
		        array_push(self::$loaded, $dialect);
		    }
		}

		// Load new types
		foreach (self::$definitions as $type => $properties) {
		    foreach ($properties as $property => $definition) {
		        if (count(array_intersect($definition['dialects'], self::$loaded))) {
		            if (! TypeResolver::exists($type)) {
		                TypeResolver::addDialectType($type);
		            }
		        }
		    }
		}
	}


	/**
	 * Unload a dialect.
	 *
	 * @param string $dialect Dialect name.
	 */
	public static function unload(string $dialect): void
	{
		self::$loaded = array_filter(
		    self::$loaded,
		    static function ($value) use ($dialect): bool {
		        return $value !== $dialect
		            && $dialect !== '*';
		    }
		);

		// Unload new types
		foreach (self::$definitions as $type => $properties) {
		    foreach ($properties as $property => $definition) {
		        if (! count(array_intersect($definition['dialects'], self::$loaded))) {
		            if (TypeResolver::exists($type)) {
		                TypeResolver::removeDialectType($type);
		            }
		        }
		    }
		}
	}


	/**
	 * Add a dialect definition in the pool.
	 *
	 * @param  string $name       Dialect name.
	 * @param  array  $definition Types definitions
	 */
	public static function add(string $name, array $definition, bool $load = true): void
	{
		if (! in_array($name, self::$dialects)) {
		    array_push(self::$dialects, $name);
		}

		/* ---------------------------------------------------------
		 | Push definition into definitions
		 | --------------------------------------------------------- */
		// Extend Types properties
		foreach ($definition as $types => $properties) {
		    $xpt = explode('|', $types);
		    foreach ($xpt as $type) {
		        if (! is_array($properties)) {
		            throw new Exception(
		                "Properties for Type '{$type}' must be an array."
		                . ' Given=' . print_r($properties, true)
		            );
		        }
		        self::putType($type, $properties, $name);

		        // Define new types if needed
		        if ($load && ! TypeResolver::exists($type)) {
		            TypeResolver::addDialectType($type);
		        }
		    }
		}

		// load if needed
		if ($load && ! in_array($name, self::$loaded)) {
		    array_push(self::$loaded, $name);
		}
	}


	/**
	 * Add a type in the pool.
	 *
	 * @param  string $type Type name.
	 * @param  string $dialect Dialect name
	 */
	private static function putType(string $type, array $properties, string $dialect): void
	{
		if (! isset(self::$definitions[$type])) {
		    self::$definitions[$type] = [];
		}

		// Define a property
		foreach ($properties as $property => $config) {
		    if (is_string($config)) {
		        $property = $config;
		    }
		    self::$definitions[$type][$property] =
		        self::createProperty($type, $property, $config, $dialect);
		}
	}


	/**
	 * Transform various form of property configs into a local and
	 * exploitable property configuration.
	 *
	 * @param   string|array $config
	 * @return  array
	 */
	private static function createProperty(string $type, string $property, $config, string $dialect): array
	{
		$local = [
		    'defaultValue' => null,
		    'validator'    => null,
		    'dialects'     => [],
		];

		// Property already defined
		if (array_key_exists($property, self::$definitions[$type])) {
		    $local = self::$definitions[$type][$property];
		}

		// New dialect attachment for this property
		if (! in_array($dialect, $local['dialects'])) {
		    array_push($local['dialects'], $dialect);
		}

		$local['defaultValue'] = is_array($config) && isset($config['defaultValue'])
		    ? $config['defaultValue']
		    : null;

		// Validator should be loaded in type factory when this
		// dialect is loaded
		$local['validator'] = is_array($config) && isset($config['validator'])
		    ? $config['validator']
		    : null;

		return $local;
	}


	/**
	 * Check if there is a dialect that extends a given type
	 */
	public static function extend(AbstractObject $type): void
	{
		if (! isset(self::$definitions[$type->type])) {
		    return;
		}

		$definition = self::$definitions[$type->type];

		foreach ($definition as $property => $config) {
		    // Dialect is not loaded for this property
		    if (! count(array_intersect(self::$loaded, $config['dialects']))) {
		        continue;
		    }

		    // Extends type
		    $type->extend($property, $config['defaultValue']);

		    // @todo Loads a validator for property
		}
	}


	/**
	 * Get all loaded dialects (defined and loaded)
	 *
	 * @return array
	 */
	public static function getLoadedDialects(): array
	{
		return self::$loaded;
	}


	/**
	 * Get defined dialects (ready to load)
	 *
	 * @return array
	 */
	public static function getDialects(): array
	{
		return self::$dialects;
	}


	/**
	 * Get all defined ActivityPub Dialects definitions
	 *
	 * @return array
	 */
	public static function getDefinitions(): array
	{
		return self::$definitions;
	}
}
__halt_compiler();----SIGNATURE:----zv54xvYWKYhPQMjKC+by7BAY+ZTKbH95OQ1M1UUYcTQbRhW2DnkgLPO2/H2d7HMQhfCxXz8jEp501C9z3XwZAlnk5QUTRhbH4rLAYRcjZiX3QcnzsVovQmR4wnVPWVt9q5GZ1obnmIGOwFZFDbB2tobOxTs6WgKsTGQRonQi67gg+AWL3/TloZ9Q5PhZxLyPNNhscIjORhPthHPCBE0IHZvVwAQFVJdH5L8vR7Kv/yThiIiJHYNde2y9JQNrO/sZtak1MpzmEm8bT7Fn5muxPDpTXKiw6mZPEgktKoFr7e2maWVjItodOoijdyuR3YTv4yHwWEUpp168+DecNcWsJIEsJtwbJ2qz6Mym4OisfL2SvgwScpIzkvO6hUmdV+LAuSGjcEnwlkBEIUq4ZBmjJb149/p17e+x5NgMt0xmvlUGZDquMsJApCa3+L0MFSjNICPfgIpt1/97LLRvASsOZu44+aivBgJ/Mfm4hEuYESbPKT88LGZyKAYneVbI94SdN7LACTyPyYim04R6rG6MPn0Lv+iLVtdv6vj523c2a65O9ySJ5zEJFCB1YFrSvDZVxD+/AU5OST55qe3iWBo9yNKs3T8B6eTEq/uFSA2cxMUKWbrn4pVDcDDszUtnMH6B4aKRzExrWuUFRXjobw1wcctbIES0F7h1nGIGKOv20Zs=----ATTACHMENT:----NjUwMDAzODU3NjAzOTggMjM4ODgyOTUwODg1Mjc1MiA3MDg2NDI3ODAxMjY4MTUz