class SettingsForm

class SettingsForm extends ConfigFormBase {
    
    /**
     * The aggregator plugin managers.
     *
     * @var \Drupal\aggregator\Plugin\AggregatorPluginManager[]
     */
    protected $managers = [];
    
    /**
     * The instantiated plugin instances that have configuration forms.
     *
     * @var \Drupal\Core\Plugin\PluginFormInterface[]
     */
    protected $configurableInstances = [];
    
    /**
     * The aggregator plugin definitions.
     *
     * @var array
     */
    protected $definitions = [
        'fetcher' => [],
        'parser' => [],
        'processor' => [],
    ];
    
    /**
     * Constructs a \Drupal\aggregator\SettingsForm object.
     *
     * @param \Drupal\Core\Config\ConfigFactoryInterface $config_factory
     *   The factory for configuration objects.
     * @param \Drupal\aggregator\Plugin\AggregatorPluginManager $fetcher_manager
     *   The aggregator fetcher plugin manager.
     * @param \Drupal\aggregator\Plugin\AggregatorPluginManager $parser_manager
     *   The aggregator parser plugin manager.
     * @param \Drupal\aggregator\Plugin\AggregatorPluginManager $processor_manager
     *   The aggregator processor plugin manager.
     * @param \Drupal\Core\StringTranslation\TranslationInterface $string_translation
     *   The string translation manager.
     */
    public function __construct(ConfigFactoryInterface $config_factory, AggregatorPluginManager $fetcher_manager, AggregatorPluginManager $parser_manager, AggregatorPluginManager $processor_manager, TranslationInterface $string_translation) {
        parent::__construct($config_factory);
        $this->stringTranslation = $string_translation;
        $this->managers = [
            'fetcher' => $fetcher_manager,
            'parser' => $parser_manager,
            'processor' => $processor_manager,
        ];
        // Get all available fetcher, parser and processor definitions.
        foreach ([
            'fetcher',
            'parser',
            'processor',
        ] as $type) {
            foreach ($this->managers[$type]
                ->getDefinitions() as $id => $definition) {
                $this->definitions[$type][$id] = new FormattableMarkup('@title <span class="description">@description</span>', [
                    '@title' => $definition['title'],
                    '@description' => $definition['description'],
                ]);
            }
        }
    }
    
    /**
     * {@inheritdoc}
     */
    public static function create(ContainerInterface $container) {
        return new static($container->get('config.factory'), $container->get('plugin.manager.aggregator.fetcher'), $container->get('plugin.manager.aggregator.parser'), $container->get('plugin.manager.aggregator.processor'), $container->get('string_translation'));
    }
    
    /**
     * {@inheritdoc}
     */
    public function getFormId() {
        return 'aggregator_admin_form';
    }
    
    /**
     * {@inheritdoc}
     */
    protected function getEditableConfigNames() {
        return [
            'aggregator.settings',
        ];
    }
    
    /**
     * {@inheritdoc}
     */
    public function buildForm(array $form, FormStateInterface $form_state) {
        $config = $this->config('aggregator.settings');
        // Global aggregator settings.
        $form['aggregator_allowed_html_tags'] = [
            '#type' => 'textfield',
            '#title' => $this->t('Allowed HTML tags'),
            '#size' => 80,
            '#maxlength' => 255,
            '#default_value' => $config->get('items.allowed_html'),
            '#description' => $this->t('A space-separated list of HTML tags allowed in the content of feed items. Disallowed tags are stripped from the content.'),
        ];
        // Only show basic configuration if there are actually options.
        $basic_conf = [];
        if (count($this->definitions['fetcher']) > 1) {
            $basic_conf['aggregator_fetcher'] = [
                '#type' => 'radios',
                '#title' => $this->t('Fetcher'),
                '#description' => $this->t('Fetchers download data from an external source. Choose a fetcher suitable for the external source you would like to download from.'),
                '#options' => $this->definitions['fetcher'],
                '#default_value' => $config->get('fetcher'),
            ];
        }
        if (count($this->definitions['parser']) > 1) {
            $basic_conf['aggregator_parser'] = [
                '#type' => 'radios',
                '#title' => $this->t('Parser'),
                '#description' => $this->t('Parsers transform downloaded data into standard structures. Choose a parser suitable for the type of feeds you would like to aggregate.'),
                '#options' => $this->definitions['parser'],
                '#default_value' => $config->get('parser'),
            ];
        }
        if (count($this->definitions['processor']) > 1) {
            $basic_conf['aggregator_processors'] = [
                '#type' => 'checkboxes',
                '#title' => $this->t('Processors'),
                '#description' => $this->t('Processors act on parsed feed data, for example they store feed items. Choose the processors suitable for your task.'),
                '#options' => $this->definitions['processor'],
                '#default_value' => $config->get('processors'),
            ];
        }
        if (count($basic_conf)) {
            $form['basic_conf'] = [
                '#type' => 'details',
                '#title' => $this->t('Basic configuration'),
                '#description' => $this->t('For most aggregation tasks, the default settings are fine.'),
                '#open' => TRUE,
            ];
            $form['basic_conf'] += $basic_conf;
        }
        // Call buildConfigurationForm() on the active fetcher and parser.
        foreach ([
            'fetcher',
            'parser',
        ] as $type) {
            $active = $config->get($type);
            if (array_key_exists($active, $this->definitions[$type])) {
                $instance = $this->managers[$type]
                    ->createInstance($active);
                if ($instance instanceof PluginFormInterface) {
                    $form = $instance->buildConfigurationForm($form, $form_state);
                    // Store the instance for validate and submit handlers.
                    // Keying by ID would bring conflicts, because two instances of a
                    // different type could have the same ID.
                    $this->configurableInstances[] = $instance;
                }
            }
        }
        // Implementing processor plugins will expect an array at $form['processors'].
        $form['processors'] = [];
        // Call buildConfigurationForm() for each active processor.
        foreach ($this->definitions['processor'] as $id => $definition) {
            if (in_array($id, $config->get('processors'))) {
                $instance = $this->managers['processor']
                    ->createInstance($id);
                if ($instance instanceof PluginFormInterface) {
                    $form = $instance->buildConfigurationForm($form, $form_state);
                    // Store the instance for validate and submit handlers.
                    // Keying by ID would bring conflicts, because two instances of a
                    // different type could have the same ID.
                    $this->configurableInstances[] = $instance;
                }
            }
        }
        return parent::buildForm($form, $form_state);
    }
    
    /**
     * {@inheritdoc}
     */
    public function validateForm(array &$form, FormStateInterface $form_state) {
        parent::validateForm($form, $form_state);
        // Let active plugins validate their settings.
        foreach ($this->configurableInstances as $instance) {
            $instance->validateConfigurationForm($form, $form_state);
        }
    }
    
    /**
     * {@inheritdoc}
     */
    public function submitForm(array &$form, FormStateInterface $form_state) {
        parent::submitForm($form, $form_state);
        $config = $this->config('aggregator.settings');
        // Let active plugins save their settings.
        foreach ($this->configurableInstances as $instance) {
            $instance->submitConfigurationForm($form, $form_state);
        }
        $config->set('items.allowed_html', $form_state->getValue('aggregator_allowed_html_tags'));
        if ($form_state->hasValue('aggregator_fetcher')) {
            $config->set('fetcher', $form_state->getValue('aggregator_fetcher'));
        }
        if ($form_state->hasValue('aggregator_parser')) {
            $config->set('parser', $form_state->getValue('aggregator_parser'));
        }
        if ($form_state->hasValue('aggregator_processors')) {
            $config->set('processors', array_filter($form_state->getValue('aggregator_processors')));
        }
        $config->save();
    }

}