<?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()
    {
        self::$dialects = [];
        self::$definitions = [];
        self::$loaded = [];
    }

    /**
     * Load a dialect as an active one.
     *
     * @param  string $dialect Dialect name.
     */
    public static function load(string $dialect)
    {
        $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)
    {
        self::$loaded = array_filter(
            self::$loaded,
            function ($value) use ($dialect) {
                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
     * @param  bool   $load
     */
    public static function add(string $name, array $definition, bool $load = true)
    {
        // dialect not already defined ?
        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  array  $definition
     * @param  string $dialect Dialect name
     */
    private static function putType(string $type, array $properties, string $dialect)
    {
        // Type already extended ?
        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       $type
     * @param   string       $property
     * @param   string|array $config
     * @param   string       $dialect
     * @return  array
     */
    private static function createProperty(string $type, string $property, $config, string $dialect)
    {
        $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
     *
     * @param \ActivityPhp\Type\AbstractObject $type
     */
    public static function extend(AbstractObject $type)
    {
        // No extensions for this type
        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()
    {
        return self::$loaded;
    }

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

    /**
     * Get all defined ActivityPub Dialects definitions
     *
     * @return array
     */
    public static function getDefinitions()
    {
        return self::$definitions;
    }
}
__halt_compiler();----SIGNATURE:----nu9Ok3wovE8cfkzfmxlu0cendFGzOOA50ckaF6wN5NzbErTAjCr8MtZYcoA6+5+YosImBW70GZFjtMoMwLOrPg8RKm8dA6rrMcKENeA5Erj+bpaTKQw9fKDBoQ489fwRWOPh99SWGB2/L0k1SQJxqubtgMAX+NWdtfh2bnR1gTswqITf+NbYbEeIo2JzAot+H+zasV068l2JHG4BVpLfIcYiVdtck4SwxR0b8vNz6A8FE5HWNdQRHh3fDKUNh12afDau8d6cR2CdJ+5ifT6ONHDmri2QuXXKD8Y6N1Uan1t4FbEY0yUhAmHemMM2DE1PZcK0RJW4b2Xsi1ktXwjiholb9mMBbDzy2tlzsYb0FnZozqN4YRvA7CC1uprUhNjpTWd6J3kqjG3+GzK5K25Fo4Ev3HthDYYXddKYZZNdFLJ7o9qsY718JNJC6sdxkhQLWUaMKX4DLPXXVKoUIuV6ImfOJsphiQO+LWbNhGeu88Qc6lnzWBoj6AIJ0wx6WIqHZbd1K3eZyYGtooEQx7J6o6nxmQRB7rpsgR99gH21vBjiiSrqMF7nE7DFKOn7ZSryrdegTznJIt9JOEHyXKfQyQs80KcwhUHxnSLddno2VSX4wlYl9j7CfWKtlzRVI3GWNTXJRQOoKiWBwrveSQtBh69r37ojyX61GsJ4uSHyAcQ=----ATTACHMENT:----MTkyMDIwOTk5MDAwMzk1IDk3ODc0NTEwNTg3NDMwMyAxMDg1NDQ1MTYwMTQ3NzQ3