FrontendForms.module

<?php

/** @noinspection PhpPossiblePolymorphicInvocationInspection */
/** @noinspection PhpUndefinedFieldInspection */
/** @noinspection PhpUndefinedMethodInspection */

declare(strict_types=1);

namespace ProcessWire;

/*
 * FrontendForms module for ProcessWire to create and validate forms on the frontend
 *
 * Created by Jürgen K.
 * https://github.com/juergenweb
 * File name: FrontendForms.module
 * Created: 03.07.2022
 */

use Exception;
use FrontendForms\FormHelper;
use FrontendForms\Label;
use ReflectionFunction;
use stdClass;
use Valitron\Validator;

class FrontendForms extends WireData implements Module, ConfigurableModule
{
    // use an API path to the GitHub repository for the 100 most common passwords
    public const TOP_PASSWORDS = 'https://api.github.com/repos/danielmiessler/SecLists/contents/Passwords/Common-Credentials/2025-199_most_used_passwords.txt';
    // This url contains the commits for the passwords including the dates of the commits (used for last modification date)
    public const LAST_PASSWORDS_MODIFICATION_URL = 'https://api.github.com/repos/danielmiessler/SecLists/commits?path=/Passwords/Common-Credentials/2025-199_most_used_passwords.txt';

    public const TOP_SPAMWORDS = 'https://api.github.com/repos/splorp/wordpress-comment-blocklist/contents/blacklist.txt';

    public const LAST_SPAMWORDS_MODIFICATION_URL = 'https://api.github.com/repos/splorp/wordpress-comment-blocklist/commits?path=/blacklist.txt';

    public const SUPPORTEDMAILMODULES = ['WireMailPostmark', 'WireMailPostmarkApp', 'WireMailSmtp', 'WireMailPHPMailer']; // Supported modules for sending emails in other modules based on FrontendForms

    public static string $framework = '';
    // (temp_uploadPath removed - mail attachment staging now uses WireTempDir, see WireMail::sendAttachments hook)

    /* Password field */
    protected Field $password_field; // the system password field with the name "pass"
    protected InputfieldPassword $password_object; // an object of the InputfieldPassword

    protected string $passwordPath = ''; // path to the top 100 passwords.txt file
    protected string $default_dateformat = ''; // the default date format as set in the processwire configuration file
    protected array $passwordList = []; // array that holds all passwords from passwords.txt
    protected string $last_check = ''; // date of the last monthly check of passwords
    protected array $blacklist = []; // array of all passwords inside the blacklist as stored inside the db

    protected string $modulePath = ''; // path to this module folder
    protected string $customFrameworksPath = ''; // path to the folder, where all custom framework JSON files can be stored
    protected array $moduleConfig = []; // array that holds all module config values
    protected string $lang = 'en'; // default language

    /* Assets */
    protected string|int $input_removeJS = 0; // remove module JS or not (frontend)
    protected string|int $input_removeCSS = 0; // remove module CSS or not (frontend)

    /* Markup */
    protected object $defaultClasses; // all class names for the form
    protected string $input_requiredHintPosition = 'top'; // default position for the required text hint
    protected array $input_wrappers = []; // hold the name of the wrappers which should be removed
    protected array $input_appendLabel = []; // array which contains checkboxes and/or radios
    protected string|int $input_wrapperFormElements = 0; // add extra div over all form elements
    protected string $input_wrapperFormElementsCSSClass = ''; // the CSS class for the wrapperFormElements div
    protected string $input_framework = 'none.json'; // default framework selection
    protected string $input_descPosition = 'afterInput'; // default input field description position
    protected string|int $input_showasterisk = 1; // show asterisk on required fields
    protected string|int $input_ajaxformsubmission = 0; // submit forms via Ajax (1) or not (0)
    protected string|int $input_hideProgressBar = 0; // Hide the progressbar during form submission (1) or not (0)
    protected string $input_global_label_tag = ''; // the tag that should be used as the global tag for labels
    protected string $input_global_desc_tag = ''; // the tag that should be used as the global tag for descriptions
    protected string $input_global_notes_tag = ''; // the tag that should be used as the global tag for nots
    protected string $input_global_msg_tag = ''; // the tag that should be used as the global tag for messages (error and success message)

    /* Email configuration */
    protected string $input_emailTemplate = 'template_1.html'; // default email template
    protected array $email_template_files = []; // array containing all pathes to the email template files
    protected array $emailTemplates = []; // email template names as a numeric array
    protected string $emailTemplatesPath = ''; // path to the email templates folder
    protected string $custom_emailTemplatesPath = ''; // path to the custom email templates folder

    /* Messages */
    protected string $input_requiredText = ''; // Text that should be displayed on each form for required fields
    protected string $input_alertSuccessText = ''; // Text that should be displayed after successful submission
    protected string $input_alertErrorText = ''; // Text that should be displayed after failed submission

    /* Max attempts */
    protected string|int $input_maxAttempts = 5; // the max number of failed attempts to submit a form
    protected string|int $input_logFailedAttempts = 0; // by default, failed login attempts will not be logged

    // Time measurement
    protected string|int $input_minTime = 3; // min time before a form should be submitted
    protected string|int $input_maxTime = 3600; // max time until a form should be submitted

    /* IP blacklist */
    protected string|int $input_useIPBan = 1; // by default, IP addresses on the blacklist cannot view the forms
    protected string $input_preventIPs = ''; // These IP addresses are excluded from visiting a form in on the site

    /* CAPTCHA text settings */
    protected string $input_captchaCharset = ''; // the characters that should be used to create the random text string
    protected string|int $input_captchaHeight = 60; // the height of the captcha image
    protected string|int $input_captchaWidth = 180; // the width of the captcha image
    protected string|int $input_offset = 5; // the offset of the puzzle piece of the slider captcha
    protected string $input_captchaTextColor = ''; // the text color of the captcha image
    protected string|int $input_captchaFontsize = 20; // the font size of the captcha text
    protected string $input_captchaFontFamily = ''; // set the path to the folder where the font is located, that should be used
    protected array $input_captchaFonts = []; // array of all fonts found under the site tree
    protected string|int|null $input_charactersOffLine = 0; // set the characters off the line or in one line
    protected string|null $input_question = '';// the captcha question for the simple question captcha
    protected string|null $input_answers = '';// the possible answers

    /* CAPTCHA background */
    protected string $input_bgcolorchooser = 'random'; // use random or custom background colors
    protected string|int $input_bgnumberOfColors = 1; // the number of colors used for the background
    protected string $input_bgCustomColors = '#ddd'; // the pre-defined custom color used for the background

    /* CAPTCHA distortion lines */
    protected string|int $input_captchaNumberOfLines = 5; // the number of distortion lines over the captcha image
    protected string $input_colorchooser = 'random'; // use random or custom line colors
    protected string $input_captchaLinesColor = '#fff'; // the color of the distortion lines
    protected string|int $input_numberOfColorsOfLines = 1; // the number of colors used for the distortion lines

    /* CAPTCHA image filters */
    protected int|string $input_blurlevel = 0; // the level of the blur effect for images
    protected int|string $input_pixelatelevel = 0; // the level of the pixelate effect for images
    protected int|string|null $input_grayscale = 0; // add or remove grayscale effect

    /* CAPTCHA general */
    protected string $imagePath = ''; // the path to the directory where all captcha images are stored
    protected string $input_captchaType = 'none'; // enable or disable captcha on forms by entering the class name or none

    /* HTML5 form validation */
    protected string|int|bool $input_html5_validation = 0; // enable or disable HTML 5 form validation

    protected bool $gd_lib = false; // GD library is enabled/installed or not
    private string $stopwordPath;

    /**
     * Get all metadata for the module
     * @return array
     */
    public static function getModuleInfo(): array
    {
        return [
            'title' => 'FrontendForms',
            'summary' => 'Create forms and validate them using the Valitron library.',
            'author' => "Jürgen Kern",
            'href' => 'https://github.com/juergenweb/FrontendForms',
            'version' => '3.0.2',
            'singular' => true,
            'autoload' => true,
            'requires' => ['PHP>=8.0.0', 'ProcessWire>=3.0.194']
        ];
    }

    /**
     * Set default values for configuration fields
     * These values will be stored in the DB during the installation process
     * This is necessary to get them via getModuleConfig() without saving the configuration page after the
     * installation If the values are not stored inside the DB, they are not reachable via getModuleConfig();
     * @return array
     */
    public static function getDefaultData(): array
    {
        return [
            'input_showasterisk' => 1,
            'input_requiredHintPosition' => 'top',
            'input_wrappers' => ['inputwrapper', 'fieldwrapper'],
            'input_wrapperFormElements' => 0,
            'input_wrapperFormElementsCSSClass' => '',
            'input_removeJS' => 0,
            'input_removeCSS' => 0,
            'input_reRenderImages' => 1,
            'input_framework' => 'none.json',
            'input_customframeworkpath' => '',
            'input_descPosition' => 'afterInput',
            'input_appendLabel' => [],
            'input_ajaxformsubmission' => 0,
            'input_hideProgressBar' => 0,
            'input_emailTemplate' => 'template_1.html',
            'input_dateformat' => 'Y-m-d',
            'input_timeformat' => 'H:i a',
            'input_privacy' => '',
            'input_privacypageselect' => 'int',
            'input_maxAttempts' => 5,
            'input_minTime' => 5,
            'input_maxTime' => 3600,
            'input_useHoneypot' => 1,
            'input_logFailedAttempts' => 0,
            'input_useIPBan' => 1,
            'input_preventIPs' => '',
            'input_requiredText' => '',
            'input_alertSuccessText' => '',
            'input_alertErrorText' => '',
            'input_captchaType' => 'none',
            'input_captchaCharset' => 'abcdefghijklmnpqrstuvwxyz123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ',
            'input_captchaHeight' => 50,
            'input_captchaWidth' => 150,
            'input_offset' => 5,
            'input_question' => '',
            'input_answers' => '',
            'input_bgcolorchooser' => 'custom',
            'input_bgnumberOfColors' => 5,
            'input_bgCustomColors' => '#ddd',
            'input_captchaTextColor' => '#666',
            'input_captchaFontsize' => 20,
            'input_captchaFontFamily' => '',
            'input_captchaNumberOfLines' => '10',
            'input_colorchooser' => 'random',
            'input_captchaLinesColor' => '#fff',
            'input_numberOfColorsOfLines' => 1,
            'input_captchaNumberOfCharacters' => 4,
            'input_charactersOffLine' => 0,
            'input_blurlevel' => 0,
            'input_pixelatelevel' => 0,
            'input_grayscale' => 0,
            'input_blacklist' => '',
            'toppasswords_download' => '',
            'last_check' => '',
            'github_modified' => '',
            'topspamwords_download' => '',
            'last_stopword_check' => '',
            'spamwords_github_modified' => '',
            'input_html5_validation' => 0,
            'input_global_label_tag' => '',
            'input_global_desc_tag' => '',
            'input_global_notes_tag' => '',
            'input_global_msg_tag' => ''
        ];
    }

    /**
     * @throws WireException
     */
    public function __construct()
    {

        parent::__construct();

        // check if the GD library is installed
        $this->gd_lib = function_exists('gd_info');
        if (!$this->gd_lib) {
            $this->warning($this->_('GD library is not installed/enabled. Please install/enable it to be able to use CAPTCHA images.'));
        }

        // add the appropriate values to properties, so you can get them everywhere inside the class
        $this->modulePath = $this->wire('config')->paths->siteModules . 'FrontendForms/'; // set the relative path to this module
        $this->customFrameworksPath = $this->wire('config')->paths->assets . 'files/FrontendForms/frameworks/';
        $this->moduleConfig = $this->wire('modules')->getConfig($this);
        $this->imagePath = $this->modulePath . 'captchaimages/'; // path to the images for the CAPTCHA
        $this->passwordPath = $this->modulePath . 'data/passwords.txt'; // path to passwords.txt file
        $this->stopwordPath = $this->modulePath . 'data/stopwords.txt'; // path to stopwords.txt file
        $this->emailTemplatesPath = $this->modulePath . 'email-templates';//  set the path to the email templates folder
        $this->custom_emailTemplatesPath = $this->wire('config')->paths->site . 'frontendforms-custom-templates'; //  set the path to the custom email templates folder

        //  create and set a property of each configuration setting from DB
        foreach ($this->moduleConfig as $key => $value) {
            $this->$key = $value;
        }

        // array of all passwords in the blacklist
        if ($this->input_blacklist) {
            $this->blacklist = explode("\n", str_replace("\r", "", $this->input_blacklist));
        }

        // create a numeric array of all available email templates inside the email folder
        $this->setEmailTemplates();

        self::$framework = str_replace('.json', '', $this->input_framework);

        // set the default custom framework path
        if (array_key_exists('input_customframeworkpath', $this->moduleConfig) && ($this->moduleConfig['input_customframeworkpath'])) {
            $cp = $this->wire('config')->paths->root . $this->moduleConfig['input_customframeworkpath'];
            // add trailing slash at the end if it is missing
            if (!str_ends_with($cp, '/')) {
                $cp = $cp . '/';
            }
            $this->customFrameworksPath = $cp;
        }

        //get all classes from the currently loaded framework from the folder frameworks
        $this->defaultClasses = json_decode(file_get_contents(self::getCSSClassFile($this->input_framework, $this->customFrameworksPath)));

    }

    /**
     * Populate a select field's options with the available HTML email templates,
     * including a preview thumbnail image for each option (if one exists) and a
     * "no HTML template" option.
     * @param InputfieldSelect $select The select field to add the template options to.
     * @param bool $inherit Whether this select is for a per-form override that can
     *   inherit the module's default template setting (adds an "inherit" option
     *   showing the currently inherited template's preview image).
     * @return void
     * @throws WireException
     */
    public function createEmailTemplatesOptions(InputfieldSelect $select, bool $inherit = false): void
    {

        //  create options
        $placeholderimage = $this->wire('config')->urls->$this . 'assets/img/emailtemplate-placeholder-image.png';
        $noneimage = $this->wire('config')->urls->$this . 'assets/img/none.png';

        if ($inherit) {
            if ($this->input_emailTemplate == 'none') {
                $inheritImage = $noneimage;
            } else {
                $inheritImage = $placeholderimage;
            }
        }

        $select->addOption('none', $this->_('no HTML template'), ['data-img-src' => $noneimage]);

        foreach ($this->emailTemplates as $template) {

            $p = pathinfo($this->email_template_files[$template]);
            $absolutedir = $p['dirname'];
            // convert the absolute filesystem path to its corresponding URL -
            // works regardless of whether the template lives inside
            // /site/modules/ (bundled templates) or in the custom templates
            // folder (site/frontendforms-custom-templates/), unlike a fixed
            // strstr() search for "/site/modules" would.
            $relativedir = str_replace(
                $this->wire('config')->paths->root,
                $this->wire('config')->urls->root,
                $absolutedir
            );
            $filename = $p['filename'] . '.png';
            $previewImage = $relativedir . '/' . $filename;
            $previewPath = $absolutedir . '/' . $filename;

            if (file_exists($previewPath)) {
                $path = $previewImage;
            } else {
                $path = $placeholderimage;
            }

            if ($inherit) {
                if ($this->input_emailTemplate == $template) {
                    $inheritImage = $path;
                }
            }

            // add data-img-src for the image picker
            $select->addOption($template, $template, ['data-img-src' => $path]);
        }

        if ($inherit) {
            $select->addOption('inherit', $this->_('Inherit from FrontendForms') . '<div class="ff-email-template-selected">(' . $this->input_emailTemplate . ')</div>', ['data-img-src' => $inheritImage]);
            // re-order the array
            $allOptions = $select->getOptions();
            $newArray = array_merge(array_splice($allOptions, -1), $allOptions);
            $select->setOptions($newArray);
        }

    }

    /**
     * Create the folder for custom frameworks classes file if it does not exist
     * @return void
     * @throws WireException
     */
    /**
     * Ensure the "frameworks" folder (custom CSS class JSON files) exists
     * at its default location, restoring it from a module-internal backup
     * first if one exists.
     *
     * Uses the fixed default path (not $this->customFrameworksPath) for
     * the restore target deliberately: ___uninstall() backs up the
     * default location specifically, since a user-configured custom path
     * elsewhere on the server is outside the module's own managed file
     * structure and not something it can reliably back up/restore.
     * @return void
     * @throws WireException
     */
    protected function createCustomFrameworksFolder(): void
    {
        $defaultFrameworksPath = $this->wire('config')->paths->assets . 'files/FrontendForms/frameworks/';
        $frameworksBackup = $this->modulePath . 'assets/frameworks/';

        if ($this->wire('files')->exists($frameworksBackup)) {
            $this->createFilesDir($frameworksBackup, $defaultFrameworksPath);
        }

        // check if custom framework folder exists, otherwise create it
        // ($recursive = true: customFrameworksPath may be a nested path
        // whose parent folder doesn't exist yet)
        if (!$this->wire('files')->exists($this->customFrameworksPath)) {
            $this->wire('files')->mkdir($this->customFrameworksPath, true);
        }
    }

    /**
     * Get the path of the CSS file for the given framework
     * @param string $framework
     * @param string $customFrameworksPath
     * @return string
     * @throws WireException
     */
    public static function getCSSClassFile(string $framework, string $customFrameworksPath): string
    {
        $modulePath = wire('config')->paths->siteModules . 'FrontendForms/';
        if (wire('files')->exists($modulePath . 'frameworks/' . $framework)) {
            return $modulePath . 'frameworks/' . $framework;
        } elseif (wire('files')->exists($customFrameworksPath . $framework)) {
            return $customFrameworksPath . $framework;
        }
        // load none.json file as fallback
        return $modulePath . 'frameworks/none.json';
    }

    /**
     * Build the list of selectable mail module options for the "custom mail module"
     * config select field, containing a "None" default plus every supported mail
     * module (see SUPPORTEDMAILMODULES) that is actually installed. If both
     * WireMailPostmark and WireMailPostmarkApp are installed, they are combined
     * into a single "WireMailPostmark" entry rather than listed separately.
     * @param Modules $modules
     * @return array Associative array of module class name => display label.
     */
    public static function createMailModuleOptions(Modules $modules): array
    {
        $list = [];
        $list['none'] = __('None'); // default

        foreach (FrontendForms::SUPPORTEDMAILMODULES as $className) {
            if ($modules->getModuleID($className)) {
                $list[$className] = $className;
            }
        }

        // combine WireMailPostmark and WireMailPostmarkApp if both are installed
        $postmark = array_filter($list, function ($key) {
            return str_starts_with($key, 'WireMailPostmark');
        }, ARRAY_FILTER_USE_KEY);
        if (count($postmark) > 1) {
            foreach ($postmark as $k => $v) {
                unset($list[$k]);
            }
            $list['WireMailPostmark'] = implode('/', $postmark);
        }
        return $list;
    }

    /**
     * Get the total number of installed 3rd party mail modules, which can be used with FrontendForms
     *
     * Counts the same, already-merged list that createMailModuleOptions()
     * builds (minus its "none" entry), rather than counting
     * SUPPORTEDMAILMODULES independently - so this number always matches
     * the number of actually selectable options in the corresponding
     * dropdown, even when WireMailPostmark and WireMailPostmarkApp get
     * combined into a single option there.
     * @param Modules $modules
     * @return int
     */
    public static function getNumberOfMailModules(Modules $modules): int
    {
        $options = FrontendForms::createMailModuleOptions($modules);
        unset($options['none']);
        return count($options);
    }


    /**
     * Create an InputfieldSelect for choosing a custom mail module
     * Internal method for modules, which are based on FrontendForms
     * @param Modules $modules
     * @param Module $module
     * @return InputfieldSelect
     * @throws WirePermissionException
     */
    public static function createMailModuleInputfield(Modules $modules, Module $module): InputfieldSelect
    {

        // select if you want to use a custom mail module for sending mails or not
        $mailModuleSelect = $modules->get('InputfieldSelect');
        /** @var InputfieldSelect $mailModuleSelect */
        $mailModuleSelect->label = __('Use Custom mail module');
        $mailModuleSelect->attr('name', 'input_mailmodule');
        $mailModuleSelect->addOptions(FrontendForms::createMailModuleOptions($modules));
        $mailModuleSelect->attr('value', $module->get('input_mailmodule'));
        $mailModuleSelect->required = 1;
        $mailModuleSelect->description = __('Select your preferred module for sending mails.');
        $mailModuleSelect->notes = __('By default, all mails will be sent with WireMail, but you can select a custom module from this field for sending mails too.');
        return $mailModuleSelect;
    }


    /**
     * Get the response of a GitHub repository page by a given url
     * @param string $url
     * @return mixed - returns the JSON object
     * @throws WireException
     */
    protected function getDataFromGitHub(string $url): mixed
    {
        // add header for GitHub request to do not get a 403 response
        // Please note: GitHub only supports a certain number of requests from the same IP
        // If the maximum of requests is reached a 403 header will be displayed
        //
        // IMPORTANT: this method is called (via downloadPasswords(), and
        // also via the manual "update now" button handlers
        // blacklistButtonSubmit()/stopwordListButtonSubmit()) on a
        // Page::render hook, meaning it can run before EVERY page request
        // on the live site, not just inside the admin. An explicit, short
        // timeout is essential here - without one, a slow or unresponsive
        // GitHub could block every visitor's page load for up to PHP's
        // default_socket_timeout (60 seconds by default), effectively
        // taking the whole site down whenever the monthly check happens to
        // coincide with a GitHub outage or rate limit.
        $opts = [
            'http' => [
                'method' => 'GET',
                'header' => [
                    'User-Agent: PHP'
                ],
                'timeout' => 5,
            ]
        ];
        $response = false; // set response to false by default
        // fetch the response from the given url
        $context = stream_context_create($opts);
        $file = @file_get_contents($url, false, $context);

        if ($file) {
            $response = json_decode($file); // contains all the response data as a JSON object
        } else {
            // there was an error getting the file - write an error log

            $this->wire('log')->error('FrontendForms: failed to fetch data from GitHub URL: ' . $url);
            // inform the user with a warning message
            $this->wire('session')->warning($this->_('Sorry, but the requested file could not be downloaded from GitHub.'));
        }
        return $response;
    }

    /**
     * Method to set multi-language value to a multi-language configuration field
     * @param string $inputfield_name
     * @param object $fieldObject
     * @return void
     * @throws WireException
     */
    protected function setLanguageValue(string $inputfield_name, object $fieldObject): void
    {

        $languages = $this->wire('languages');
        if ($languages) { // check if multi-lang site
            $fieldObject->useLanguages = true;
            foreach ($languages as $language) {
                if ($language->isDefault()) {
                    $fieldObject->set('value', (string)$this->get($inputfield_name));
                } else {
                    $fieldObject->set('value' . $language->id, (string)$this->get($inputfield_name . '__' . $language->id));
                }
            }
        }
    }

    /**
     * Method to add an email template to the WireMail class
     * Will be used with the mailTemplate method from the WireMail class
     * @param WireMail $mail - the mail object of the WireMail class
     * @param string $templateName - the name of the template that should be used to render the email
     * @return WireMail
     * @throws Exception
     * @throws WireException
     */
    protected function setEmailTemplate(WireMail $mail, string $templateName): WireMail
    {
        /*
         * This is only for modules, which are based on the FrontendForms module
         * because they can inherit from this module
         */
        if ($templateName === 'inherit') {
            $templateName = $this->input_emailTemplate; //  use the template from the FrontendForms config
        }

        // Validate the resolved template name in all cases - including the
        // "inherit" case above. The inherited value is only validated once,
        // at selection time in the config dropdown, and stored persistently
        // in the DB afterwards - if the underlying template file is later
        // deleted or renamed (e.g. during a module update), that stored
        // value becomes stale. Without re-validating it here too, an
        // invalid inherited template name would silently be set on the
        // mail object instead of failing clearly and immediately.
        $customPath = false;
        if (FormHelper::checkForPath($templateName)) {
            $customPath = true;
            $path_parts = pathinfo($templateName);
            if (!file_exists($path_parts['dirname'])) {
                throw new Exception(sprintf('The directory that should contain your email template under the given path %s/ does not exist. Please check your path once more.', $path_parts['dirname']));
            }
            $this->emailTemplates = $this->wire('files')->find($path_parts['dirname'], ['extensions' => 'html']);
        } else {
            $this->setEmailTemplates();
        }

        if (!in_array($templateName, $this->emailTemplates)) {
            //  check if an email template with this name exists
            $msg = sprintf(
                'Email template with the name %s does not exist. Possible templates are: %s',
                $templateName,
                implode(', ', $this->emailTemplates)
            );
            if ($customPath) {
                $msg = sprintf(
                    'Email template under the given path %s does not exist. Possible templates are: %s',
                    $templateName,
                    implode(', ', $this->emailTemplates)
                );
            }
            throw new Exception($msg);
        }

        // add a new property to the mail class
        $mail->email_template = $templateName;
        return $mail;
    }

    /**
     * Add or remove a specific IP value from the input_preventIPs db field and return the string afterwards
     * @param bool $add
     * @throws WireException
     */
    /**
     * Add or remove an IP address to/from the ban list, based on the
     * currently submitted POST value.
     * @param bool $add True to add the submitted IP, false to remove it.
     * @return bool True if the IP was actually added/removed, false if the
     *   submitted value was invalid (add) or not found in the list (remove) -
     *   so callers can show an accurate success/failure message instead of
     *   always claiming success regardless of what actually happened.
     * @throws WireException
     */
    protected function addRemoveIpFromBanList(bool $add): bool
    {
        //create an array of strings, filtering out empty lines (e.g. from
        // an initially empty list, where explode("\n", '') would otherwise
        // produce a stray blank entry that stays in the stored value
        // permanently)
        $ipAddresses = array_filter(
            explode("\n", $this->moduleConfig['input_preventIPs']),
            static function ($value) {
                return trim($value) !== '';
            }
        );
        $success = false;
        if ($add) {
            // add the value to $ipAddresses, but only if it is a valid IP address
            $ip = $this->wire('input')->post->submit_save_ip ?? '';
            if (filter_var($ip, FILTER_VALIDATE_IP)) {
                $ipAddresses[] = $ip;
                $success = true;
            }
        } else {
            // remove the value from $ipAddresses
            $key = array_search($this->wire('input')->post->submit_remove_ip ?? '', $ipAddresses, true);
            if ($key !== false) {
                unset($ipAddresses[$key]);
                $success = true;
            }
        }
        // convert it back to a string and save it to the module configuration
        $data = $this->moduleConfig;
        $data['input_preventIPs'] = implode("\n", array_unique($ipAddresses));
        $this->input_preventIPs = $data['input_preventIPs']; // show the values inside the inputfield
        $this->wire('modules')->saveConfig($this, $data);
        return $success;
    }

    /**
     * Grab a txt file by its path and return an array of all values in it
     *
     * Uses file() with FILE_IGNORE_NEW_LINES (strips both \n and \r, so
     * Windows CRLF-saved files don't leave a stray \r on each entry) and
     * FILE_SKIP_EMPTY_LINES (so a typical trailing newline at the end of
     * the file - or any other blank line - doesn't produce a spurious
     * empty array entry). This also avoids the resource leak of manually
     * calling fopen() without a matching fclose().
     * @param string $path
     * @return array
     */
    public static function createArrayOfTxtFile(string $path): array
    {
        $listArray = @file($path, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
        return $listArray === false ? [] : $listArray;
    }

    /**
     * Grab all email template files inside the email template folder
     * Create an array of all email template file names (including the
     * file extension, e.g. "template_1.html")
     * @return void
     * @throws WireException
     */
    protected function setEmailTemplates(): void
    {
        $custom_templateFiles = $this->wire('files')->find($this->custom_emailTemplatesPath, ['extensions' => 'html']);
        $templateFiles = $this->wire('files')->find($this->emailTemplatesPath, ['extensions' => 'html']);
        // built-in templates first, custom templates last - so that when
        // both a built-in and a custom template share the same filename,
        // the custom one takes priority (overwriting the built-in path in
        // $pathes_to_files below) rather than silently being ignored in
        // favor of the built-in default.
        $files = array_merge($templateFiles, $custom_templateFiles);

        $pathes_to_files = [];
        foreach ($files as $file) {
            $pathes_to_files[pathinfo($file, PATHINFO_BASENAME)] = $file;
        }
        $this->email_template_files = $pathes_to_files;
        // derive the name list from the already-deduplicated keys above,
        // rather than building it separately from $files - otherwise a
        // template sharing its filename between the built-in and custom
        // folders would appear twice in the resulting dropdown options
        $this->emailTemplates = array_keys($pathes_to_files);
    }

    /**
     * Get the names of all email templates inside the email_templates folder without the file extension (only
     * names)
     * @return array - a numeric array of email template names
     */
    protected function getEmailTemplates(): array
    {
        return $this->emailTemplates;
    }

    /**
     * Set the language as language code (fe en, de,…)
     * Please take a look inside the lang folder which languages are available (the name of the folder is the
     * language code)
     * @param string $lang
     * @return void
     */
    public function setLang(string $lang): void
    {
        $this->lang = trim($lang);
        Validator::lang($this->lang);
    }

    /**
     * Get the name of the site profile installed by extracting the readme file inside the templates' folder
     * Created for future usage in modules based on this module
     * If pages were created by a module - the markup could be adapted to the site profile installed
     * @return string
     */
    public static function getSiteProfileName(): string
    {
        // grab the readme file if present
        $readme = wire('files')->fileGetContents(wire('config')->paths->templates . '/readme.txt');
        if ($readme) {
            //find and extract the link
            preg_match_all('!https?://\S+!', $readme, $matches);
            if (!empty($matches[0])) {
                return basename($matches[0][0]) . '.txt';
            }
        }
        return 'default.txt';
    }

    /**
     * Ready method contains all Hooks to extend the WireMail class
     * These Hooks need to be inside ready(), do not work inside init()
     * @return void
     * @throws WireException
     */
    public function ready(): void
    {

        /**
         * Add a new method "sendAttachments($form)" to the WireMail class
         * This method is an extension of the WireMail attachment() method
         * It takes the files from the given upload folder and send it with the email
         * Afterwards the files will be removed/moved or will be kept inside the given folder
         * Usage: $mail->sendAttachments();
         * $mail is the WireMail object
         */
        wire()->addHookMethod('WireMail::sendAttachments', function ($event) {

            $mail = $event->object;
            /** @var WireMail $mail */
            $form = $event->arguments(0);

            $keep_files = $event->arguments(1) && $event->arguments(1);

            // get the paths of the currently uploaded files
            $fileNames = $form->getUploadedFiles();

            if ($fileNames) {
                // isolated temp dir for this send - avoids collisions between concurrent
                // submissions (and between multiple sendAttachments() calls within the same
                // request) that a single shared temp_uploads folder would risk.
                //
                // IMPORTANT: WireTempDir removes its directory as soon as the PHP object is
                // destructed (see WireTempDir::__destruct()), not only at the actual end of
                // the request. Since $tempDir would otherwise go out of scope (and get
                // destructed) the moment this closure returns - i.e. before WireMail::send()
                // has read the attachment - we disable that auto-removal and instead keep the
                // object alive on $mail itself, so we can remove it explicitly after sending.
                $tempDir = $this->wire('files')->tempDir();
                $tempDir->setRemove(false);
                $mail->set('_ffAttachmentTempDir', $tempDir);
                $tempPath = $tempDir->get();

                foreach ($fileNames as $path) {
                    // move the files to the tmp folder
                    $file_name = pathinfo($path, PATHINFO_BASENAME);
                    $this->wire('files')->copy($path, $tempPath);
                    if ($mail->className() === 'WireMailPHPMailer') {
                        $mail->addAttachment($tempPath . $file_name);
                    } else {
                        $mail->attachment($tempPath . $file_name);
                    }
                    // save the file in addition under the upload path
                    if ($keep_files) {
                        $this->wire('files')->copy($tempPath . $file_name, $form->getUploadPath() . $file_name);
                    } else {
                        $this->wire('files')->unlink($path);
                    }
                }
            }
            $event->return = $mail;
            return $mail;
        });

        /**
         * Additional Hook method use/change the email template that should be used for sending emails
         * Add the name of the file including the extension as parameter inside the parenthesis
         * Usage: $mail->mailTemplate('template_1.html');
         */
        wire()->addHookMethod('WireMail::mailTemplate', function ($event) {
            $mail = $event->object;
            /** @var WireMail $mail */
            $mail->email_template = 'none';
            $template = $event->arguments(0);
            //  run only if a template was selected
            if ($template != 'none') {
                // check if template exists and set it to $mail->email_template property
                $this->setEmailTemplate($mail, $template);
            }
            $event->return = $mail;
            return $mail;
        });

        /**
         * add the new property "title" to WireMailClass
         * This can be used as additional information under the subject
         * $mail->title = 'My title'
         */
        wire()->addHookMethod('WireMail::title', function ($event) {
            $mail = $event->object;
            /** @var WireMail $mail */
            $title = $event->arguments(0);
            $mail['title'] = trim((string)$title);
            $event->return = $mail;
            return $mail;
        });


        /**
         * Add the FrontendComments field to an extra tab if FrontendComments field exists
         */
        wire()->addHookAfter('ProcessPageEdit::buildForm', function ($event) {

            // First check if FrontendComments fields exist
            $commentfields = $this->wire('fields')->findByType('FieldtypeFrontendComments');
            if (!$commentfields) {
                return;
            }

            // make sure we're editing a page and not a user
            if ($event->process != 'ProcessPageEdit') {
                return;
            }

            $page = $event->object->getPage();

            // get all fields of the type FrontendComments on this page
            $pageCommentFields = [];
            foreach ($commentfields as $f) {
                if ($page->hasField($f->name)) {
                    $pageCommentFields[] = $f->name;
                }
            }

            if (!$pageCommentFields) {
                return;
            } // no field of this type found

            $form = $event->return;

            $inputfields = new InputfieldWrapper();
            $inputfields->attr('title', $this->_('Comments'));
            $inputfields->attr('name+id', 'pagecommentstab'); // we need both unique ID and Name

            $pageEditTab = $form->find('id=ProcessPageEditContent')->first();
            $form->insertAfter($inputfields, $pageEditTab);

            // inserting in the right place is not enough to set the tab order
            // we need the following hook
            wire()->addHookAfter('ProcessPageEdit::getTabs', function ($event) {
                $event->return = array_merge(
                    array_slice($event->return, 0, 1, true),
                    array('pagecommentstab' => __('Comments')), // should be identical to the weird name/title above
                    array_slice($event->return, 1, null, true)
                );
            });

            // move comment fields from the content tab to the newly created comments tab
            $contentTab = $form->children->get('id=ProcessPageEditContent');
            $commentsTab = $form->children->get('id=pagecommentstab');
            foreach ($pageCommentFields as $fieldName) {
                $commentField = $contentTab->get($fieldName);
                $contentTab->remove($fieldName);
                $commentsTab->prepend($commentField);
            }

            $event->return = $form;

        });

    }


    /**
     * @throws WireException
     * Init method contains a lot of HOOK methods
     */
    public function init(): void
    {

        // Require the classloaders
        wire('classLoader')->addNamespace('Valitron', __DIR__ . '/valitron/src');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Validation');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Validation/ValidationRules');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Validation/ValidationLogic');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Validation/ValidationHelpers');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Security');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Upload');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Mail');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Steps');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Textelements');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Textelements/Defaults');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Inputelements');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Inputelements/Traits');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Miscellaneous');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Miscellaneous/defaults');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Wrapper');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Captcha');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Rendering');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Captcha/variants');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Images');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Inputelements/Datalist');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Inputelements/Inputs');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Inputelements/Inputs/defaults');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Inputelements/Select');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Inputelements/Select/defaults');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Inputelements/Textarea');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/Formelements/Inputelements/Textarea/defaults');
        wire('classLoader')->addNamespace('FrontendForms', __DIR__ . '/avatar');

        //create instance of InputfieldPassword and set the requirement settings from field "pass" to it
        $this->password_field = $this->wire('fields')->get('pass');
        $this->password_object = new InputfieldPassword();
        if (!$this->password_field->requirements) { // the password field was not saved till now, so requirements are not stored
            $this->password_field->requirements = ['letter', 'digit'];
        }

        $this->password_object->requirements = $this->password_field->requirements;
        // use the module's own configured date format (input_dateformat)
        // for all of this module's own date displays (statistics tables,
        // "last checked" dates, ...) - falling back to ProcessWire's
        // global config date format only if the module's own setting is
        // ever somehow empty. Previously this always used
        // wire('config')->dateFormat unconditionally, meaning the
        // input_dateformat admin setting had no effect at all.
        $this->default_dateformat = $this->input_dateformat ?: $this->wire('config')->dateFormat;
        $this->passwordList = self::createArrayOfTxtFile($this->passwordPath);

        // check if LanguageSupport module is installed
        if ($this->wire('modules')->isInstalled('LanguageSupport')) {
            //set language id inside a session variable for later usage in url hook
            $this->wire('session')->set('userlang', $this->wire('user')->language->id);
        }

        /**
         * Hooks for validation and sanitization of configuration values in the backend
         */
        $this->addHookBefore('InputfieldTextarea::processInput', $this, 'validateIP');
        $this->addHookBefore('InputfieldTextarea::processInput', $this, 'validateColorCodeTextarea');
        $this->addHookBefore('InputfieldText::processInput', $this, 'sanitizeColorValues');
        $this->addHookBefore('Inputfield::render', $this, 'addLinkToNotes');
        $this->addHookBefore('Page::render', $this, 'downloadPasswords');
        $this->addHookAfter('Page::render', $this, 'initializeImagePicker');
        $this->addHook('LazyCron::every4Weeks', $this, 'updateStopWordList');

        // load only in the backend
        if (isset($_SERVER['REQUEST_URI']) && str_starts_with($_SERVER['REQUEST_URI'], $this->wire('config')->urls->admin)) {

            // add CSS and JS to the backend but only on this module page
            $version = $this->getModuleInfo()['version'] . '-' . time();


            if (self::isModuleEditPage(['FrontendForms'])) {
                $this->wire('config')->styles->add($this->wire('config')->urls->{$this->className} . 'assets/css/frontendforms-backend.css?v=' . $version);
                $this->wire('config')->scripts->add($this->wire('config')->urls->{$this->className} . 'assets/js/frontendforms-backend.js?v=' . $version);
            }

            // add image picker js and CSS files to the backend (used for the email template select)

            if ((self::isModuleEditPage(['FrontendForms', 'FrontendContact', 'FrontendLoginRegister'])) || (self::isFieldEditPage(['FieldtypeFrontendComments']))) {
                $this->wire('config')->styles->add($this->wire('config')->urls->{$this->className} . 'assets/css/image-picker.css?v=' . $version);
                $this->wire('config')->scripts->add($this->wire('config')->urls->{$this->className} . 'assets/js/image-picker.min.js?v=' . $version);
            }

        }
        // add CSS and JS links to the frontend template
        $this->addHookAfter('Page::render', $this, 'addAssets', ['priority' => 999]);
        // hooks after inputfield integer render
        $this->addHookAfter('InputfieldInteger::render', $this, 'inputfieldIntegerRenderAfter');
        // outputs examples how to overwrite global settings
        $this->addHookAfter('Inputfield::render', $this, 'overwriteExamplesNotes');
        $this->addHookBefore('WireMail::send', $this, 'convertMailProperties');
        // clean up the WireTempDir used for staging mail attachments (see
        // WireMail::sendAttachments above) now that sending has actually completed
        $this->addHookAfter('WireMail::send', $this, 'removeMailAttachmentTempDir');
        // if an image captcha is selected than set the height of the image to 2/3 of the width
        $this->addHookBefore('Modules::saveConfig', $this, 'setImageHeight');
        // if an image captcha is selected than set the height of the image to 2/3 of the width
        $this->addHookBefore('Modules::saveConfig', $this, 'cleanUpBlacklist');
        // if the pass config field is saved update the blacklist
        $this->addHookAfter('Fields::saved', $this, 'updateBlacklist');

        // Hook for replacing form placeholders inside CKEditor fields
        $this->addHookAfter('Page::render', $this, 'replaceFormPlaceholders');

        // Hook for checking if update button was pressed by analyzing Post values
        $this->addHookBefore('Page::render', $this, 'blacklistButtonSubmit');
        $this->addHookBefore('Page::render', $this, 'stopwordListButtonSubmit');
        // Hook to check if a button to add an IP to the IP blacklist was submitted
        $this->addHookBefore('Page::render', $this, 'saveIPButtonSubmit');
        // Hook to check if a button to remove an IP from the IP blacklist was submitted
        $this->addHookBefore('Page::render', $this, 'removeIPButtonSubmit');
        // Hook to find all Font files
        $this->addHookBefore('Page::render', $this, 'findFontFiles');

        // Show details about the blocked IP address inside a panel
        $this->wire->addHook('/detail-view/{ip}', function () { // event variable is necessary
            // this is an admin-only panel - hide it as a 404 for anyone without module-admin permission
            if (!$this->wire('user')->hasPermission('module-admin')) {
                throw new Wire404Exception();
            }
            if ($this->wire('modules')->isInstalled('LanguageSupport')) {
                // grab current user lang from session and convert the
                // stored ID back into an actual Language object - $user
                // ->language expects a Language page, not a raw ID, so
                // assigning the ID directly here did not reliably work.
                $langId = $this->wire('session')->get('userlang');
                $language = $langId ? $this->wire('languages')->get((int) $langId) : null;
                if ($language && $language->id) {
                    $this->wire('user')->language = $language;
                }
            }
            $out = '';
            // load the detail-view template file - use an absolute,
            // reliable path (not a bare relative filename) so PHP always
            // resolves this to the exact same file regardless of the
            // current working directory, and so ProcessWire's
            // translation system correctly matches it to the textdomain
            // registered via "Find files to translate" (a CWD-dependent
            // resolution could otherwise silently mismatch the textdomain
            // and fall back to the original, untranslated English text).
            include_once('detail-view.php');
            return $out;
        });
    }

    /**
     * Update the STOP word list every 4 weeks, but only if it has
     * actually changed on GitHub since the last check - mirrors
     * downloadPasswords()'s logic exactly, just for the SPAM-word list.
     * Also updates spamwords_github_modified/topspamwords_download, the
     * same fields the "last automatic check" text in the module config
     * displays, so that text actually reflects LazyCron runs.
     * @return void
     * @throws WireException
     * @noinspection PhpUnused
     */
    public function updateStopWordList(): void
    {
        $data = $this->wire('modules')->getConfig($this);
        $data['last_stopword_check'] = $this->last_stopword_check = $this->wire('datetime')->date($this->default_dateformat);

        $github_data = $this->getDataFromGitHub(self::LAST_SPAMWORDS_MODIFICATION_URL);

        if ($github_data && isset($github_data[0]->commit->author->date)) {
            $last_update = $github_data[0]->commit->author->date;

            // only re-download if the GitHub version is actually newer
            // than what was downloaded last time - or if nothing has
            // ever been downloaded yet
            $shouldDownload = (!$this->topspamwords_download)
                || (strtotime($last_update) > strtotime($this->topspamwords_download));

            if ($shouldDownload) {
                if ($this->downloadStopwordsFromGitHub()) {
                    $data['topspamwords_download'] = $this->topspamwords_download = $this->wire('datetime')->date($this->default_dateformat);
                    $data['spamwords_github_modified'] = $this->spamwords_github_modified = $this->wire('datetime')->date(
                        $this->default_dateformat,
                        $last_update
                    );
                    $log_data = $this->wire('datetime')->date('Y-m-d H:i:s');
                } else {
                    $log_data = 'Error saving file';
                }
            } else {
                $log_data = 'No update needed - not modified on GitHub since last download';
            }
        } else {
            $log_data = 'Could not retrieve last modification date from GitHub';
        }

        $this->wire('modules')->saveConfig($this, $data);

        $log = $this->wire('log');
        /** @var WireLog $log */
        $log->save('frontendforms_updatestopwords', $log_data);
    }


    /**
     * Check if we are on the module config page
     * @param array $moduleNames
     * @return bool
     * @throws WireException
     */
    public static function isModuleEditPage(array $moduleNames): bool
    {
        $currentURL = wire('input')->url(['withQueryString' => true]);
        $queryStrings = parse_url($currentURL, PHP_URL_QUERY);
        if ($queryStrings) {
            // find the "name=..." parameter specifically, regardless of
            // its position in the query string - previously this always
            // took the first parameter, which incorrectly assumed "name"
            // is always first. If some other parameter (e.g. a tab or
            // anchor-style param) came first instead, the comparison
            // against getModuleEditUrl() below would never match, even
            // when actually on the correct module edit page.
            $queryStringsArray = explode('&', $queryStrings);
            $nameQueryString = $queryStringsArray[0];
            foreach ($queryStringsArray as $param) {
                if (str_starts_with($param, 'name=')) {
                    $nameQueryString = $param;
                    break;
                }
            }
            $currentURL = str_replace($queryStrings, $nameQueryString, $currentURL);
        }
        $currentURL = self::normalizeAdminUrl($currentURL);

        foreach ($moduleNames as $name) {
            $modulePageEditUrl = self::normalizeAdminUrl(wire('modules')->getModuleEditUrl($name, false));
            if ($modulePageEditUrl === $currentURL) {
                return true;
            }
        }
        return false;
    }

    /**
     * Normalize an admin URL for reliable comparison in isModuleEditPage()
     * and isFieldEditPage().
     *
     * Confirmed via live-server testing: wire('input')->url() can return
     * a trailing slash before the query string (e.g.
     * ".../edit/?name=FrontendForms"), while
     * Modules::getModuleEditUrl()/Field::editUrl() do not (e.g.
     * ".../edit?name=FrontendForms") - or vice versa, depending on the
     * PW version/environment. Previously only one side of the comparison
     * was normalized (via a narrow, action-specific str_replace()), so
     * the two could still end up in different, non-matching forms
     * depending on which side actually had the trailing slash on a given
     * server. Stripping any slash immediately before "?" from BOTH sides
     * here guarantees they're always compared in the same form.
     * @param string $url
     * @return string
     */
    protected static function normalizeAdminUrl(string $url): string
    {
        return str_replace('/?', '?', $url);
    }

    /**
     * Check if we are on the field edit page of a certain Fieldtype
     * @param array $fieldTypes
     * @return bool
     * @throws WireException
     */
    public static function isFieldEditPage(array $fieldTypes): bool
    {
        $currentURL = wire('input')->url(['withQueryString' => true]);
        $queryStrings = parse_url($currentURL, PHP_URL_QUERY);
        if ($queryStrings) {
            // find the "id=..." parameter specifically, regardless of its
            // position or any other extra query parameters present (e.g.
            // "modal=1" when a field is opened in a modal window) - a
            // strict full-string comparison against editUrl() below would
            // otherwise fail to match on the correct field edit page
            // whenever any such extra parameter is present. Same
            // reasoning as the fix applied to isModuleEditPage().
            $queryStringsArray = explode('&', $queryStrings);
            $idQueryString = $queryStringsArray[0];
            foreach ($queryStringsArray as $param) {
                if (str_starts_with($param, 'id=')) {
                    $idQueryString = $param;
                    break;
                }
            }
            $currentURL = str_replace($queryStrings, $idQueryString, $currentURL);
        }
        $currentURL = self::normalizeAdminUrl($currentURL);

        foreach ($fieldTypes as $type) {
            $fields = wire('fields')->findByType($type);
            foreach ($fields as $field) {
                $editURL = self::normalizeAdminUrl($field->editUrl());
                if ($editURL === $currentURL) {
                    return true;
                }
            }
        }
        return false;
    }


    /**
     * Set the height of the image to 2/3 of the width if an image CAPTCHA was selected
     * This is necessary because the images are in 3/2 format
     * @param HookEvent $event
     * @return void
     * @noinspection PhpUnused
     */
    protected function setImageHeight(HookEvent $event): void
    {
        $class = $event->arguments(0);
        $data = $event->arguments(1);
        // run only on FrontendForms module - Modules::saveConfig is a
        // global hook point that fires for every module's config save,
        // not just this one, so without this check any other module
        // that happens to also have a matching input_captchaType field
        // would have its config data incorrectly modified too.
        if ($class == 'FrontendForms' && isset($data['input_captchaType']) && $data['input_captchaType'] === 'DefaultImageCaptcha') {
            $data['input_captchaHeight'] = (int)($data['input_captchaWidth'] * 2 / 3);
        }
        $event->arguments(1, $data);
    }

    /**
     * Add values from the top 100 passwords which fulfill the password requirements to the blacklist
     * Parameter "overwrite" is only there for future purposes, at the moment it is not used
     * @param bool $overwrite
     * @return string - the list of the passwords as a string separated by \n
     * @throws WireException
     */
    protected function addPopularPasswords(bool $overwrite = false): string
    {
        //grab current blacklist data
        if ($overwrite) {
            // old data will be deleted and only the values from the list of the top 100 will be used
            $blacklist = implode("\n", $this->passwordList);
        } else {
            // Relying on array_unique()'s default $flags (SORT_STRING) here
            // is essential, not incidental: passing SORT_REGULAR instead
            // would compare numeric-looking strings as numbers, which
            // would incorrectly treat e.g. "123456" and "0123456" as
            // duplicates and silently drop one of them - even though they
            // are different password strings and "123456" in particular
            // is a genuinely common weak password that should stay
            // blacklisted.
            $blacklist = array_unique(array_merge($this->blacklist, $this->passwordList));
        }
        // save the list
        $data = $this->moduleConfig;
        $data['input_blacklist'] = $this->cleanUpPasswordList($blacklist);
        // save the current date and time of the list update
        $data['last_check'] = $this->wire('datetime')->date($this->default_dateformat);
        $this->wire('modules')->saveConfig($this, $data);
        return $data['input_blacklist'];
    }

    /**
     * Takes a list of passwords from a textarea separated by \n and removes all passwords that
     * do not fulfill the requirements
     * @param string|array $data
     * @return string
     */
    protected function cleanUpPasswordList(string|array $data): string
    {
        if (is_string($data)) {
            $data = explode("\n", $data);
        }
        // filter out empty array values if present (only genuinely empty/
        // whitespace-only entries - not every "falsy" value, since a
        // password consisting of just "0" is a real, non-empty entry that
        // array_filter() without a callback would incorrectly drop)
        $passwords = array_filter($data, static function ($value) {
            return trim((string) $value) !== '';
        });
        foreach ($passwords as $key => $password) {
            $password = str_replace(['.', ' ', "\n", "\t", "\r"], '', $password);
            if (!$this->password_object->isValidPassword($password)) {
                unset($passwords[$key]);
            } else {
                $passwords[$key] = $password;
            }
        }
        // let us remove double entries if present
        $passwords = array_unique($passwords);
        $this->password_object->getErrors(true); // suppress error messages in backend
        // convert it back to a string
        return implode("\n", $passwords);
    }

    /**
     * Remove all forbidden passwords, which do not fulfill the requirements of passwords as set in the config
     * The goal is to keep the password list as short as possible
     * Passwords which do not fulfill the requirements do not need to check against the blacklist
     * BTW all duplicates (if present) will also be removed
     * @param HookEvent $event
     * @return void
     * @noinspection PhpUnused
     */
    protected function cleanUpBlacklist(HookEvent $event): void
    {
        $class = $event->arguments(0);
        $data = $event->arguments(1);
        // run only on FrontendForms module
        if ($class == 'FrontendForms') {
            if (is_array($data) && isset($data['input_blacklist'])) {
                $data['input_blacklist'] = $this->cleanUpPasswordList($data['input_blacklist']);
            }
        }
        $event->arguments(1, $data);
    }

    /**
     * Check whether the current request is allowed to submit changes to the
     * FrontendForms module configuration (password blacklist / IP blacklist
     * buttons). Requires a user with the "module-admin" permission on the
     * module's own edit page with a valid CSRF token, since these actions
     * are hooked onto Page::render and would otherwise run unauthenticated
     * on every page of the site.
     * @return bool
     * @throws WireException
     */
    protected function isAuthorizedConfigSubmit(): bool
    {
        if (!$this->wire('user')->hasPermission('module-admin')) {
            return false;
        }
        if (!self::isModuleEditPage(['FrontendForms'])) {
            return false;
        }
        return $this->wire('session')->CSRF->hasValidToken();
    }


    /**
     * Hook method to add passwords from the passwords.txt file to the blacklist if
     * the update blacklist button was submitted manually
     * @return void
     * @throws WireException
     * @noinspection PhpUnused
     */
    protected function blacklistButtonSubmit(): void
    {
        // check if blacklist update button was submitted
        if ($this->wire('input')->post->submit_save_passwordblacklist) {
            if (!$this->isAuthorizedConfigSubmit()) {
                return;
            }
            $this->input_blacklist = $this->addPopularPasswords();
            $message = $this->_('The password blacklist has been updated manually.');
            $this->wire->message($message);
            $this->wire('session')->setFor($this, 'scrollToField', 'ff-password-changes');
            $this->wire('session')->setFor($this, 'popupMessage', $message);
        }
    }

    /**
     * Hook method to manually re-download the stopwords.txt (SPAM word)
     * file from GitHub if the update button was submitted manually.
     * Mirrors blacklistButtonSubmit() exactly, just downloading the
     * SPAM-word file directly (via downloadStopwordsFromGitHub()) rather
     * than re-merging an already-downloaded local file into a textarea,
     * since the request here is specifically to freshly re-download
     * stopwords.txt on demand.
     * @return void
     * @throws WireException
     * @noinspection PhpUnused
     */
    protected function stopwordListButtonSubmit(): void
    {
        // check if the stopword list update button was submitted
        if ($this->wire('input')->post->submit_save_stopwordlist) {
            if (!$this->isAuthorizedConfigSubmit()) {
                return;
            }
            $data = $this->wire('modules')->getConfig($this);
            $data['last_stopword_check'] = $this->last_stopword_check = $this->wire('datetime')->date($this->default_dateformat);

            if ($this->downloadStopwordsFromGitHub()) {
                $data['topspamwords_download'] = $this->topspamwords_download = $this->wire('datetime')->date($this->default_dateformat);

                $github_data = $this->getDataFromGitHub(self::LAST_SPAMWORDS_MODIFICATION_URL);
                if ($github_data && isset($github_data[0]->commit->author->date)) {
                    $data['spamwords_github_modified'] = $this->spamwords_github_modified = $this->wire('datetime')->date(
                        $this->default_dateformat,
                        $github_data[0]->commit->author->date
                    );
                }

                $this->wire('modules')->saveConfig($this, $data);
                $message = $this->_('The SPAM word list has been updated manually.');
                $this->wire->message($message);
                $this->wire('session')->setFor($this, 'scrollToField', 'ff-stopword-changes');
                $this->wire('session')->setFor($this, 'popupMessage', $message);
            } else {
                $this->wire('modules')->saveConfig($this, $data);
                $this->wire->warning($this->_('Sorry, the SPAM word list could not be downloaded from GitHub. Please try again later.'));
            }
        }
    }

    /**
     * Check if a save button for adding IP address to the blacklist was submitted
     * If yes, then save this IP address to the blacklist of banned IP addresses
     * @return void
     * @throws WireException
     * @noinspection PhpUnused
     */
    protected function saveIPButtonSubmit(): void
    {
        // check if a save ip to blacklist button was submitted
        if ($this->wire('input')->post->submit_save_ip) {
            if (!$this->isAuthorizedConfigSubmit()) {
                return;
            }
            if ($this->addRemoveIpFromBanList(true)) {
                $this->wire->message(sprintf(
                    $this->_('The IP address %s was added to the IP blacklist.'),
                    $this->wire('input')->post->submit_save_ip
                ));
            } else {
                $this->wire->warning(sprintf(
                    $this->_('The IP address %s is not a valid IP address and was not added to the IP blacklist.'),
                    $this->wire('input')->post->submit_save_ip
                ));
            }
        }
    }

    /**
     * Check if a save button for removing an IP address from the blacklist was submitted
     * If yes, this IP address will be removed from the blacklist of banned IP addresses
     * @return void
     * @throws WireException
     * @noinspection PhpUnused
     */
    protected function removeIPButtonSubmit(): void
    {
        // check if a save ip to blacklist button was submitted
        if ($this->wire('input')->post->submit_remove_ip) {
            if (!$this->isAuthorizedConfigSubmit()) {
                return;
            }
            if ($this->addRemoveIpFromBanList(false)) {
                $this->wire->message(sprintf(
                    $this->_('The IP address %s was removed from the IP blacklist.'),
                    $this->wire('input')->post->submit_remove_ip
                ));
            } else {
                $this->wire->warning(sprintf(
                    $this->_('The IP address %s was not found in the IP blacklist and could not be removed.'),
                    $this->wire('input')->post->submit_remove_ip
                ));
            }
        }
    }

    /**
     * Find all ttf fonts across the whole site and save the names and paths to the input_captcha_fonts property
     * @return void
     * @throws WireException
     * @noinspection PhpUnused
     */
    protected function findFontFiles(): void
    {
        if ($this->wire('input')->post->input_submit_refreshFonts_frontendforms) {
            if (!$this->isAuthorizedConfigSubmit()) {
                return;
            }
            $data = $this->moduleConfig;
            $data['input_captchaFonts'] = $this->findAllFontfiles();
            $this->input_captchaFonts = $data['input_captchaFonts'];
            if ($this->wire('modules')->saveConfig($this, $data)) {
                $message = $this->_('The website has been searched for new fonts.');
                $this->wire->message($message);
                // flag for initializeImagePicker() to scroll to the font
                // family field on the next page render, so the admin
                // lands right where the newly found fonts are selectable
                // instead of having to scroll/search for the field again
                $this->wire('session')->setFor($this, 'scrollToField', 'wrap_Inputfield_input_captchaFontFamily');
                $this->wire('session')->setFor($this, 'popupMessage', $message);
            }
        }
    }

    /**
     * Update blacklist if field pass was saved
     * @param HookEvent $event
     * @return void
     * @throws WireException
     * @noinspection PhpUnused
     */
    protected function updateBlacklist(HookEvent $event): void
    {
        $field = $event->arguments(0);
        if ($field->name == 'pass') {
            //set the requirements
            $this->password_object = new InputfieldPassword();
            $this->password_object->requirements = $field->requirements;
            $this->addPopularPasswords();
            $this->wire('session')->message($this->_('Blacklist of passwords from the module FrontendForms was updated'));
        }
    }

    /**
     * Sanitize textarea that there is only on item in one line and return the cleaned array
     * @param string|null $value
     * @return array
     */
    protected function sanitizeMultilineTextarea(string|null $value): array
    {
        if ($value != null) {
            // create an array of string with separator \n
            $items = explode("\n", $value);
            $value = [];
            foreach ($items as $item) {
                $value[] = trim(explode(" ", $item)[0]);
            }
            return $value;
        }
        return [];
    }

    /**
     * Sanitize and validate all IP addresses to be unique inside the textarea input_preventIPs
     * @param HookEvent $event
     * @return void
     * @noinspection PhpUnused
     */
    protected function validateIP(HookEvent $event): void
    {
        if ($event->object->name == 'input_preventIPs') {
            $value = $event->arguments(0);
            // sanitize all values first
            $dataArray = $this->sanitizeMultilineTextarea($value[$event->object->name]);
            //validate if all array items contain a valid IP address
            foreach ($dataArray as $key => $ip) {
                if (!filter_var($ip, FILTER_VALIDATE_IP)) {
                    $this->wire->error(sprintf(
                        $this->_('%s is not a valid IP address and has therefore been deleted.'),
                        $ip
                    ));
                    unset($dataArray[$key]);
                }
            }
            // convert it back to string separated by \n
            $dataArray = implode("\n", array_unique($dataArray));
            $value->input_preventIPs = $dataArray;
            $event->arguments(0, $value);
        }
    }

    /**
     * Validate, if value is a valid HEX color code
     * @param HookEvent $event
     * @return void
     * @noinspection PhpUnused
     */
    protected function validateColorCodeTextarea(HookEvent $event): void
    {
        $inputfields = ['input_captchaLinesColor', 'input_bgCustomColors'];
        $fieldname = $event->object->name;
        if (in_array($fieldname, $inputfields)) {
            $value = $event->arguments(0);
            if ($value != null) {
                // sanitize all values first
                $dataArray = $this->sanitizeMultilineTextarea($value[$event->object->name]);
                //validate if all array items contain a valid HEX code
                foreach ($dataArray as $key => $item) {
                    if (!self::checkHex($item)) {
                        $this->wire->error(sprintf(
                            $this->_('%s is not a valid color code and has therefore been deleted.'),
                            $item
                        ));
                        unset($dataArray[$key]);
                    }
                }
                // create string from an array again
                $dataArray = implode("\n", $dataArray);
                $value->{$fieldname} = $dataArray;
                $event->arguments(0, $value);
            }
        }
    }

    /**
     * Check if the value is a valid HEX code
     * @param string $hex
     * @return bool
     */
    public static function checkHex(string $hex): bool
    {
        // Hash prefix is optional.
        $hex = ltrim($hex, '#');
        $length = strlen($hex);
        $valid = ($length === 3 || $length === 6);
        // Must be a valid hex value.
        return $valid && ctype_xdigit($hex);
    }

    /**
     * Sanitize all color values if they are valid HEX code
     * @param HookEvent $event
     * @return void
     * @noinspection PhpUnused
     */
    protected function sanitizeColorValues(HookEvent $event): void
    {
        $fieldNames = ['input_captchaTextColor'];
        $fields = $event->arguments(0);
        foreach ($fieldNames as $name) {
            $value = $fields->$name;
            if (($value) && !(self::checkHex($value))) {
                $defaultColor = $this->getDefaultData()[$name];
                $this->wire->error(sprintf(
                    $this->_('The color code %s does not correspond to a valid color code in HEX format and has therefore been reset to the default value %s.'),
                    $value,
                    $defaultColor
                ));
                // set the color code back to the default value
                $fields->$name = $defaultColor;
                $event->arguments(0, $fields);
            }
        }
    }

    /**
     * Method to add HTML links to field notes
     * @param HookEvent $event
     * @return void
     * @noinspection PhpUnused
     */
    protected function addLinkToNotes(HookEvent $event): void
    {
        $field = $event->object;
        /** @var Inputfield $field */
        if (!in_array($field->name, ['input_dateformat', 'input_timeformat'])) {
            return;
        }
        $field->entityEncodeText = false;

        switch ($field->name) {
            case ('input_dateformat'):
                $notes = sprintf(
                    $this->_('Enter a date format in PHP dateformat syntax (fe Y-m-d). %s'),
                    '<a href="https://www.php.net/manual/en/datetime.format.php" target="_blank" rel="noopener noreferrer" title="Link opens in a new tab">Read more...</a><br>'
                );
                $field->notes = $notes . sprintf($this->_(' The default format is %s'), 'Y-m-d');
                break;
            case ('input_timeformat'):
                $notes = sprintf(
                    $this->_('Enter a time format in PHP dateformat syntax (fe H:i:s). %s'),
                    '<a href="https://www.php.net/manual/en/datetime.format.php" target="_blank" rel="noopener noreferrer" title="Link opens in a new tab">Read more...</a><br>'
                );
                $field->notes = $notes . sprintf($this->_(' The default format is %s'), 'H:i a');
                break;
        }
    }

    /**
     * Request GitHub, download the passwords.txt file and save it to the
     * module's data folder
     * @return bool - true if download was successful, otherwise false
     * @throws WireException
     */
    protected function downloadPasswordsFromGitHub(): bool
    {

        $filedata = $this->getDataFromGitHub(self::TOP_PASSWORDS); //load JSON data from the txt.file
        if (!is_object($filedata) || empty($filedata->download_url)) {
            return false;
        }

        //get content of the file from GitHub - using a direct,
        // explicitly timeout-protected call rather than
        // WireFileTools::fileGetContents(), whose internal timeout
        // behavior isn't something this code can rely on. This method can
        // run before every page request (via the Page::render hook in
        // downloadPasswords()), so a hanging request here would be just as
        // serious as the one fixed in getDataFromGitHub().
        $context = stream_context_create([
            'http' => [
                'method' => 'GET',
                'header' => [
                    'User-Agent: PHP'
                ],
                'timeout' => 5,
            ]
        ]);
        $download_content = @file_get_contents($filedata->download_url, false, $context);

        if (!$download_content || !$this->isPlausibleTextListContent($download_content, 1024 * 1024)) {
            return false;
        }
        // create or overwrite existing file passwords.txt
        return (bool)($this->wire('files')->filePutContents($this->passwordPath, $download_content));
    }

    /**
     * Request GitHub, download the stopwords.txt (SPAM word) file and
     * save it to the module's data folder. Mirrors
     * downloadPasswordsFromGitHub() exactly, using the same
     * timeout-protected direct download and defense-in-depth content
     * check, just against the SPAM-word list source and stopwordPath
     * instead.
     * @return bool - true if download was successful, otherwise false
     * @throws WireException
     */
    protected function downloadStopwordsFromGitHub(): bool
    {
        $filedata = $this->getDataFromGitHub(self::TOP_SPAMWORDS); //load JSON data from the txt.file
        if (!is_object($filedata) || empty($filedata->download_url)) {
            return false;
        }

        $context = stream_context_create([
            'http' => [
                'method' => 'GET',
                'header' => [
                    'User-Agent: PHP'
                ],
                'timeout' => 5,
            ]
        ]);
        $download_content = @file_get_contents($filedata->download_url, false, $context);

        // the SPAM-word list is a community-maintained list with tens of
        // thousands of entries (unlike the small top-100-ish password
        // list), so it gets a considerably larger plausible-size ceiling
        // - 10 MB is still far more generous than the list has ever
        // actually needed, while still catching genuinely implausible
        // responses.
        if (!$download_content || !$this->isPlausibleTextListContent($download_content, 10 * 1024 * 1024)) {
            return false;
        }
        // create or overwrite existing file stopwords.txt
        return (bool)($this->wire('files')->filePutContents($this->stopwordPath, $download_content));
    }

    /**
     * Defense-in-depth sanity check for content downloaded from GitHub
     * before it gets saved to a local file (passwords.txt / stopwords.txt).
     * This is not currently a direct code-execution path (the file is
     * saved with a .txt extension and is only ever read line-by-line via
     * file(), never include()'d), but validating the content anyway
     * guards against the file's usage ever-changing in the future, or a
     * misconfigured server that executes .txt files as PHP.
     * @param string $content
     * @param int $maxBytes Maximum plausible size for this particular
     *   list - a top-100-ish password list should be tiny, while a
     *   community-maintained spam-word list can legitimately be much
     *   larger (tens of thousands of entries).
     * @return bool True if the content looks like a plausible plain-text
     *   word list, false if it should be rejected.
     */
    protected function isPlausibleTextListContent(string $content, int $maxBytes): bool
    {
        if (strlen($content) > $maxBytes) {
            return false;
        }
        // reject content containing PHP/script open tags or a null byte -
        // a plain-text word list should never legitimately contain these
        if (str_contains($content, '<?php') || str_contains($content, '<?=') || str_contains($content, '<script') || str_contains($content, "\0")) {
            return false;
        }
        // reject content that isn't valid UTF-8 / doesn't look like plain
        // text (a real word list is just newline-separated entries)
        if (!mb_check_encoding($content, 'UTF-8')) {
            return false;
        }
        return true;
    }


    /**
     * Request GitHub once a month and download the top 100 passwords if file has been changed since the last
     * download To prevent downloading the whole list on every page request, the download will be taken only once
     * per month The download will be started only if the file passwords.txt does not exist inside or the file was
     * modified on GitHub
     * @return void
     * @throws WireException
     * @noinspection PhpUnused
     */
    protected function downloadPasswords(): void
    {
        $data = $this->wire('modules')->getConfig($this);

        // let us check some conditions if it is necessary to update the passwords
        if ($this->wire('files')->exists($this->passwordPath)) {

            // check if the last check was in the same month or not (only for automated downloads - not for manual downloads)
            $check = $this->wire('datetime')->date('Y-m', $this->last_check) != $this->wire('datetime')->date('Y-m');
            $manualDownload = (bool) $this->wire('input')->post->submit_save_passwordblacklist;

            if ($check || $manualDownload) {

                // save the check date to the database
                $this->last_check = $data['last_check'] = $this->wire('datetime')->date($this->default_dateformat);
                // grab data from GitHub
                $github_data = $this->getDataFromGitHub(self::LAST_PASSWORDS_MODIFICATION_URL); //load JSON data from the file
                if ($github_data && isset($github_data[0]->commit->author->date)) {
                    $last_update = $github_data[0]->commit->author->date; // last modification date on GitHub
                    // a manual download always re-downloads, regardless of
                    // whether the GitHub version is newer than the last
                    // download - an automated (monthly) check only
                    // downloads if it actually is newer
                    $shouldDownload = $manualDownload
                        || (!$this->toppasswords_download)
                        || (strtotime($last_update) > strtotime($this->toppasswords_download));

                    if ($shouldDownload && $this->downloadPasswordsFromGitHub()) {
                        $this->toppasswords_download = $data['toppasswords_download'] = $this->wire('datetime')->date($this->default_dateformat);
                        $this->github_modified = $data['github_modified'] = $this->wire('datetime')->date($this->default_dateformat, $last_update);
                    }
                }
                $this->wire('modules')->saveConfig($this, $data);
            }
        } else {
            // in the rare case that the file does not exist (fe accidentally deleted) - download it once more
            if ($this->downloadPasswordsFromGitHub()) {
                $data['toppasswords_download'] = $this->wire('datetime')->date($this->default_dateformat);
                $this->wire('modules')->saveConfig($this, $data);
            }
        }
    }

    /**
     * Page::render hook (admin only) that initializes the jQuery "imagepicker"
     * plugin on select fields carrying the "ff-imagepicker" class, so options
     * are rendered as clickable image thumbnails rather than plain text.
     * Runs only on the module's own edit page and the FieldtypeFrontendComments
     * field edit page, where such select fields (e.g. the email template
     * picker) actually appear.
     * @param HookEvent $event
     * @return void
     * @throws WireException
     * @noinspection PhpUnused
     */
    protected function initializeImagePicker(HookEvent $event): void
    {
        $page = $event->object;
        /** @var Page $page */
        // don't add this to frontend pages
        if ($page->template->name !== 'admin') {
            return;
        }
        if ((self::isModuleEditPage(['FrontendForms', 'FrontendContact', 'FrontendLoginRegister'])) || (self::isFieldEditPage(['FieldtypeFrontendComments']))) {
            $initialize = '<script>$("select.ff-imagepicker").imagepicker({show_label  : true})</script>';
            $event->return = str_replace('</body>', $initialize . '</body>', $event->return);

            // Translatable text for the "unsaved changes" confirmation
            // dialog shown by guardActionButtons() in
            // frontendforms-backend.js, passed via data attributes rather
            // than hardcoded in the JS file so it goes through
            // ProcessWire's translation system.
            $discardWarning = $this->_('There are unsaved changes in this form. If you continue, these changes will be lost, since this action only saves the related settings. Please save your changes first, or choose "Continue" to discard them.');
            $continueLabel = $this->_('Continue');
            $cancelLabel = $this->_('Cancel');
            $okLabel = $this->_('OK');
            $event->return = preg_replace(
                '/<body\b/',
                '<body'
                . ' data-ff-discard-warning="' . htmlspecialchars($discardWarning, ENT_QUOTES, 'UTF-8') . '"'
                . ' data-ff-btn-continue="' . htmlspecialchars($continueLabel, ENT_QUOTES, 'UTF-8') . '"'
                . ' data-ff-btn-cancel="' . htmlspecialchars($cancelLabel, ENT_QUOTES, 'UTF-8') . '"'
                . ' data-ff-btn-ok="' . htmlspecialchars($okLabel, ENT_QUOTES, 'UTF-8') . '"',
                $event->return,
                1
            );
        }

        // if a manual action just completed that should draw attention to
        // a specific element (see findFontFiles(), blacklistButtonSubmit(),
        // stopwordListButtonSubmit()), flag that element's id for
        // scrollToFlaggedField() in frontendforms-backend.js to reveal and
        // scroll to on this page load, so the admin lands right where the
        // relevant setting is instead of having to scroll/search for it
        // again. The session flag is removed immediately so this only
        // happens once, right after the action, not on every subsequent
        // visit to this page.
        $scrollToElementId = $this->wire('session')->getFor($this, 'scrollToField');
        if ($scrollToElementId) {
            $this->wire('session')->removeFor($this, 'scrollToField');
            $event->return = preg_replace(
                '/<body\b/',
                '<body data-ff-scroll-to="' . htmlspecialchars($scrollToElementId, ENT_QUOTES, 'UTF-8') . '"',
                $event->return,
                1
            );
        }

        // if a manual action just completed and set a message (see
        // blacklistButtonSubmit()), show that same message again as a
        // Vex popup dialog, in addition to the regular PW notice, so it's
        // harder to miss.
        $popupMessage = $this->wire('session')->getFor($this, 'popupMessage');
        if ($popupMessage) {
            $this->wire('session')->removeFor($this, 'popupMessage');
            $event->return = preg_replace(
                '/<body\b/',
                '<body data-ff-popup-message="' . htmlspecialchars($popupMessage, ENT_QUOTES, 'UTF-8') . '"',
                $event->return,
                1
            );
        }
    }

    /**
     * Remove the WireTempDir used for staging mail attachments (if any) now that
     * WireMail::send() has actually completed. See WireMail::sendAttachments hook
     * in ready(), where the temp dir is created with setRemove(false) and stored
     * on the mail object so it survives until this point.
     * @param HookEvent $event
     * @return void
     * @noinspection PhpUnused
     */
    protected function removeMailAttachmentTempDir(HookEvent $event): void
    {
        $mail = $event->object;
        /** @var WireMail $mail */
        $tempDir = $mail->get('_ffAttachmentTempDir');
        if ($tempDir) {
            $tempDir->remove();
        }
    }

    /**
     * @param HookEvent $event
     * @return void
     * @noinspection PhpUnused
     */
    protected function convertMailProperties(HookEvent $event): void
    {
        $mail = $event->object;
        /** @var WireMail $mail */
        $className = $mail->className();

        if ($className === 'WireMailPHPMailer') {
            if ($mail['bodyHTML']) {
                $mail->Body = $mail['bodyHTML'];
            }
        }
    }

    /**
     * Internal method to create additional texts under the notes
     * Consist of a default text, followed by the code example
     * @param array $methods
     * @return string
     */
    protected function createAdditionalNotesText(array $methods): string
    {
        // create singular/plural default text
        $text = $this->_n(
            $this->_('This can be overwritten on the form by using this method'),
            $this->_('This can be overwritten on the form by using these methods'),
            count($methods)
        );
        $methodsMarkup = [];
        foreach ($methods as $method) {
            $methodsMarkup[] = '<b>' . $method . '</b>';
        }
        $methodText = implode('<br>', $methodsMarkup);
        return '<pre>' . $text . ':<br>' . $methodText . '</pre>';
    }

    /**
     * Array that holds all examples on how to overwrite global setting on per form base
     * These examples will be displayed under the input fields in the module configuration
     * @param HookEvent $event
     * @return void
     * @noinspection PhpUnused
     */
    protected function overwriteExamplesNotes(HookEvent $event): void
    {
        $field = $event->object;
        /** @var Inputfield $field */
        $fields = [
            'input_minTime' => ['$form->setMinTime(3);'],
            'input_maxTime' => ['$form->setMaxTime(600);'],
            'input_maxAttempts' => ['$form->setMaxAttempts(4);'],
            'input_logFailedAttempts' => ['$form->logFailedAttempts(false); // true, false'],
            'input_requiredHintPosition' => ['$form->setRequiredTextPosition("bottom"); // top, bottom, none'],
            'input_requiredText' => ['$form->setRequiredText("This is my custom text");'],
            'input_alertSuccessText' => ['$form->setSuccessMsg("All is good");'],
            'input_alertErrorText' => ['$form->setErrorMsg("Something went wrong");'],
            'input_wrappers' => [
                '$form->useInputWrapper(true); // true, false',
                '$form->useFieldWrapper(false); // true, false'
            ],
            'input_wrapperFormElements' => ['$form->useFormElementsWrapper(true); // true, false'],
            'input_wrapperFormElementsCSSClass' => ['$form->getFormElementsWrapper()->removeAttribute("class")->setAttribute("class", "myClass");'],
            'input_appendLabel' => [
                '$form->appendLabelOnCheckboxes(true); // true, false',
                '$form->appendLabelOnRadios(true); // true, false'
            ],
            'input_descPosition' => [
                '$form->setDescPosition("beforeLabel"); // beforeLabel, afterLabel, afterInput (overwrite on per form base)',
                '$myField->setDescription("My field description")->setPosition("beforeLabel"); // beforeLabel, afterLabel, afterInput (overwrite on per field base)',
            ],
            'input_ajaxformsubmission' => ['$form->useAjax(true); // true, false'],
            'input_hideProgressBar' => ['$form->showProgressbar(true); // true, false'],
            'input_emailTemplate' => ['$mail->mailTemplate("template_2.html"); // has to be added to the WireMail object not to the form'],
            'input_useIPBan' => ['$form->useIPBan(false); // true, false',],
            'input_preventIPs' => [
                '$form->useIPBan(false); // true, false',
                '$form->testIPBan("146.70.36.200"); // ' . $this->_('Use this method to test, if IP ban works. Enter the IP address that should be tested.') . '<br>' .
                $this->_('This method is only for testing purposes, so do not forget to remove it afterwards.')
            ],
            'input_useHoneypot' => ['$form->useHoneypot(true); // true,false'],
            'input_captchaType' => ['$form->disableCaptcha();'],
            'input_html5_validation' => ['$form->setHtml5Validation(true); // true,false'],
            'input_question' => ['$form->setSecurityQuestion("What color is green?", ["green", "color green", "it is green"]); // first parameter is the question'],
            'input_answers' => ['$form->setSecurityQuestion("What color is green?", ["green", "color green", "it is green"]); // second parameter are the answers'],
            'input_global_label_tag' => ['$form->setLabelTag("div");'],
            'input_global_desc_tag' => ['$form->setDescriptionTag("div");'],
            'input_global_notes_tag' => ['$form->setNotesTag("div");'],
            'input_global_msg_tag' => ['$form->setMessageTag("div");'],
            'input_removeCSS' => ['$form->useCSS(false); // true or false'],
            'input_removeJS' => ['$form->useJS(false); // true or false']
        ];
        if (!array_key_exists($field->name, $fields)) {
            return;
        }
        $field->entityEncodeText = false;
        $field->notes .= $this->createAdditionalNotesText($fields[$field->name]);
    }

    /**
     * Add the module JavaScript and CSS file to the frontend
     * JS files will be added before the closing body tag
     * CSS files are added before the closing head tag
     * @param HookEvent $event
     * @return void
     * @throws WireException
     * @noinspection PhpUnused
     */
    protected function addAssets(HookEvent $event): void
    {
        $page = $event->object;
        /** @var Page $page */
        // don't add this to the admin pages
        if ($page->template->name === 'admin') {
            return;
        }

        // add js variables as translatable strings to the head section if slider captcha is selected
        // inject them only if the page contains at least 1 form or the page is selected in the module config
        //
        // Real bug found and fixed: this used to also require $this->input_captchaType (the
        // SITE-WIDE module setting) to equal "SliderCaptcha" - but $page->sliderCaptcha is already
        // set by Form::applySliderCaptchaPageFlag() based on each individual FORM's own resolved
        // captcha type (which honors any per-form/per-field override, e.g. FrontendComments'
        // "input_fc_captcha"), independently of the site-wide default. Requiring the site-wide
        // setting on top of that meant: if the site-wide default was anything other than
        // "SliderCaptcha", a form that itself resolved to "SliderCaptcha" via such an override never
        // got its slider variables/JS injected at all, even though $page->sliderCaptcha correctly
        // said it needed them - the slider rendered but was completely inert. $page->sliderCaptcha
        // alone is already the correct, precise signal.
        if (!is_null($page->ff_forms)) {
            if ($page->sliderCaptcha) {
                $sliderdata = [
                    'barText' => $this->_('Slide right to fill'),
                    'loadingText' => $this->_('Loading'),
                    'failedText' => $this->_('Try again!'),
                    'offset' => $this->input_offset
                ];
                $script = '<script>let slidertexts = ' . json_encode($sliderdata) . ';</script>';

                $event->return = str_replace('</head>', $script . '</head>', $event->return);
            }
        }

        $version = $this->getModuleInfo()['version'];
        if ((!is_null($page->ff_forms)) && (!$this->input_removeJS || $page->useJS)) {

            $js = '';
            // check if at field conditions are used inside this form, if so add the JavaScript file to the page
            if ($page->field_conditions) {
                $js = '<script src="' . $this->wire('config')->urls->$this . 'assets/js/mf-conditional-fields.min.js?v=' . $version . '"></script>' . PHP_EOL;
            }

            // set the asterisk as JS constant, because it could be changed via Hook
            // will be used to add it via JS to conditional required input fields
            $label = new Label();
            $asterisk = $label->renderAsterisk();
            $js .= '<script>const asterisk = \'' . $asterisk . '\';</script>' . PHP_EOL;
            $js .= '<script src="' . $this->wire('config')->urls->$this . 'assets/js/frontendforms-frontend.min.js?v=' . $version . '" defer></script>' . PHP_EOL;

            // load slidercaptcha.js only if this captcha type is selected
            // Same fix as above: rely solely on $page->sliderCaptcha, which already reflects the
            // actually resolved captcha type of every form rendered on this page, regardless of the
            // site-wide "input_captchaType" default.
            if ($page->sliderCaptcha) {
                $js .= '<script src="' . $this->wire('config')->urls->$this . 'assets/js/frontendforms-slidercaptcha.min.js?v=' . $version . '" defer></script>' . PHP_EOL;
            }

            if (array_filter($page->useJS)) {
                $event->return = str_replace('</body>', $js . PHP_EOL . '</body>', $event->return);
            }

        }

        if ((!is_null($page->ff_forms)) && (!$this->input_removeCSS || $page->useCSS)) {

            $css = '<link rel="stylesheet" type="text/css" href="' . $this->wire('config')->urls->$this . 'assets/css/frontendforms-frontend.min.css?v=' . $version . '">' . PHP_EOL;

            if (!is_null($page->ff_forms) && array_filter($page->useCSS)) {
                $event->return = str_replace('</head>', $css . PHP_EOL . '</head>', $event->return);
            }

        }

        $modules = $this->wire('modules');

        if ($modules->isInstalled('FieldtypeFrontendComments')) {

            // get all comment fields
            $fields = $this->wire('fields')->findByType('FieldtypeFrontendComments');
            if (count($fields) == 0) {
                return;
            }

            // check if the given comment fields have JS and CSS enabled
            $commentFieldJS = [];
            $commentFieldCSS = [];
            $commentFieldStars = [];

            foreach ($fields as $field) {

                $cssPropName = 'useCommentCSS' . $field->name;
                $jsPropName = 'useCommentJS' . $field->name;
                $starsPropName = 'useCommentStars' . $field->name;

                if ($page->hasField($field->name)) {

                    // Remove all JS
                    if (!array_key_exists('input_removeFrontendCommentsJS', $field->data)) {
                        $commentFieldJS[$field->name] = 1;
                    }
                    if (!is_null($page->$jsPropName)) { // overwrite it
                        $commentFieldJS[$field->name] = $page->$jsPropName;
                    }

                    // Remove all CSS
                    if (!array_key_exists('input_removeFrontendCommentsCSS', $field->data)) {
                        $commentFieldCSS[$field->name] = 1;
                    }
                    if (!is_null($page->$cssPropName)) { // overwrite it
                        $commentFieldCSS[$field->name] = $page->$cssPropName;
                    }

                    // Remove star rating CSS and JS
                    if ($field->data['input_fc_stars']) {
                        $commentFieldStars[$field->name] = 1;
                    }
                    if (!is_null($page->$starsPropName)) { // overwrite it
                        $commentFieldStars[$field->name] = $page->$starsPropName;
                    }
                }
            }

            // url to FrontendComments asset folder
            $url = $this->wire('config')->urls->get('FieldtypeFrontendComments') . 'assets/';

            // get module version
            $moduleVersion = $this->wire('modules')->getModuleInfo('FieldtypeFrontendComments')['version'];

            // add CSS files to the frontend if at least one comment field has CSS enabled
            if (in_array(1, $commentFieldCSS)) {

                // add main CSS file
                $css = '<link rel="stylesheet" type="text/css" href="' . $url . 'frontendcommentsmain.css?v=' . $moduleVersion . '">' . PHP_EOL;

                // check which markup/framework is enabled
                $framework = $this->moduleConfig['input_framework'];

                // check if CSS file exists for the given framework setting
                $frameworkName = pathinfo($framework, PATHINFO_FILENAME);
                $pathToCSSFile = $this->wire('config')->paths->siteModules . 'FrontendComments/assets/';
                if (file_exists($pathToCSSFile . 'frontendcomments' . $frameworkName . '.css')) {
                    // add CSS file
                    $css .= '<link rel="stylesheet" type="text/css" href="' . $url . 'frontendcomments' . $frameworkName . '.css?v=' . $moduleVersion . '">' . PHP_EOL;
                }

                // add star rating CSS to the frontend if enabled
                if (in_array(1, $commentFieldStars)) {

                    $css .= '<link rel="stylesheet" type="text/css" href="' . $url . 'star-rating.css?v=' . $moduleVersion . '">' . PHP_EOL;
                }


                $event->return = str_replace('</head>', $css . PHP_EOL . '</head>', $event->return);

            }


            // add JS files to the frontend if at least one comment field has JS enabled
            if (in_array(1, $commentFieldJS)) {

                // add main JS file
                $js = '<script>let loadingAlertText = "' . $this->_('The reply form could not be loaded due to an error.') . '"</script>' . PHP_EOL;
                $js .= '<script src="' . $url . 'frontendcomments.js?v=' . $moduleVersion . '"></script>' . PHP_EOL;

                // add star rating JS to the frontend if enabled
                if (in_array(1, $commentFieldStars)) {

                    $js .= '<script src="' . $url . 'star-rating.min.js?v=' . $moduleVersion . ' "></script>' . PHP_EOL;
                    $js .= '<script>' . PHP_EOL;
                    $js .= '/** @noinspection JSUnresolvedReference */' . PHP_EOL;
                    $js .= "let stars = new StarRating('.fcm-star-rating');" . PHP_EOL;
                    $js .= '</script>' . PHP_EOL;
                }

                $event->return = str_replace('</body>', $js . PHP_EOL . '</body>', $event->return);
            }

        }
    }

    /**
     * Normalize paths for string comparison
     * This is a typical Windows problem. PHP provides paths differently depending on the source
     * This function makes paths equal under Windows and Linux
     * @param string $path
     * @return string
     */
    private function normalizePath(string $path): string
    {
        return rtrim(str_replace('\\', '/', $path), '/');
    }

    /**
     * Page::render hook that scans the rendered page content for
     * {{formname}} (or {{formname__2}}, {{formname__3}}, ... for repeated
     * occurrences of the same form) placeholders and replaces each one with
     * the output of a matching, developer-defined PHP function of the same
     * name, if one exists inside a file under site/templates/. This allows
     * editors to insert a form anywhere in a CKEditor/textarea field simply
     * by typing the placeholder, without needing direct template access.
     * Does not run on admin pages.
     * @param HookEvent $event
     * @return void
     * @throws WireException
     * @noinspection PhpUnused
     */
    protected function replaceFormPlaceholders(HookEvent $event): void
    {
        $page = $event->object;
        /** @var Page $page */

        // don't run on admin pages
        if ($page->template->name === 'admin') {
            return;
        }

        $content = $event->return;
        // find all ckeditor fields on the page and run the code only on that fields
        $template = $page->template;
        // get the namespace of the template file
        $namespace = $template->ns;
        // get all fields of the template
        $fields = $template->fieldgroup;

        // Initialize the temporary "found forms" tracking array once per
        // page render, before iterating fields - not inside the loop
        // below. Page::data($key, $value) is a setter (not a "get with
        // default"), so calling it inside the loop would unconditionally
        // reset the tracking array on every matching field, causing the
        // same {{formname}} placeholder used in multiple CKEditor/textarea
        // fields on the same page to incorrectly receive duplicate
        // numbering (e.g. both getting __1) instead of incrementing
        // correctly across fields (__1, __2, ...).
        if ($page->data('found-forms') === null) {
            $page->data('found-forms', []);
        }

        foreach ($fields as $field) {

            if (($field->type == 'FieldtypeTextarea' || $field->type == 'FieldtypeTextareaLanguage') && ($field->contentType == 1)) {

                // Find forms with or without surrounding <p> inside body
                $findFormsRegex = '/(<p>\s*)?{{([a-zA-Z0-9_-]+)}}(\s*<\/p>)?/';

                // Do the search and Replace
                $content = preg_replace_callback(
                /**
                 * @throws WireException
                 */
                    $findFormsRegex,
                    function ($matches) use ($page, $event, $namespace) {

                        // This is where the magic happens
                        $formFullName = strtolower($matches[2]);

                        $out = '';

                        // Figure out form name and iteration, if exists
                        $formNameParts = explode('__', $formFullName);
                        $formName = $formNameParts[0];
                        $formCount = $formNameParts[1] ?? 1;

                        // Get form number on the page
                        $formCount = $formCount ?? 1;

                        // Get the array of existing form names from temp page variable
                        $foundForms = $page->data('found-forms');

                        // Increment form number if form name was already found before and exists in the temp found forms array
                        while (in_array($formName . '__' . $formCount, $foundForms)) {
                            $formCount++;
                        }

                        // Generate form name with new incremented number
                        $formNameCount = $formName . '__' . $formCount;

                        // Include new form name in the list of existing forms
                        $foundForms[] = $formNameCount;

                        // Push to the global page variable
                        $page->data('found-forms', $foundForms);

                        // Create the dynamic function name (with or without a namespace
                        if ($namespace) {
                            $functionName = $namespace . '\\' . $formName;
                        } else {
                            $functionName = $formName;
                        }

                        // check if a function with this name exists
                        if (function_exists($functionName)) {
                            // security check: only call functions that are actually
                            // defined in a PHP file (this alone excludes every internal/
                            // compiled PHP core function like exec(), system(), phpinfo(),
                            // etc. - they have no file of their own) AND whose file lives
                            // inside site/templates/, the conventional location for
                            // developer-defined form-rendering functions. Without this,
                            // a page editor could trigger arbitrary global PHP functions
                            // (including dangerous ones) just by typing a matching
                            // {{functionname}} placeholder into a textarea/CKEditor field.
                            $reflection = new ReflectionFunction($functionName);
                            $functionFile = $reflection->getFileName();
                            $functionFile = $this->normalizePath($functionFile);
                            $templatesPath = (string) $this->wire('config')->paths->templates;
                            $templatesPath = $this->normalizePath($templatesPath);
                            if ($functionFile !== false && str_starts_with($functionFile, $templatesPath)) {
                                $out .= $functionName($formNameCount);
                            }

                        }
                        return $out;
                    },
                    $content
                );
            }
        }

        $event->return = $content;
    }

    /**
     * Method for a hook to add a unit after a label
     * @param HookEvent $event
     * @param string $fieldname
     * @param string $unit
     * @return void
     */
    public static function addUnitToLabel(HookEvent $event, string $fieldname, string $unit): void
    {
        $inputfield = $event->object;
        /** @var Inputfield $inputfield */
        if ($inputfield->name === $fieldname) {
            $input = $event->return;
            $event->return = '<div id="label-' . $inputfield->name . '" class="fieldlabel">' . $input . ' ' . $unit . '</div>';
        }
    }

    /**
     * Add the appropriate label text next to the input fields of type integer
     * @param HookEvent $event
     * @return void
     * @noinspection PhpUnused
     */
    protected function inputfieldIntegerRenderAfter(HookEvent $event): void
    {
        self::addUnitToLabel($event, 'input_minTime', $this->_('Seconds'));
        self::addUnitToLabel($event, 'input_maxTime', $this->_('Seconds'));
        self::addUnitToLabel($event, 'input_captchaWidth', 'px');
        self::addUnitToLabel($event, 'input_offset', 'px');
        self::addUnitToLabel($event, 'input_captchaHeight', 'px');
        self::addUnitToLabel($event, 'input_captchaFontsize', 'px');
        self::addUnitToLabel($event, 'input_maxAttempts', $this->_('Attempts'));
        self::addUnitToLabel($event, 'input_bgnumberOfColors', $this->_('Colors'));
        self::addUnitToLabel($event, 'input_numberOfColorsOfLines', $this->_('Colors'));
        self::addUnitToLabel($event, 'input_captchaNumberOfLines', $this->_('Lines'));
    }

    /**
     * Get various information about an IP address from ip-api.com
     * @param string $ip
     * @return stdClass|null - returns a json-decoded object, or null if the
     *     lookup failed (network error) or the response was not valid JSON
     */
    public static function getIPData(string $ip): ?stdClass
    {
        // Deliberately HTTP, not HTTPS: ip-api.com's free endpoint (used
        // here, without an API key) does not support SSL at all -
        // "256-bit SSL encryption is not available for this free API" per
        // their own documentation (https://ip-api.com/). Their paid Pro
        // tier is required for HTTPS access. Switching this to https://
        // would make every request fail outright.
        $iptolocation = 'http://ip-api.com/json/' . $ip;
        $location = @file_get_contents($iptolocation);
        if ($location === false) {
            return null;
        }
        $data = json_decode($location);
        return ($data instanceof stdClass) ? $data : null;
    }

    /**
     * Resolve the current user's admin theme class name (or the site-wide
     * default, if the user hasn't chosen one).
     *
     * Used by code that runs outside of ProcessWire's normal
     * admin-template page lifecycle (e.g. the /detail-view/{ip} URL-hook
     * route), where wire('adminTheme') is never populated - see
     * detail-view.php for the full explanation.
     * @return string The admin theme class name, or an empty string if none could be resolved.
     * @throws WireException
     * @noinspection PhpUnused
     */
    protected function getActiveAdminThemeClass(): string
    {
        return (string) ($this->wire('user')->admin_theme ?: $this->wire('config')->defaultAdminTheme);
    }

    /**
     * Check whether the current user's admin theme (or the site-wide
     * default) is Uikit-based.
     * @return bool
     * @throws WireException
     */
    protected function isUikitAdminThemeActive(): bool
    {
        $themeClass = $this->getActiveAdminThemeClass();
        return $themeClass !== '' && str_contains($themeClass, 'Uikit');
    }

    /**
     * Render a link to domaintools.com for further information about the IP address
     * @param string $ip
     * @return string
     * @throws Wire404Exception
     * @throws WireException
     * @throws WirePermissionException
     * @noinspection PhpUnused
     */
    protected function executeWhoisLookUp(string $ip): string
    {
        $whoislookup = '<div id="linkwrapper">';

        $button = $this->wire('modules')->get('InputfieldButton');

        $button->name = 'external_link';
        $button->value = sprintf(
            $this->_('More detailed information about the IP %s at www.domaintools.com'),
            $ip
        );
        $button->attr('onclick', "window.open('https://whois.domaintools.com/$ip', '_blank');");

        $whoislookup .= $button->render();

        $whoislookup .= '</div>';
        return $whoislookup;
    }


    /**
     * Render a detail view table for a given IP address inside the panel
     * @param string $ip
     * @return string
     * @throws WireException
     * @throws WirePermissionException
     * @noinspection PhpUnused
     */
    protected function executeViewDetailsTable(string $ip): string
    {
        $logs = $this->wire('log')->getEntries('failed-attempts-frontendforms');
        $headline = '<h2>' . sprintf($this->_('Failed attempts for IP %s'), $ip) . '</h2>';

        $table = $this->wire('modules')->get('MarkupAdminDataTable');
        $table->setEncodeEntities(false);
        // AdminThemeUikit normally adds Uikit-compatible table markup via
        // its own hook on MarkupAdminDataTable::render() - but that hook
        // is only registered while AdminThemeUikit's own bootstrap runs,
        // which skips itself outside of admin-template pages. This
        // /detail-view/{ip} URL-hook route is never an admin-template
        // page, so that hook never fires here. Adding the standard Uikit
        // table classes directly ensures the table looks right in that
        // case - but only when the current user's admin theme (or the
        // site-wide default, if the user hasn't chosen one) actually is
        // Uikit-based; otherwise these classes would just be inert,
        // unused markup for that user.
        if ($this->isUikitAdminThemeActive()) {
            $table->addClass('uk-table uk-table-divider uk-table-small uk-table-justify uk-table-striped');
        }
        $table->headerRow([
            $this->_('Date'),
            $this->_('URL'),
            $this->_('Form-ID')
        ]);

        foreach ($logs as $log) {
            $text = json_decode($log['text']);
            // skip log entries that aren't valid JSON, rather than
            // attempting to read a property off of null
            if (!$text) {
                continue;
            }
            // grab only log with the given IP
            if ($text->IP == $ip) {
                $urlLink = '<a href="' . htmlspecialchars($log['url'], ENT_QUOTES, 'UTF-8') . '"'
                    . ' target="_blank" rel="noopener noreferrer"'
                    . ' title="' . htmlspecialchars($this->_('Opens in a new window'), ENT_QUOTES, 'UTF-8') . '">'
                    . htmlspecialchars($log['url'], ENT_QUOTES, 'UTF-8')
                    . '</a>';
                $table->row([
                    htmlspecialchars($log['date'], ENT_QUOTES, 'UTF-8'),
                    $urlLink,
                    htmlspecialchars((string) $text->FormID, ENT_QUOTES, 'UTF-8'),
                ]);
            }
        }
        return $headline . $table->render();
    }

    /**
     * @param array $data
     * @return string
     * @throws WireException
     * @throws WirePermissionException
     */
    public function ___executeTable(array $data = []): string
    {
        if ($data) {
            $table = $this->wire('modules')->get('MarkupAdminDataTable');
            $table->setEncodeEntities(false);
            $table->setSortable(false);
            $table->addClass('uk-table-middle');
            $table->headerRow([
                $this->_('IP address'),
                $this->_('User'),
                $this->_('Blacklist entry'),
                $this->_('Number of blocks'),
                $this->_('Details'),
                $this->_('Add/remove IP from blacklist'),
            ]);
            $blackListIPs = preg_split('/\r\n|\r|\n/', $this->input_preventIPs);

            // create all table rows
            foreach ($data as $ip => $entry) {
                // create a link to open panel
                $details = '';
                if (!$this->input->get('modal')) {
                    $button = $this->wire('modules')->get('InputfieldButton');
                    $button->value = $this->_('View details');
                    $button->attr('data-href', '/detail-view/' . $ip);
                    $button->addClass('pw-panel');
                    $button->setSmall();
                    $details .= $button->render();
                }

                // instantiate button object for adding the IP to the blacklist
                $button = $this->wire('modules')->get('InputfieldSubmit');
                $button->setSmall();
                $button->name = 'submit_save_ip';
                $button->setAttribute('data-from_id', 'Inputfield_submit_save_module');
                $button->value = $ip;
                if (in_array($ip, $blackListIPs)) {
                    $fa = 'fa-check';
                    // remove button
                    $button->name = 'submit_remove_ip';
                    $button->text = $this->_('Remove from blacklist');
                    $button->setSecondary();
                    $out = $button->render();
                } else {
                    // create add button
                    $button->text = $this->_('Add to blacklist');
                    $out = $button->render();
                    $fa = 'fa-times';
                }
                $table->row([
                    htmlspecialchars((string) $ip, ENT_QUOTES, 'UTF-8'),
                    htmlspecialchars((string) $entry['user'], ENT_QUOTES, 'UTF-8'),
                    '<i class="fa fa-fw ' . $fa . '"></i>',
                    $entry['count'],
                    $details,
                    $out
                ]);
            }
            return $table->render();
        } else {
            return $this->_('Sorry, but there is not data available. Please check if logging is enabled.');
        }
    }

    /**
     * Find all ttf fonts inside the project that can be used for the CAPTCHA text
     * @return array
     * @throws WireException
     */
    protected function findAllFontfiles(): array
    {

        $files = [];
        $rootPath = $this->wire('config')->paths->root;
        // absolute paths (the default for find(), no 'returnRelative'
        // option needed) - not relative ones. The saved config value
        // (input_captchaFontFamily) is later checked directly via
        // wire('files')->exists($this->frontendforms['input_captchaFontFamily'])
        // in AbstractTextCaptcha::getFontFamily(), which requires an
        // absolute path to resolve correctly. A relative path there would
        // silently fail to be found, meaning any font the admin actually
        // selected via this dropdown (other than the one set during
        // ___install(), which already used an absolute path) would never
        // actually be applied.
        $results = $this->wire('files')->find($rootPath, ['recursive' => true, 'extensions' => ['ttf']]);

        foreach ($results as $font) {
            if (!self::isFontAwesomeFile($font)) {
                $files[$font] = ucfirst(pathinfo($font, PATHINFO_BASENAME));
            }
        }
        return array_unique($files);
    }

    /**
     * Check whether a given font file path belongs to Font Awesome - icon
     * fonts don't contain glyphs for regular text characters at all, so if
     * one of these ever gets selected as the CAPTCHA font, captcha text
     * would render as empty/missing-glyph boxes for every character.
     *
     * Case-insensitive and matches both "fontawesome" and the hyphenated
     * "font-awesome" (the actual directory name ProcessWire's admin theme
     * ships it under, e.g.
     * wire/templates-admin/styles/font-awesome-6.7.2/...) - an earlier,
     * hyphen-less-only, case-sensitive check let this slip through.
     * @param string $path
     * @return bool
     */
    public static function isFontAwesomeFile(string $path): bool
    {
        return (bool) preg_match('/font-?awesome/i', $path);
    }

    /**
     * Module config
     * @param InputfieldWrapper $inputfields
     * @throws WireException
     * @throws WirePermissionException
     */
    public function getModuleConfigInputfields(InputfieldWrapper $inputfields): void
    {

        $fieldset1 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldset1->label = $this->_('Markup and styling settings for the forms');
        $fieldset1->icon = 'fa-cog';
        $fieldset1->description = $this->_('Make your global settings for the output. Most of the settings can be overwritten on per form base if needed.');
        $fieldset1->collapsed = 1;

        // Required fields settings
        $fieldsetRequired = $this->wire('modules')->get('InputfieldFieldset');
        $fieldsetRequired->label = $this->_('Settings for required fields');
        $fieldsetRequired->collapsed = 1;

        // Show asterisk on required fields
        $showasterisk = $this->wire('modules')->get('InputfieldCheckbox');
        $showasterisk->label = $this->_('Asterisk for required field');
        $showasterisk->label2 = $this->_('Add an asterisk on required fields after the label tag.');
        $showasterisk->description = $this->_('Adds a span element with an asterisk after the field label on required fields (<span class="asterisk">*</span>).');
        $showasterisk->notes = $this->_('You can also use CSS pseudo class :after to add an asterisk to the label tag. For this reason you can disable the asterisk markup.');
        $showasterisk->attr('name', 'input_showasterisk');
        $showasterisk->attr('checked', $this->input_showasterisk ? 'checked' : '');
        $fieldsetRequired->add($showasterisk, $inputfields);

        // Required hint position
        $requiredHintPosition = $this->wire('modules')->get('InputfieldRadios');
        $requiredHintPosition->attr('name', 'input_requiredHintPosition');
        $requiredHintPosition->addOptions([
            'none' => $this->_('Do not show hint for required fields'),
            'top' => $this->_('Show hint for required fields on top'),
            'bottom' => $this->_('Show hint for required fields on bottom')
        ]);
        $requiredHintPosition->defaultValue = ['top'];
        $requiredHintPosition->required = 1;
        $requiredHintPosition->attr('value', $this->input_requiredHintPosition);
        $requiredHintPosition->description = $this->_('Disable displaying of the text (none), place the text before (top) or after (bottom) the form.');
        $requiredHintPosition->label = $this->_('Enable/disable the display of the required text and set the position');
        $requiredHintPosition->notes = $this->_('Can be overwritten on each form.');
        $requiredHintPosition->columnWidth = 50;
        $fieldsetRequired->add($requiredHintPosition, $inputfields);

        // Required hint custom text
        $requiredText = wire('modules')->get('InputfieldText');
        $requiredText->name = 'input_requiredText';
        $requiredText->label = $this->_('Hint for visitors that all required fields have to be filled out');
        $requiredText->value = $this->input_requiredText;
        $reqText = $this->_('This text will be displayed on the form depending on your settings.') . ' ';
        $reqText .= $this->_('If nothing is entered, a default text will be displayed instead.');
        $requiredText->description = $reqText;
        $requiredText->notes = $this->_('Can be overwritten on each form.');
        $requiredText->useLanguages = true;
        $requiredText->showIf = "input_requiredHintPosition!=none";
        $requiredText->columnWidth = 50;
        $fieldsetRequired->add($requiredText, $inputfields);

        $fieldset1->add($fieldsetRequired, $inputfields);

        // Alert messages settings
        $fieldsetAlerts = $this->wire('modules')->get('InputfieldFieldset');
        $fieldsetAlerts->label = $this->_('Settings for messages after form submission');
        $fieldsetAlerts->collapsed = 1;

        // Success message after submission
        $alertSuccessText = $this->wire('modules')->get('InputfieldText');
        $alertSuccessText->name = 'input_alertSuccessText';
        $alertSuccessText->label = $this->_('The message after successful submission');
        $alertSuccessText->value = $this->input_alertSuccessText;
        $alertText = $this->_('This text will be displayed after a form was submitted successfully.') . ' ';
        $alertText .= $this->_('If nothing is entered, a default text will be displayed instead.');
        $alertSuccessText->description = $alertText;
        $alertSuccessText->notes = $this->_('Can be overwritten on each form.');
        $alertSuccessText->useLanguages = true;
        $fieldsetAlerts->add($alertSuccessText, $inputfields);

        // Error message after failed submission
        $alertErrorText = $this->wire('modules')->get('InputfieldText');
        $alertErrorText->name = 'input_alertErrorText';
        $alertErrorText->label = $this->_('The message after submission failed');
        $alertErrorText->value = $this->input_alertErrorText;
        $alertText = $this->_('This text will be displayed after errors on form submission.') . ' ';
        $alertText .= $this->_('If nothing is entered, a default text will be displayed instead.');
        $alertErrorText->description = $alertText;
        $alertErrorText->notes = $this->_('Can be overwritten on each form.');
        $alertErrorText->useLanguages = true;
        $fieldsetAlerts->add($alertErrorText, $inputfields);

        $fieldset1->add($fieldsetAlerts, $inputfields);

        // Markup and styling settings
        $fieldsetMarkup = $this->wire('modules')->get('InputfieldFieldset');
        $fieldsetMarkup->label = $this->_('Settings for the markup and styling of the form and the input fields');
        $fieldsetMarkup->collapsed = 1;

        // Remove wrappers from input fields
        $wrappers = $this->wire('modules')->get('InputfieldCheckboxes');
        $wrappers->label = $this->_('Add wrappers to the form fields');
        $wrappers->name = 'input_wrappers';
        $wrappers->addOption('inputwrapper', $this->_('Add wrapper div for the inputfield (input wrapper)'));
        $wrappers->addOption('fieldwrapper', $this->_('Add outer wrapper div for each formfield (field wrapper)'));
        $wrappers->value = $this->input_wrappers;
        $fieldsetMarkup->add($wrappers, $inputfields);

        // Add wrapper div after form tag to wrap all elements of the form
        $wrapperFormElements = $this->wire('modules')->get('InputfieldCheckbox');
        $wrapperFormElements->attr('name', 'input_wrapperFormElements');
        $wrapperFormElements->attr('checked', $this->input_wrapperFormElements === 1 ? 'checked' : '');
        $wrapperFormElements->label = $this->_('Add an additional wrapper div after opening and before closing form tag');
        $wrapperFormElements->label2 = $this->_('Add a wrapper div over all form elements');
        $wrapperFormElements->notes = $this->_('In some rare cases you need to wrap all form elements inside an extra wrapper div, which is between the opening and closing form tag. For this case you can add the div by checking the box.');
        $wrapperFormElements->columnWidth = 50;
        $fieldsetMarkup->add($wrapperFormElements, $inputfields);

        $wrapperFormElementsCSSClass = $this->wire('modules')->get('InputfieldText');
        $wrapperFormElementsCSSClass->attr('name', 'input_wrapperFormElementsCSSClass');
        $wrapperFormElementsCSSClass->attr('value', $this->input_wrapperFormElementsCSSClass);
        $wrapperFormElementsCSSClass->label = $this->_('Add a CSS class to to the extra wrapper div');
        $wrapperFormElementsCSSClass->notes = $this->_('By default, an unique id will be added, but if you need a special styling class, you can enter the name of the class in this field.');
        $wrapperFormElementsCSSClass->showIf = "input_wrapperFormElements=1";
        $wrapperFormElementsCSSClass->columnWidth = 50;
        $fieldsetMarkup->add($wrapperFormElementsCSSClass, $inputfields);

        // Select CSS framework
        $frameworkSelect = $this->wire('modules')->get('InputfieldSelect');
        /** @var InputfieldSelect $frameworkSelect */
        $frameworkSelect->attr('name', 'input_framework');
        $frameworkSelect->label = $this->_('Output rendering');
        $frameworkSelect->description = $this->_('Select if you want to use a framework for rendering the form or not');
        $defaultFrameWorkFiles = $this->wire('files')->find($this->modulePath . 'frameworks/', ['extensions' => 'json']);
        $customFrameworkFiles = $this->wire('files')->find($this->customFrameworksPath, ['extensions' => 'json']);
        $frameWorkFiles = array_merge($defaultFrameWorkFiles, $customFrameworkFiles);
        $key = array_search($this->modulePath . 'frameworks/none.json', $frameWorkFiles);
        if ($key !== false) {
            array_unshift($frameWorkFiles, $frameWorkFiles[$key]); // move none.json to the first position in the array
        }

        $frameWorkOptions = [];
        foreach ($frameWorkFiles as $path) {
            $label = ucwords(pathinfo($path, PATHINFO_FILENAME), ' ');
            if ($label == 'None') {
                $label = $this->_('No framework');
            }
            $frameWorkOptions[pathinfo($path, PATHINFO_BASENAME)] = $label;
        }
        // check for external frameworks under site/assets/files/Frontendforms/frameworks
        $frameworkSelect->addOptions(array_unique($frameWorkOptions));
        $frameworkSelect->attr('value', $this->input_framework);
        $frameworkSelect->required = 1;
        $fieldsetMarkup->add($frameworkSelect, $inputfields);


        //input_global_label_tag
        $customFrameworkPath = $this->wire('modules')->get('InputfieldText');
        $customFrameworkPath->attr('name', 'input_customframeworkpath');
        $customFrameworkPath->attr('value', $this->input_customframeworkpath);
        $customFrameworkPath->label = $this->_('Custom path for the CSS classes json file');
        $customFrameworkPath->description = $this->_('If you want to save your custom CSS class file in a directory other than site/assets/files/FrontendForms/frameworks/, you can enter the path to your custom directory here. Otherwise leave this field empty.');
        $notes = $this->_('Please enter the path starting with site (eg site/templates/FrontendForms/frameworks).');
        $notes .= '<br>' . sprintf($this->_('You find more information about custom CSS json files %s.'), '<a target="_blank" href="https://github.com/juergenweb/FrontendForms/blob/main/README.md#support-for-css-frameworks">here</a>');
        $customFrameworkPath->entityEncodeText = false;

        $customFrameworkPath->notes = $notes;
        $fieldsetMarkup->add($customFrameworkPath, $inputfields);

        // Append labels on checkboxes and radio buttons after input tag
        $appendLabels = $this->wire('modules')->get('InputfieldCheckboxes');
        $appendLabels->label = $this->_('Append the label after the input tag on checkboxes and radios');
        $appendLabels->description = $this->_('By default, radio and checkbox tags are wrapped by their label tag. If you want to append the label tag after the input tag, please check the appropriate box.');
        $appendLabels->notes = $this->_('Can be overwritten on each form.');
        $appendLabels->attr('name', 'input_appendLabel');
        $appendLabels->attr('value', $this->input_appendLabel);
        $appendLabels->addOption('appendcheckbox', $this->_('Append label on checkboxes'));
        $appendLabels->addOption('appendradio', $this->_('Append label on radio buttons'));
        $fieldsetMarkup->add($appendLabels, $inputfields);

        // Set global position of the input field description
        $descPosition = $this->wire('modules')->get('InputfieldSelect');
        /** @var InputfieldSelect $descPosition */
        $descPosition->label = $this->_('Set the position of the field description');
        $descPosition->description = $this->_('By default, the field description will be displayed after the input field. If you want you can display the description before or after the label too.');
        $descPosition->notes = $this->_('Can be overwritten on each form and even on each input field.');
        $descPosition->attr('name', 'input_descPosition');
        $descPosition->attr('value', $this->input_descPosition);
        $descPosition->required = 1;
        $descPosition->defaultValue = 'afterInput';
        $descPosition->addOption('beforeLabel', $this->_('Before the field label'));
        $descPosition->addOption('afterLabel', $this->_('After the field label'));
        $descPosition->addOption('afterInput', $this->_('After the input field'));
        $fieldsetMarkup->add($descPosition, $inputfields);

        //input_global_label_tag
        $globalLabelTag = $this->wire('modules')->get('InputfieldText');
        $globalLabelTag->attr('name', 'input_global_label_tag');
        $globalLabelTag->attr('value', $this->input_global_label_tag);
        $globalLabelTag->label = $this->_('Tag for the label element');
        $globalLabelTag->description = $this->_('Change the tag (p, div,..) for the label of an input field.');
        $globalLabelTag->notes = $this->_('If you are not satisfied with the tag used for this item, you can modify it according to your needs. Otherwise, leave this field blank.');
        $fieldsetMarkup->add($globalLabelTag, $inputfields);

        //input_global_desc_tag
        $globalDescTag = $this->wire('modules')->get('InputfieldText');
        $globalDescTag->attr('name', 'input_global_desc_tag');
        $globalDescTag->attr('value', $this->input_global_desc_tag);
        $globalDescTag->label = $this->_('Tag for the description element');
        $globalDescTag->description = $this->_('Change the tag (p, div,..) for the description of an input field.');
        $globalDescTag->notes = $this->_('If you are not satisfied with the tag used for this item, you can modify it according to your needs. Otherwise, leave this field blank.');
        $fieldsetMarkup->add($globalDescTag, $inputfields);

        //input_global_notes_tag
        $globalNotesTag = $this->wire('modules')->get('InputfieldText');
        $globalNotesTag->attr('name', 'input_global_notes_tag');
        $globalNotesTag->attr('value', $this->input_global_notes_tag);
        $globalNotesTag->label = $this->_('Tag for the notes element');
        $globalNotesTag->description = $this->_('Change the tag (p, div,..) for the notes of an input field.');
        $globalNotesTag->notes = $this->_('If you are not satisfied with the tag used for this item, you can modify it according to your needs. Otherwise, leave this field blank.');
        $fieldsetMarkup->add($globalNotesTag, $inputfields);

        //input_global_msg_tag
        $globalMsgTag = $this->wire('modules')->get('InputfieldText');
        $globalMsgTag->attr('name', 'input_global_msg_tag');
        $globalMsgTag->attr('value', $this->input_global_msg_tag);
        $globalMsgTag->label = $this->_('Tag for the message elements (success and error message)');
        $globalMsgTag->description = $this->_('Change the tag (p, div,..) for the messages of an input field.');
        $globalMsgTag->notes = $this->_('If you are not satisfied with the tag used for this item, you can modify it according to your needs. Otherwise, leave this field blank.');
        $fieldsetMarkup->add($globalMsgTag, $inputfields);

        $fieldsetStyle = $this->wire('modules')->get('InputfieldFieldset');
        $fieldsetStyle->label = $this->_('Custom CSS classes');
        $fieldsetStyle->collapsed = 1;// by default, this fieldset should be collapsed
        $fieldsetStyle->description = $this->_('You can overwrite each CSS class with your own class name(s). If you want to add multiple classes at the same time please separate them with a whitespace (fe class1 class2).');

        // Add your own CSS classes
        //  get all class field names as an array
        $cssClassFields = array_keys((array)$this->defaultClasses);
        $fields = [];
        foreach ($cssClassFields as $field) {
            $label = substr(str_replace('_', ' ', $field), 0, -5);
            $fields['input_' . $field] = sprintf($this->_('CSS class for the %s'), $this->_($label));
        }
        $i = 0;
        foreach ($fields as $fieldName => $label) {
            $i++;
            $fieldClass = substr($fieldName, 6);
            ${'css-' . $i} = $this->wire('modules')->get('InputfieldText');
            ${'css-' . $i}->label = $label;
            ${'css-' . $i}->attr('name', $fieldName);
            ${'css-' . $i}->attr('value', $this->$fieldName ?: '');
            if (isset($this->defaultClasses->$fieldClass)) {
                ${'css-' . $i}->notes($this->_('Current class') . ': ' . $this->defaultClasses->$fieldClass);
            }
            $fieldsetStyle->add(${'css-' . $i}, $inputfields);
        }
        $fieldsetMarkup->add($fieldsetStyle, $inputfields);
        $fieldset1->add($fieldsetMarkup, $inputfields);

        $fieldsetAssets = $this->wire('modules')->get('InputfieldFieldset');
        $fieldsetAssets->label = $this->_('Settings for stylesheets and scripts');
        $fieldsetAssets->collapsed = 1;

        // Remove JS on Frontend
        $removeJS = $this->wire('modules')->get('InputfieldCheckbox');
        $removeJS->attr('name', 'input_removeJS');
        $removeJS->attr('checked', $this->input_removeJS === 1 ? 'checked' : '');
        $removeJS->label = $this->_('Javascript setting');
        $removeJS->label2 = $this->_('Remove all module Javascript files from frontend');
        $removeJS->notes = $this->_('All JavaScript files, which will be needed for some features of the form, will added before the closing body tag on the frontend by default . You can prevent the embedding of the scripts completely by checking the box.');
        $removeJS->columnWidth = 50;
        $fieldsetAssets->add($removeJS, $inputfields);

        // Remove CSS on Frontend
        $removeCSS = $this->wire('modules')->get('InputfieldCheckbox');
        $removeCSS->attr('name', 'input_removeCSS');
        $removeCSS->attr('checked', $this->input_removeCSS === 1 ? 'checked' : '');
        $removeCSS->label = $this->_('CSS setting');
        $removeCSS->label2 = $this->_('Remove frontendforms.css from template');
        $removeCSS->notes = $this->_('A small CSS file for the forms will be added to the template by default. You can remove the embedding of the CSS file by checking the box.');
        $removeCSS->columnWidth = 50;
        $fieldsetAssets->add($removeCSS, $inputfields);

        $fieldset1->add($fieldsetAssets, $inputfields);
        $inputfields->add($fieldset1);

        $fieldset2 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldset2->label = $this->_('Ajax form submission');
        $fieldset2->collapsed = 1;
        $fieldset2->icon = 'fa-code';

        $ajaxformsubmission = $this->wire('modules')->get('InputfieldCheckbox');
        $ajaxformsubmission->attr('name', 'input_ajaxformsubmission');
        $ajaxformsubmission->attr('checked', $this->input_ajaxformsubmission == '1' ? 'checked' : '');
        $ajaxformsubmission->label = $this->_('Submit forms via Ajax');
        $ajaxformsubmission->description = $this->_('If the box is checked, every form and its form data will be submitted via Ajax. This means that there will be no page reload after submission.');
        $ajaxformsubmission->notes = $this->_('Please note, if Javascript is not enabled, the form will be submitted with page reload, but this could cause problems under certain circumstances where no page reload is necessary. If Javascript is not enabled, the user will see a warning message above the form.');

        $fieldset2->add($ajaxformsubmission, $inputfields);

        $hideProgressBar = $this->wire('modules')->get('InputfieldCheckbox');
        $hideProgressBar->attr('name', 'input_hideProgressBar');
        $hideProgressBar->attr('checked', $this->input_hideProgressBar == '1' ? 'checked' : '');
        $hideProgressBar->label = $this->_('Hide the progressbar during form submission');
        $hideProgressBar->description = $this->_('If the box is checked, the progressbar will not be displayed during the form submission via Ajax.');
        $hideProgressBar->notes = $this->_('Usually, a progressbar with a text will be displayed during the submission of a form via Ajax to inform the user that the form will be submitted. This could be helpful to users, if the submission will take a little more time.');

        $fieldset2->add($hideProgressBar, $inputfields);

        // Custom message during Ajax request
        $ajaxMsg = $this->wire('modules')->get('InputfieldText');
        $ajaxMsg->name = 'input_ajaxMsg';
        $ajaxMsg->label = $this->_('AJAX form submission info text');
        $ajaxMsg->value = $this->input_ajaxMsg;
        $ajaxMsgText = $this->_('This text will be displayed next to the progress bar during a form is submitted via AJAX.') . ' ';
        $ajaxMsgText .= $this->_('If nothing is entered, a default text will be displayed instead.');
        $ajaxMsg->description = $ajaxMsgText;
        $ajaxMsg->useLanguages = true;

        $fieldset2->add($ajaxMsg, $inputfields);

        $inputfields->add($fieldset2);

        $fieldset3 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldset3->label = $this->_('Email settings');
        $fieldset3->collapsed = 1;
        $fieldset3->icon = 'fa-envelope';


        // enter a global date format for usage of date strings in emails
        $dateFormat = $this->wire('modules')->get('InputfieldText');
        $dateFormat->label = $this->_('Date format');
        $dateFormat->attr('name', 'input_dateformat');
        if ($this->wire('modules')->isInstalled('LanguageSupport')) {
            $this->setLanguageValue('input_dateformat', $dateFormat);
        } else {
            $dateFormat->value = $this->input_dateformat;
        }
        $dateFormat->columnWidth = 50;
        $dateFormat->placeholder = $this->_('fe. Y-m-d');
        $dateFormat->description = $this->_('Enter a global date format which can be used for date strings in email templates.');
        $dateFormat->required = 1;
        $fieldset3->add($dateFormat, $inputfields);

        // enter a global time format for usage of time strings in emails
        $timeFormat = $this->wire('modules')->get('InputfieldText');
        $timeFormat->label = $this->_('Time format');
        $timeFormat->attr('name', 'input_timeformat');
        if ($this->wire('modules')->isInstalled('LanguageSupport')) {
            $this->setLanguageValue('input_timeformat', $timeFormat);
        } else {
            $timeFormat->value = $this->input_timeformat;
        }
        $timeFormat->columnWidth = 50;
        $timeFormat->placeholder = $this->_('fe. H:i');
        $timeFormat->description = $this->_('Enter a global time format which can be used for time strings in email templates.');
        $timeFormat->required = 1;
        $fieldset3->add($timeFormat, $inputfields);

        //  Select an email template or not
        if ($this->emailTemplates) {
            $emailTemplate = $this->wire('modules')->get('InputfieldSelect');
            /** @var InputfieldSelect $emailTemplate */
            $emailTemplate->label = $this->_('HTML email template setting');
            $emailTemplate->attr('name', 'input_emailTemplate');
            $emailTemplate->attr('class', 'ff-imagepicker');

            // create and add all options
            $this->createEmailTemplatesOptions($emailTemplate);

            $emailTemplate->attr('value', $this->input_emailTemplate);
            $emailTemplate->required = 1;
            $emailTemplate->description = $this->_('Choose whether you want to use the HTML template for your emails and if so, which one.');
            $emailTemplate->notes = $this->_('If you are using FrontendForms with the PW WireMail class to send emails, you can use a HTML email template by adding the mailTemplate() method to the WireMail object. Can be overwritten on each form.');
            $fieldset3->add($emailTemplate, $inputfields);
        }

        $inputfields->add($fieldset3);

        $fieldset4 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldset4->label = $this->_('Data privacy settings');
        $fieldset4->collapsed = 1;
        $fieldset4->icon = 'fa-list';

        // TODO
        $privacyPageSelect = $this->wire('modules')->get('InputfieldSelect');
        /** @var InputfieldSelect $privacyPageSelect */
        $privacyPageSelect->attr('name', 'input_privacypageselect');
        $privacyPageSelect->label = $this->_('Select the type of page that contains your privacy policy');
        $privacyPageSelect->description = $this->_('Choose whether you want to use an internal ProcessWire page or an external website as your privacy policy page.');
        $privacyPageSelect->addOption('int', $this->_('Internal ProcessWire page'));
        $privacyPageSelect->addOption('ext', $this->_('Page of an external website'));
        $privacyPageSelect->attr('value', $this->input_privacypageselect);
        $privacyPageSelect->defaultValue = 'int';
        $privacyPageSelect->required = 1;
        $fieldset4->add($privacyPageSelect, $inputfields);


        $privacyPageUrl = $this->wire('modules')->get('InputfieldUrl');
        $privacyPageUrl->attr('name', 'input_privacypageurl');
        $privacyPageUrl->label = $this->_('URL to the external page with the privacy policy');
        $privacyPageUrl->description = $this->_('Enter the URL of the page that contains your privacy policy.');
        $privacyPageUrl->attr('value', $this->input_privacypageurl);
        $privacyPageUrl->useLanguages = true;
        $privacyPageUrl->showIf = 'input_privacypageselect=ext';
        $privacyPageUrl->requiredIf = 'input_privacypageselect=ext';
        $fieldset4->add($privacyPageUrl, $inputfields);

        // Select the data privacy page
        $dataPrivacySelect = $this->wire('modules')->get('InputfieldPageAutocomplete');
        $dataPrivacySelect->attr('name', 'input_privacy');
        $dataPrivacySelect->maxSelectedItems = 1;
        $dataPrivacySelect->label = $this->_('Privacy policy page');
        $dataPrivacySelect->description = $this->_('Select the page that contains your privacy policy by entering a search term for the title of that page (e.g. privacy).');
        $dataPrivacySelect->notes = $this->_('The link to this page will be used inside the Privacy class for generating the "Accept the privacy policy" checkbox.');
        $dataPrivacySelect->attr('value', $this->input_privacy);
        $dataPrivacySelect->showIf = 'input_privacypageselect=int';
        $dataPrivacySelect->requiredIf = 'input_privacypageselect=int';
        $fieldset4->add($dataPrivacySelect, $inputfields);

        $inputfields->add($fieldset4);

        $fieldset5 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldset5->label = $this->_('Spam protection and security settings for the forms');
        $fieldset5->description = $this->_('Make your global settings for spam protection and security. Most of the settings can be overwritten on per form base if needed.');
        $fieldset5->collapsed = 1;
        $fieldset5->icon = 'fa-shield';
        $fieldset5->attr('id', 'spam');

        $fieldsetsecurity1 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldsetsecurity1->label = $this->_('Measure 1: Restrict number of failed attempts');
        $fieldsetsecurity1->collapsed = 1;
        $fieldsetsecurity1->attr('id', 'failed-attempts');

        // set max number of failed attempts
        $maxAttempts = $this->wire('modules')->get('InputfieldInteger');
        $maxAttempts->label = $this->_('Max number of failed attempts');
        $maxAttempts->description = $this->_('Please set the max number of failed attempts for submitting a form.');
        $maxAttempts->notes = $this->_('If set to 0 then this feature is disabled. After reaching the limit the user will be blocked by using a session and all browser windows have to be closed to remove the blocking.');
        $maxAttempts->attr('name', 'input_maxAttempts');
        $maxAttempts->attr('type', 'number');
        $maxAttempts->attr('value', $this->input_maxAttempts);
        $maxAttempts->attr('min', 0);
        $maxAttempts->columnWidth = 50;
        $fieldsetsecurity1->add($maxAttempts, $inputfields);

        $logFailedAttempts = $this->wire('modules')->get('InputfieldCheckbox');
        $logFailedAttempts->attr('name', 'input_logFailedAttempts');
        $logFailedAttempts->attr('checked', $this->input_logFailedAttempts == '1' ? 'checked' : '');
        $logFailedAttempts->label = $this->_('Log IPs of blocked visitors');
        $logFailedAttempts->description = $this->_('If the box is checked, an entry with the IP address of the visitor, the form id and the date will be stored in the logfiles after the visitor was blocked.');
        $logFailedAttempts->notes = $this->_('Please note, that you have to inform your users in your privacy policy, that the IP address will be stored in this case.');
        $logFailedAttempts->columnWidth = 50;
        $fieldsetsecurity1->add($logFailedAttempts, $inputfields);

        $fieldset5->add($fieldsetsecurity1, $inputfields);

        $fieldsetsecurity2 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldsetsecurity2->label = $this->_('Measure 2: Time-trap - Measuring time until form submission');
        $fieldsetsecurity2->collapsed = 1;

        // add min time in seconds
        $minTime = $this->wire('modules')->get('InputfieldInteger');
        $minTime->label = $this->_('Min time before form submission');
        $minTime->description = $this->_('Please set the min time in seconds before a form should be submitted.');
        $minTime->notes = $this->_('If set to 0 then this feature is disabled. This feature measures the time between loading and submitting a form. If it is to fast (fe a spam bot) it will lead to a form error. ');
        $minTime->attr('name', 'input_minTime');
        $minTime->attr('value', $this->input_minTime);
        $minTime->attr('min', 0);
        $minTime->attr('type', 'number');
        $minTime->columnWidth = 50;
        $fieldsetsecurity2->add($minTime, $inputfields);

        // add max time in seconds
        $maxTime = $this->wire('modules')->get('InputfieldInteger');
        $maxTime->label = $this->_('Max time until form submission');
        $maxTime->description = $this->_('Please set the max time in seconds until a form should be submitted.');
        $maxTime->notes = $this->_('If set to 0 then this feature is disabled. This feature measures the time between loading and submitting a form. If it is to slow (fe a spam bot analyzing the form) it will lead to a form error. ');
        $maxTime->attr('name', 'input_maxTime');
        $maxTime->attr('type', 'number');
        $maxTime->attr('min', 0);
        $maxTime->attr('value', $this->input_maxTime);
        $maxTime->columnWidth = 50;
        $fieldsetsecurity2->add($maxTime, $inputfields);

        $fieldset5->add($fieldsetsecurity2, $inputfields);

        $fieldsetsecurity3 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldsetsecurity3->label = $this->_('Measure 3: Honeypot field');
        $fieldsetsecurity3->collapsed = 1;

        $useHoneypot = $this->wire('modules')->get('InputfieldCheckbox');
        $useHoneypot->attr('name', 'input_useHoneypot');
        $useHoneypot->attr('checked', $this->input_useHoneypot == '1' ? 'checked' : '');
        $useHoneypot->label = $this->_('Add honeypot field to form');
        $useHoneypot->description = $this->_('If the box is checked, an invisible honeypot field for spam protection will be added to the form.');
        $useHoneypot->notes = $this->_('It is recommended to use a honeypot field. Disable this feature only if you have a good reason to do so.');
        $fieldsetsecurity3->add($useHoneypot, $inputfields);

        $fieldset5->add($fieldsetsecurity3, $inputfields);

        $fieldsetsecurity4 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldsetsecurity4->label = $this->_('Measure 4: Using IP blacklist');
        $fieldsetsecurity4->collapsed = 1;

        // Add wrapper div after form tag to wrap all elements of the form
        $useIPBan = $this->wire('modules')->get('InputfieldCheckbox');
        $useIPBan->attr('name', 'input_useIPBan');
        $useIPBan->attr('checked', $this->input_useIPBan === 1 ? 'checked' : '');
        $useIPBan->label = $this->_('Check IP of visitors');
        $useIPBan->label2 = $this->_('Enable checking of visitors IP against blacklist');
        $useIPBan->description = $this->_('You can prevent IP addresses from viewing your forms, if they might be harmful to your site. By checking/unchecking the box, you can enable/disable the checking against the blacklist.');
        $useIPBan->notes = $this->_('This only works, if there is at least 1 entry in the next input field');
        $useIPBan->columnWidth = 50;
        $fieldsetsecurity4->add($useIPBan, $inputfields);

        // prevent the following IP addresses from visiting sites of this module on the frontend
        $preventIPs = $this->wire('modules')->get('InputfieldTextarea');
        $preventIPs->attr('name', 'input_preventIPs');
        $preventIPs->label = $this->_('Blacklist of forbidden IPs');
        $preventIPs->description = $this->_('Please enter every IP address on a new line. Every visit of an IP address listed below prevents the form to be rendered on the frontend. Visitors see an alert box instead, that informs about the banned IP address.');
        $preventIPs->notes = $this->_('Tip: You can take a look at the logfile for failed login attempts and enter fe. IP addresses that appear very often. Works only if logging failed attempts is enabled.');
        $preventIPs->attr('value', $this->input_preventIPs);
        $preventIPs->showIf = "input_useIPBan=1";
        $preventIPs->columnWidth = 50;

        $fieldsetsecurity4->add($preventIPs, $inputfields);

        $fieldset5->add($fieldsetsecurity4, $inputfields);

        //CAPTCHA

        $fieldsetsecurity5 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldsetsecurity5->collapsed = 1;

        // disable this fieldset if GD lib is not enabled
        if (!$this->gd_lib) {

            $status = ' ' . $this->_('(disabled: Please enable GD lib to enable CAPTCHA support)');
        } else {
            $status = '';
        }
        $fieldsetsecurity5->label = $this->_('Measure 5: CAPTCHA') . $status;

        // show the input fields only if GD lib is enabled
        if ($this->gd_lib) {
            // BASIC-SETTINGS
            $fieldsetbasic = $this->wire('modules')->get('InputfieldFieldset');
            $fieldsetbasic->label = $this->_('Basic settings');
            $fieldsetbasic->columnWidth = 100;
            $fieldsetbasic->collapsed = 1;

            // Enable/disable CAPTCHA on forms
            $captchaType = $this->wire('modules')->get('InputfieldRadios');
            $captchaType->attr('name', 'input_captchaType');
            $captchaType->label = $this->_('Use a CAPTCHA');
            $captchaType->description = $this->_('Choose whether you want to use a CAPTCHA and if so what kind.');
            $captchaTypes = $this->wire('files')->find(
                $this->modulePath . 'Formelements/Captcha/variants/',
                ['recursive' => 0]
            );
            $captchaType->addOption('none', $this->_('No CAPTCHA'));

            foreach ($captchaTypes as $file) {
                $className = pathinfo($file, PATHINFO_FILENAME);
                $cname = 'FrontendForms\\' . $className;
                $option = new $cname();
                $captchaType->addOption($className, $option->title, ['flow' => 'up', 'tooltip' => $option->desc]);
            }

            $captchaType->attr('value', $this->input_captchaType);
            $captchaType->required = 1;
            $captchaType->notes = $this->_('Most visitors do not like CAPTCHAS, so it is recommended to use it only if you have problems with spam. If a CAPTCHA is enabled and you want to disable it on a certain form, please use the following method:');
            $width = in_array($this->input_captchaType, ['DefaultImageCaptcha', 'SliderCaptcha']) ? 50 : 33;
            $captchaType->columnWidth = $width;
            $fieldsetbasic->add($captchaType, $inputfields);

            // set the width of the captcha image (only on text CAPTCHAS)
            $captchaWidth = $this->wire('modules')->get('InputfieldInteger');
            $captchaWidth->label = $this->_('Image width');
            $captchaWidth->description = $this->_('Please enter the width of the CAPTCHA image.');
            $captchaWidth->attr('name', 'input_captchaWidth');
            $captchaWidth->attr('type', 'number');
            $captchaWidth->attr('value', $this->input_captchaWidth);
            $captchaWidth->attr('min', 10);
            $captchaWidth->attr('max', 900); // images are 900*600px, so set max width to 900px
            $width = in_array($this->input_captchaType, ['DefaultImageCaptcha', 'SliderCaptcha']) ? 50 : 33;
            $captchaWidth->columnWidth = $width;
            $captchaWidth->required = 1;
            $captchaWidth->showIf = "input_captchaType!=none|SimpleQuestionCaptcha|SliderCaptcha";
            $fieldsetbasic->add($captchaWidth, $inputfields);

            // set height of the captcha image
            $captchaHeight = $this->wire('modules')->get('InputfieldInteger');
            $captchaHeight->description = $this->_('Please enter the height of the CAPTCHA image.');
            $captchaHeight->label = $this->_('Image height');
            $captchaHeight->attr('name', 'input_captchaHeight');
            $captchaHeight->attr('type', 'number');
            $captchaHeight->attr('value', $this->input_captchaHeight);
            $captchaHeight->attr('min', 10);
            $captchaHeight->columnWidth = 33;
            $captchaHeight->requiredIf = "input_captchaType=SimpleQuestionCaptcha";
            $captchaHeight->showIf = "input_captchaType!=none|DefaultImageCaptcha|SimpleQuestionCaptcha|SliderCaptcha";
            $fieldsetbasic->add($captchaHeight, $inputfields);

            // set the offset of the puzzle piece (only on slider CAPTCHA)
            $captchaOffset = $this->wire('modules')->get('InputfieldInteger');
            $captchaOffset->label = $this->_('Offset');
            $captchaOffset->description = $this->_('Please set the offset in px for the puzzle piece.');
            $captchaOffset->notes = $this->_('The lower the value, the more precisely the puzzle piece must be placed (highest allowed value: 25)');
            $captchaOffset->attr('name', 'input_offset');
            $captchaOffset->attr('type', 'number');
            $captchaOffset->attr('value', $this->input_offset);
            $captchaOffset->attr('min', 0);
            $captchaOffset->attr('max', 25); // a max offset of 25px is allowed
            $captchaOffset->columnWidth = 50;
            $captchaOffset->required = 1;
            $captchaOffset->requiredIf = "input_captchaType=SliderCaptcha";
            $captchaOffset->showIf = "input_captchaType=SliderCaptcha";
            $fieldsetbasic->add($captchaOffset, $inputfields);

            // set the question field
            $question = $this->wire('modules')->get('InputfieldText');
            $question->description = $this->_('Please enter a simple question.');
            $question->label = $this->_('Question');
            $question->notes = $this->_('The question should be as simple as possible.');
            $question->placeholder = $this->_('For example: What color has a green apple?');
            $question->attr('name', 'input_question');
            $question->attr('value', $this->input_question);
            $question->columnWidth = 50;
            $question->useLanguages = true;
            $question->showIf = "input_captchaType=SimpleQuestionCaptcha";
            $question->required = 1;
            $question->requiredIf = "input_captchaType=SimpleQuestionCaptcha";
            $fieldsetbasic->add($question, $inputfields);

            // set the answer field
            $answers = $this->wire('modules')->get('InputfieldTextArea');
            $answers->description = $this->_('Please enter various accepted answers (each on a separate line!!).');
            $answers->label = $this->_('Accepted answers');
            $answers->notes = $this->_('You can enter as many possible answers as you want, but at least one. You do not have to pay attention to upper and lower case letters (For example: "Green" ist the same as "green").');
            $answers->placeholder = $this->_('Enter serveral answers (each on a new line) that will be accepted. For example: green, color green, is green');
            $answers->attr('name', 'input_answers');
            $answers->attr('value', $this->input_answers);
            $answers->columnWidth = 50;
            $answers->required = 1;
            $answers->requiredIf = "input_captchaType=SimpleQuestionCaptcha";
            $answers->useLanguages = true;
            $answers->showIf = "input_captchaType=SimpleQuestionCaptcha";
            $fieldsetbasic->add($answers, $inputfields);

            $fieldsetsecurity5->add($fieldsetbasic, $inputfields);

            // BACKGROUND-SETTINGS
            $fieldsetBackgroundSettings = $this->wire('modules')->get('InputfieldFieldset');
            $fieldsetBackgroundSettings->label = $this->_('Image background settings');
            $fieldsetBackgroundSettings->collapsed = 1;// by default, this fieldset should be collapsed
            $fieldsetBackgroundSettings->description = $this->_('Set the styling of the background for the CAPTCHA image.');
            $fieldsetBackgroundSettings->showIf = "input_captchaType!=none|SimpleQuestionCaptcha|DefaultImageCaptcha|SliderCaptcha";

            // Random or custom colors
            $bgcolorchooser = $this->wire('modules')->get('InputfieldRadios');
            $bgcolorchooser->label = $this->_('Random or custom colors');
            $bgcolorchooser->description = $this->_('Select if you want to use (a) certain color(s) or (a) random color(s) for the background.');
            $bgcolorchooser->notes = $this->_('If you want to adapt the color(s) to your project design, it is recommended to use custom color(s) instead of random.');
            $bgcolorchooser->attr('name', 'input_bgcolorchooser');
            $bgcolorchooser->attr('value', $this->input_bgcolorchooser);
            $bgcolorchooser->addOption('custom', $this->_('Custom color(s)'));
            $bgcolorchooser->addOption('random', $this->_('Random color(s)'));
            $bgcolorchooser->required = 1;
            $bgcolorchooser->columnWidth = 50;
            $fieldsetBackgroundSettings->add($bgcolorchooser, $inputfields);

            // set the number of colors for the distortion lines
            $bgnumberOfColors = $this->wire('modules')->get('InputfieldInteger');
            $bgnumberOfColors->label = $this->_('Number of colors');
            $bgnumberOfColors->description = $this->_('Select how much random colors should be used for the background');
            $bgnumberOfColors->notes = $this->_('If set to 0, then there is no limit for the colors, but it is recommended not to set the value too high. A good starting point will be 5.');
            $bgnumberOfColors->attr('name', 'input_bgnumberOfColors');
            $bgnumberOfColors->attr('type', 'number');
            $bgnumberOfColors->attr('value', $this->input_bgnumberOfColors);
            $bgnumberOfColors->attr('min', 0);
            $bgnumberOfColors->required = 1;
            $bgnumberOfColors->columnWidth = 25;
            $bgnumberOfColors->showIf = "input_bgcolorchooser=random";
            $fieldsetBackgroundSettings->add($bgnumberOfColors, $inputfields);

            // Custom colors for the background
            $bgCustomColors = wire('modules')->get('InputfieldTextArea');
            $bgCustomColors->label = $this->_('The color(s) for the background');
            $bgCustomColors->description = $this->_('Set the colors for the background in HEX color format (fe #ddd). Each color must be written on a new line.');
            $bgCustomColors->notes = $this->_('At least one color is required, but it is recommended to use more than 1 color to make the background more inhomogeneous and therefore more difficult for spam bots to read the content');
            $bgCustomColors->attr('name', 'input_bgCustomColors');
            $bgCustomColors->attr('value', $this->input_bgCustomColors);
            $bgCustomColors->columnWidth = 25;
            $bgCustomColors->required = 1;
            $bgCustomColors->showIf = "input_bgcolorchooser=custom";
            $fieldsetBackgroundSettings->add($bgCustomColors, $inputfields);

            $fieldsetsecurity5->add($fieldsetBackgroundSettings, $inputfields);

            $fieldsetTextCaptcha = $this->wire('modules')->get('InputfieldFieldset');
            $fieldsetTextCaptcha->label = $this->_('Character settings');
            $fieldsetTextCaptcha->collapsed = 1;// by default, this fieldset should be collapsed
            $fieldsetTextCaptcha->description = $this->_('Set the styling of the text (character string or calculation) based on your own preferences.');
            $fieldsetTextCaptcha->showIf = "input_captchaType!=none|SimpleQuestionCaptcha|DefaultImageCaptcha|SliderCaptcha|SimpleMathTextCaptcha";

            // Select the font family
            $refreshLink = $this->wire('modules')->get('InputFieldSubmit');
            $refreshLink->attr('name', 'input_submit_refreshFonts_frontendforms');
            $refreshLink->attr('value', 'refresh');
            $refreshLink->setSmall();
            $refreshLink->setSecondary();
            $refreshLink->text = $this->_('Refresh all font files');

            $captchaFontFamily = $this->wire('modules')->get('InputfieldSelect');
            /** @var InputfieldSelect $captchaFontFamily */
            $captchaFontFamily->attr('name', 'input_captchaFontFamily');
            $captchaFontFamily->label = $this->_('Font family');
            $captchaFontFamily->description = $this->_('Select the font family for the text.');
            $captchaFontFamily->addOptions($this->input_captchaFonts);
            $captchaFontFamily->attr('value', $this->input_captchaFontFamily);
            $captchaFontFamily->required = 1;
            $captchaFontFamily->columnWidth = 34;
            $captchaFontFamily->notes = $this->_('If there are no files available in the input field or you have transferred the site, please click the button below to refresh all font files.');

            $captchaFontFamily->appendMarkup('<div>' . $refreshLink->render() . '</div>');
            $fieldsetTextCaptcha->add($captchaFontFamily, $inputfields);

            // set number of the fontsize
            $captchaFontsize = $this->wire('modules')->get('InputfieldInteger');
            $captchaFontsize->label = $this->_('Font size');
            $captchaFontsize->description = $this->_('Set the font size for the text.');
            $captchaFontsize->attr('name', 'input_captchaFontsize');
            $captchaFontsize->attr('type', 'number');
            $captchaFontsize->attr('value', $this->input_captchaFontsize);
            $captchaFontsize->attr('min', 1);
            $captchaFontsize->required = 1;
            $captchaFontsize->columnWidth = 33;
            $fieldsetTextCaptcha->add($captchaFontsize, $inputfields);

            // CAPTCHA text color
            $captchaTextColor = wire('modules')->get('InputfieldText');
            $captchaTextColor->label = $this->_('Font color');
            $captchaTextColor->description = $this->_('Set the color for the text.');
            $captchaTextColor->notes = $this->_('Please enter a valid HEX color code.');
            $captchaTextColor->attr('name', 'input_captchaTextColor');
            $captchaTextColor->attr('value', $this->input_captchaTextColor);
            $captchaTextColor->required = 1;
            $captchaTextColor->columnWidth = 33;
            $fieldsetTextCaptcha->add($captchaTextColor, $inputfields);

            // Set the characters that should be used to create the CAPTCHA text
            $input_captchaCharset = $this->wire('modules')->get('InputfieldTextarea');
            $input_captchaCharset->label = $this->_('Characterset');
            $input_captchaCharset->description = $this->_('Enter the characters, that should be used to create a random text for CAPTCHAS.');
            $input_captchaCharset->attr('name', 'input_captchaCharset');
            $input_captchaCharset->attr('value', $this->input_captchaCharset);
            $input_captchaCharset->columnWidth = 34;
            $input_captchaCharset->required = 1;
            $input_captchaCharset->showIf = "input_captchaType!=SimpleMathTextCaptcha";
            $fieldsetTextCaptcha->add($input_captchaCharset, $inputfields);

            // set the number of characters for text CAPTCHA
            $captchaNumberOfCharacters = $this->wire('modules')->get('InputfieldInteger');
            $captchaNumberOfCharacters->label = $this->_('Number of characters');
            $captchaNumberOfCharacters->description = $this->_('Enter the number of character you want the text to consist of (A recommended value is 4 or 5).');
            $captchaNumberOfCharacters->attr('name', 'input_captchaNumberOfCharacters');
            $captchaNumberOfCharacters->attr('value', $this->input_captchaNumberOfCharacters);
            $captchaNumberOfCharacters->attr('type', 'number');
            $captchaNumberOfCharacters->attr('min', 4);
            $captchaNumberOfCharacters->columnWidth = 33;
            $captchaNumberOfCharacters->required = 1;
            $captchaNumberOfCharacters->showIf = "input_captchaType!=SimpleMathTextCaptcha";
            $fieldsetTextCaptcha->add($captchaNumberOfCharacters, $inputfields);

            //Show characters off the line
            $charactersOffLine = $this->wire('modules')->get('InputfieldCheckbox');
            $charactersOffLine->attr('name', 'input_charactersOffLine');
            $charactersOffLine->attr('checked', $this->input_charactersOffLine ? 'checked' : '');
            $charactersOffLine->label = $this->_('Characters not in one line');
            $charactersOffLine->label2 = $this->_('Position characters randomly');
            $charactersOffLine->description = $this->_('If checked, the characters the text consists of will not be displayed in one line. They will be displayed randomly in various positions and angles (recommended).');
            $charactersOffLine->columnWidth = 33;
            $fieldsetTextCaptcha->add($charactersOffLine, $inputfields);

            $fieldsetsecurity5->add($fieldsetTextCaptcha, $inputfields);

            // DISTORTION LINES
            $fieldsetDistortionlines = $this->wire('modules')->get('InputfieldFieldset');
            $fieldsetDistortionlines->label = $this->_('Distortion lines');
            $fieldsetDistortionlines->collapsed = 1; // by default, this fieldset should be collapsed
            $fieldsetDistortionlines->description = $this->_('Add distortion lines over the image to make it more difficult for spam bots to read the content.');
            $fieldsetDistortionlines->showIf = "input_captchaType!=none|SimpleQuestionCaptcha|SliderCaptcha";

            // Set the number of distortion lines
            $captchaNumberOfLines = $this->wire('modules')->get('InputfieldInteger');
            $captchaNumberOfLines->label = $this->_('Number of distortion lines');
            $captchaNumberOfLines->description = $this->_('Set how many lines should be drawn over the image.');
            $captchaNumberOfLines->notes = $this->_('If set to 0 then this feature is disabled. Max number is 100. You can enter the number in steps of 5. Afterwards check it on the frontend by refreshing the CAPTCHA multiple times, if the amount of lines is too low or to high.');
            $captchaNumberOfLines->attr('name', 'input_captchaNumberOfLines');
            $captchaNumberOfLines->attr('type', 'number');
            $captchaNumberOfLines->attr('value', $this->input_captchaNumberOfLines);
            $captchaNumberOfLines->attr('min', 0);
            $captchaNumberOfLines->attr('max', 100);
            $captchaNumberOfLines->attr('step', 5);
            $captchaNumberOfLines->required = 1;
            $captchaNumberOfLines->columnWidth = 33;
            $fieldsetDistortionlines->add($captchaNumberOfLines, $inputfields);

            // Random or custom colors
            $colorchooser = $this->wire('modules')->get('InputfieldRadios');
            $colorchooser->label = $this->_('Random or custom colors');
            $colorchooser->description = $this->_('Select if you want to use (a) certain color(s) or (a) random color(s) for the lines.');
            $colorchooser->notes = $this->_('If you want to adapt the color(s) to your project design, it is recommended to use custom color(s) instead of random.');
            $colorchooser->attr('name', 'input_colorchooser');
            $colorchooser->attr('value', $this->input_colorchooser);
            $colorchooser->addOption('custom', $this->_('Custom colors'));
            $colorchooser->addOption('random', $this->_('Random colors'));
            $colorchooser->required = 1;
            $colorchooser->showIf = "input_captchaNumberOfLines>0";
            $colorchooser->columnWidth = 33;
            $fieldsetDistortionlines->add($colorchooser, $inputfields);

            // set the number of colors for the distortion lines
            $numberOfColorsOfLines = $this->wire('modules')->get('InputfieldInteger');
            $numberOfColorsOfLines->label = $this->_('Number of colors');
            $numberOfColorsOfLines->description = $this->_('Select how much random colors should be used for the lines.');
            $numberOfColorsOfLines->notes = $this->_('If you enter the value 0, then the number of colors used is equal to the number of distortion lines. On the other hand, the entered value corresponds to the number of colors that are used.');
            $numberOfColorsOfLines->attr('name', 'input_numberOfColorsOfLines');
            $numberOfColorsOfLines->attr('value', $this->input_numberOfColorsOfLines);
            $numberOfColorsOfLines->attr('type', 'number');
            $numberOfColorsOfLines->attr('min', 0);
            $numberOfColorsOfLines->required = 1;
            $numberOfColorsOfLines->columnWidth = 17;
            $numberOfColorsOfLines->showIf = "input_captchaNumberOfLines>0,input_colorchooser=random";
            $fieldsetDistortionlines->add($numberOfColorsOfLines, $inputfields);

            // Custom colors
            $captchaLinesColor = $this->wire('modules')->get('InputfieldTextArea');
            $captchaLinesColor->label = $this->_('The color(s) for the lines above the image');
            $captchaLinesColor->description = $this->_('Set the colors for the lines in HEX color format (fe #000). Each color must be written on a new line.');
            $captchaLinesColor->notes = $this->_('At least one color is required, but it is recommended to use more than 1 color to make the lines more inhomogeneous and therefore more difficult for spam bots to read the content.');
            $captchaLinesColor->attr('name', 'input_captchaLinesColor');
            $captchaLinesColor->attr('value', $this->input_captchaLinesColor);
            $captchaLinesColor->columnWidth = 17;
            $captchaLinesColor->required = 1;
            $captchaLinesColor->showIf = "input_captchaNumberOfLines>0,input_colorchooser=custom";
            $fieldsetDistortionlines->add($captchaLinesColor, $inputfields);

            $fieldsetsecurity5->add($fieldsetDistortionlines, $inputfields);

            // IMAGE FILTERS
            $fieldsetImagefilters = $this->wire('modules')->get('InputfieldFieldset');
            $fieldsetImagefilters->label = $this->_('Image filters');
            $fieldsetImagefilters->collapsed = 1; // by default, this fieldset should be collapsed
            $fieldsetImagefilters->description = $this->_('Add filters to images to make it more difficult to identify the content.');
            $fieldsetImagefilters->showIf = "input_captchaType=DefaultImageCaptcha";

            // Blur filter
            $blurlevel = $this->wire('modules')->get('InputfieldInteger');
            $blurlevel->label = $this->_('Blur');
            $blurlevel->description = $this->_('Blur the image by selecting the blur value: The higher the value, the stronger the blur effect.');
            $blurlevel->notes = $this->_('If you enter the value 0, then the blur effect is disabled. The maximum value is 10.');
            $blurlevel->attr('name', 'input_blurlevel');
            $blurlevel->attr('value', $this->input_blurlevel);
            $blurlevel->attr('type', 'number');
            $blurlevel->attr('min', 0);
            $blurlevel->attr('max', 10);
            $blurlevel->required = 1;
            $fieldsetImagefilters->add($blurlevel, $inputfields);

            // Pixelate filter
            $pixelatelevel = $this->wire('modules')->get('InputfieldInteger');
            $pixelatelevel->label = $this->_('Pixelate');
            $pixelatelevel->description = $this->_('Pixelate the image by selecting the pixelate value: The higher the value, the stronger the pixelate effect.');
            $pixelatelevel->notes = $this->_('If you enter the value 0, then the pixelate effect is disabled. The maximum value is 5.');
            $pixelatelevel->attr('name', 'input_pixelatelevel');
            $pixelatelevel->attr('value', $this->input_pixelatelevel);
            $pixelatelevel->attr('type', 'number');
            $pixelatelevel->attr('min', 0);
            $pixelatelevel->attr('max', 10);
            $pixelatelevel->required = 1;
            $fieldsetImagefilters->add($pixelatelevel, $inputfields);

            // 3 Grayscale filter
            $grayscale = $this->wire('modules')->get('InputfieldCheckbox');
            $grayscale->label = $this->_('Grayscale');
            $grayscale->label2 = $this->_('Remove colors from the image');
            $grayscale->description = $this->_('By clicking the box, all colors of the image will be removed.');
            $grayscale->attr('name', 'input_grayscale');
            $grayscale->attr('checked', $this->input_grayscale ? 'checked' : '');
            $fieldsetImagefilters->add($grayscale, $inputfields);

            $fieldsetsecurity5->add($fieldsetImagefilters, $inputfields);
        }

        $fieldset5->add($fieldsetsecurity5, $inputfields);

        $fieldset7 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldset7->label = $this->_('Measure 6: Password field settings');
        $fieldset7->description = $this->_('Increase site security by checking passwords against a blacklist of popular passwords. This is useful if you offer user registration on your site to prevent users entering unsafe passwords.');
        $fieldset7->collapsed = 1;// by default, this fieldset should be collapsed

        $blacklist = wire('modules')->get('InputfieldTextArea');
        $blacklist->label = $this->_('Password blacklist');
        $desc = $this->_('Enter passwords, that are forbidden (each on a new line).') . ' ';
        $desc .= $this->_('This list will be used by the "safePassword" validator to validate a password field against unsafe passwords.') . ' ';
        $desc .= $this->_('The validator returns false, if the password was found on the blacklist, otherwise true.') . ' ';
        $desc .= $this->_('The list will be populated automatically with appropriate passwords from the top 100 passwords list below, but you can add your own passwords too - They will not get overwritten during the blacklistlist update.');
        $blacklist->description = $desc;
        $notes = sprintf($this->_('Current number of entries in the blacklist: %s.'), count($this->blacklist));
        if ($this->last_check) {
            $notes .= ' ' . sprintf(
                    $this->_('Last update of the blacklist: %s.'),
                    $this->wire('datetime')->date($this->default_dateformat, $this->last_check)
                );
        }
        $blacklist->notes = $notes;
        $blacklist->attr('name', 'input_blacklist');
        $blacklist->attr('value', $this->input_blacklist);
        $fieldset7->add($blacklist, $inputfields);

        // load passwords from ....
        $pwlist = wire('modules')->get('InputfieldMarkup');
        // grab content from the page
        $content = '<h2>' . $this->_('List of top 100 most common passwords') . '</h2>';
        $content .= '<p>' . $this->_('The passwords in the list below are unsafe and a serious security issue for each account on your site.') . '<br>';
        $osaplink = '<a href="https://owasp.org/" target="_blank">OSAP</a>';
        $content .= sprintf(
                $this->_('All passwords were taken from %s (Open Web Application Security Project).'),
                $osaplink
            ) . '<br>';
        $url =  $this->getDataFromGitHub(self::TOP_PASSWORDS)->html_url;
        $gitlink = '<a href="'.$url.'" target="_blank">'.$url.'</a>';
        $content .= sprintf($this->_('Source of the passwords: %s'), $gitlink) . '</p><hr>';
        $hintText = '<h3>' . $this->_('Please note:') . '</h3>';
        $hintText .= '<p>' . $this->_('Only passwords that matches your password requirements will be added to the blacklist after pressing the update button or during the automatic update.') . '<br>';
        $hintText .= $this->_('Passwords which do not fulfill your password requirements, do not need to be on the list and will be filtered out before. The blacklist should be as short as possible to prevent performance issues.') . '<br>';
        $hintText .= $this->_('If your blacklist is very long, it would be better to increase the password requirements.') . '<br>';
        $hintText .= $this->_('If no passwords from this list will be added does not mean that it would not work - it means that your password requirements are high enough to filter out all of these passwords before.') . '</p>';
        // get password requirements
        $hintText .= '<h3>' . $this->_('Current password requirements settings:') . '</h3>';
        $hintText .= '<p>' . $this->_('A password must contain at least one of the following characters:') . '</p><ul>';

        if ($this->password_field->requirements) {


            if (!$this->password_field->requirementsLabels) {
                $requirementsLabels = wire('modules')->get('InputfieldPassword')->requirementsLabels;
            } else {
                $requirementsLabels = $this->password_field->requirementsLabels;
            }

            foreach ($this->password_field->requirements as $label) {
                if (array_key_exists($label, $requirementsLabels)) {
                    $hintText .= '<li>' . $requirementsLabels[$label] . '</li>';
                }
            }
        } else {
            $hintText .= '<li>' . $this->_('No password requirements have been set!') . '</li>';
        }

        $hintText .= '</ul>';
        $link = '<a title="' . $this->_('To the password field edit page') . '" href="' . $this->password_field->editUrl() . '">';
        $link .= $this->_('here') . '</a>';
        $hintText .= '<p>' . sprintf(
                $this->_('If you have the permission to change the password requirements, you can do it %s.'),
                $link
            ) . '</p>';

        // information about the last update of the list
        $update = $this->_('The password list will be checked once a month automatically if something has been changed on GitHub.');
        $updatedata = '';

        if ($this->toppasswords_download && $this->wire('files')->exists($this->passwordPath)) {
            $updatedata .= '<li>' . sprintf(
                    $this->_('Last download date: %s (%s).'),
                    $this->wire('datetime')->date($this->default_dateformat, filemtime($this->passwordPath)),
                    $this->wire('datetime')->date('relative', filemtime($this->passwordPath))
                ) . '</li>';
        }
        if ($this->github_modified) {
            $updatedata .= '<li>' . sprintf(
                    $this->_('Last modification date on GitHub: %s (%s).'),
                    $this->wire('datetime')->date($this->default_dateformat, $this->github_modified),
                    $this->wire('datetime')->date('relative', $this->github_modified)
                ) . '</li>';
        }
        if ($this->last_check) {
            $updatedata .= '<li>' . sprintf(
                    $this->_('Last automatic check for passwords via CronJob: %s (%s).'),
                    $this->wire('datetime')->date($this->default_dateformat, $this->last_check),
                    $this->wire('datetime')->date('relative', $this->last_check)
                ) . '</li>';
        }

        $update .= '<ul id="ff-password-changes">' . $updatedata . '</ul>';
        $content .= '<p>' . $update . '</p>';
        $content .= '<p>' . $this->_('After the check, all passwords that fulfill your password requirements and are not on your blacklist, will be added automatically.') . '<br>';
        $content .= $this->_('You do not need to add them manually.') . '</p><hr>';
        $content .= $this->_('If you do not want to wait until the next automatic update, you can update your blacklist manually by pressing the button below.') . '</p>';

        // Create a button to add the passwords to the blacklist
        $button = $this->wire('modules')->get('InputfieldSubmit');
        $button->name = 'submit_save_passwordblacklist';
        $button->value = 'add';
        $button->text = $this->_('Update blacklist manually');
        $content .= $button->render();

        $content .= '<div class="uk-alert-warning" data-uk-alert>' . $hintText . '</div>';

        // create an HTML ol list of passwords
        if ($this->passwordList) {
            // if the list is longer than 100, cut all passwords after number 100
            $arr = array_filter($this->passwordList);
            $list = array_slice($arr, 0, 100, true);
            $content .= '<h3>' . sprintf(
                    $this->_('Top 100 most common passwords in %s (Last list update on GitHub: %s)'),
                    date('Y'),
                    $this->wire('datetime')->date($this->default_dateformat, $this->github_modified)
                ) . '</h3>';
            $items = '';
            foreach ($list as $password) {
                $class = (in_array($password, $this->blacklist)) ? 'active notes' : 'inactive';
                $items .= '<li class="' . $class . '">' . $password . '</li>';
            }
            $content .= '<div id="pw-container"><ol id="password-list">' . $items . '</ol><hr>';
            $content .= '<p>' . $this->_('Passwords with a colored background are on your blacklist.') . '</p>';
            $content .= '</div>';
        } else {
            $content .= $this->_('Sorry, but the file passwords.txt does not exist. Please press the update button above.');
        }

        $pwlist->value = $content;
        $fieldset7->add($pwlist, $inputfields);

        $fieldset5->add($fieldset7, $inputfields);

        $fieldset8 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldset8->label = $this->_('Measure 7: HTML5 browser validation');
        $fieldset8->collapsed = 1;// by default, this fieldset should be collapsed
        $fieldset8->description = $this->_('Use HTML5 browser validation in addition to server side validation.');

        // HTML 5 form validation
        $html5_validation = $this->wire('modules')->get('InputfieldCheckbox');
        $html5_validation->attr('name', 'input_html5_validation');
        $html5_validation->attr('checked', $this->input_html5_validation == '1' ? 'checked' : '');
        $html5_validation->label = $this->_('Enable HTML5 browser validation in addition to the server side validation.');
        $html5_validation->checkboxLabel = $this->_('Enable HTML 5 browser validation');
        $html5_validation->description = $this->_('If the box is checked, the form will be validated by the browser at the frontend using HTML5 attributes');
        $html5_validation->notes = $this->_('The form will be validated on the server in any case, but you can also use HTML5 browser validation so that the form values are validated before they are sent to the server.');
        $fieldset8->add($html5_validation, $inputfields);
        $fieldset5->add($fieldset8, $inputfields);

        $fieldset9 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldset9->label = $this->_('Measure 8: Stop words to identify SPAM texts');
        $fieldset9->collapsed = 1;// by default, this fieldset should be collapsed
        $fieldset9->description = $this->_('Define some stop words that can be checked via the "checkContentForSpam" validator.');

        $stopwords = wire('modules')->get('InputfieldTextArea');
        $stopwords->label = $this->_('STOP word list');
        $stopwords->textFormat = Inputfield::textFormatMarkdown;
        $desc = $this->_('Enter words that are not allowed in texts (each on a new line).') . ' ';
        $desc .= $this->_('This list will be used by the "checkContentForSpam" validator to validate a text field against STOP words and other SPAM indicators.') . '<br>';
        $desc .= $this->_('The validator returns false, if a lot of SPAM indicators (not only STOP words) were found, otherwise true.') . '<br>';
        $desc .= $this->_('This validator is especially created for textarea fields, which contain for example a message of a contact form.');
        $stopwords->description = $desc;
        $notes = sprintf($this->_('This list is for your own custom SPAM words. All other SPAM words (over 60 000) will be taken from %s and will be downloaded to FrontendForms every 4 weeks automatically.'), '<a href="https://github.com/splorp/wordpress-comment-blocklist/blob/master/blacklist.txt" target="_blank">wordpress-comment-blocklist</a>');
        $notes .= '<br>' . $this->_('The validator checks whether words from this long list are included in the text, and then marks the text as SPAM.');
        $stopwords->notes = $notes;
        $stopwords->attr('name', 'input_stopwords');
        $stopwords->attr('value', $this->input_stopwords);
        $fieldset9->add($stopwords, $inputfields);

        // information about the last update of the SPAM word list -
        // mirrors the equivalent password-list status block above
        $spamUpdate = $this->_('The SPAM word list will be checked once every 4 weeks automatically if something has been changed on GitHub.');
        $spamUpdateData = '';

        if ($this->topspamwords_download && $this->wire('files')->exists($this->stopwordPath)) {
            $spamUpdateData .= '<li>' . sprintf(
                    $this->_('Last download date: %s (%s).'),
                    $this->wire('datetime')->date($this->default_dateformat, filemtime($this->stopwordPath)),
                    $this->wire('datetime')->date('relative', filemtime($this->stopwordPath))
                ) . '</li>';
        }
        if ($this->spamwords_github_modified) {
            $spamUpdateData .= '<li>' . sprintf(
                    $this->_('Last modification date on GitHub: %s (%s).'),
                    $this->wire('datetime')->date($this->default_dateformat, $this->spamwords_github_modified),
                    $this->wire('datetime')->date('relative', $this->spamwords_github_modified)
                ) . '</li>';
        }
        if ($this->last_stopword_check) {
            $spamUpdateData .= '<li>' . sprintf(
                    $this->_('Last automatic check for SPAM words via CronJob: %s (%s).'),
                    $this->wire('datetime')->date($this->default_dateformat, $this->last_stopword_check),
                    $this->wire('datetime')->date('relative', $this->last_stopword_check)
                ) . '</li>';
        }

        $spamUpdate .= '<ul id="ff-stopword-changes">' . $spamUpdateData . '</ul>';
        $spamUpdate .= '<p>' . $this->_('If you do not want to wait until the next automatic update, you can update the SPAM word list manually by pressing the button below.') . '</p>';

        $spamStatus = $this->wire('modules')->get('InputfieldMarkup');
        $spamStatus->value = $spamUpdate;
        $fieldset9->add($spamStatus, $inputfields);

        // Create a button to manually re-download the SPAM word list
        $stopwordButton = $this->wire('modules')->get('InputfieldSubmit');
        $stopwordButton->name = 'submit_save_stopwordlist';
        $stopwordButton->value = 'add';
        $stopwordButton->text = $this->_('Update SPAM word list manually');
        $fieldset9->add($stopwordButton, $inputfields);


        $fieldset5->add($fieldset9, $inputfields);


        $fieldset10 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldset10->label = $this->_('Measure 9: Allowed MIME types for uploads');
        $fieldset10->collapsed = 1;// by default, this fieldset should be collapsed
        $fieldset10->description = $this->_('Define all MIME types that are allowed for file uploads.');

        $mimetypes = wire('modules')->get('InputfieldTextarea');
        $mimetypes->attr('name', 'input_allowedmimetypes');
        $mimetypes->label = $this->_('Allowed MIME Types');
        $mimetypes->textFormat = Inputfield::textFormatMarkdown;
        $mimetypes->description = $this->_('Enter the MIME types that are allowed for file uploads, one per line.');

        $mimeLink = '<a class="external" href="https://codeshack.io/mime-type-lookup/">codeshack.io</a>';

        $table = wire('modules')->get('MarkupAdminDataTable');
        $table->setSortable(false);

        $table->headerRow([
            $this->_('Examples of the most commonly used MIME types in web forms:'),
            $this->_('Examples of dangerous MIME types:')
        ]);

        $mostUsed = '<ul>
                    <li>image/jpeg</li>
                    <li>image/png</li>
                    <li>image/gif</li>
                    <li>image/webp</li>
                    <li>application/pdf</li>
                    <li>text/plain</li>
                    <li>text/csv</li>
                    <li>application/zip</li>
                    </ul>';

        $mostDangerous = '<ul>
     <li>application/x-php</li>
      <li>text/x-php</li>
        <li>application/x-httpd-php</li>
        <li>application/javascript</li>
        <li>text/javascript</li>
        <li>text/html</li>
        <li>application/x-sh</li>
        <li>application/octet-stream</li>
        <li>application/x-msdownload</li>
        <li>application/x-python-code</li>
                    </ul>';

        $table->row([
            $mostUsed,
            $mostDangerous
        ]);

        $outputTable = $table->render();

        $notes = sprintf($this->_('Use the following website to search for MIME types: %s'), $mimeLink).'<br><br>';
        $notes .= $this->_('Some MIME types pose a higher security risk because they can execute code, bypass browser restrictions, or compromise your server if uploaded to a web-accessible directory.');
        $notes .= '<br>'.$this->_('The most secure approach is to allow only specific MIME types instead of blocking specific MIME types.');
        $notes .= '<br>'.$this->_('If a user uploads a file with a disallowed MIME type, the form submission will fail and an error message will be displayed.');
        $notes .= '<br>'.sprintf($this->_('Just a note: this global setting can be overridden for each file upload field by using the %s validation rule with different values defined directly on the upload field.'), '<b>allowedMimeTypes</b>');
        $notes .= '<br>'.sprintf($this->_('If you want to bypass this security check, you can use the %s method on an upload field to disable the global setting.'), '<b>removeRule("allowedMimeTypes")</b>');
        $notes .= '<h2>'.$this->_('MIME types examples:').'</h2>';
        $notes .= $outputTable;

        $mimetypes->notes = $notes;

        $mimetypes->attr('value', $this->input_allowedmimetypes);
        $fieldset10->add($mimetypes, $inputfields);

        $fieldset5->add($fieldset10, $inputfields);

        $fieldset11 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldset11->label = $this->_('Measure 10: Re-render uploaded images');
        $fieldset11->collapsed = 1;// by default, this fieldset should be collapsed
        $fieldset11->description = $this->_('Re-render (decode and re-save) uploaded images to strip any hidden payload that might be smuggled inside the original file bytes or metadata.');

        $reRenderImages = $this->wire('modules')->get('InputfieldCheckbox');
        $reRenderImages->attr('name', 'input_reRenderImages');
        $reRenderImages->attr('checked', $this->input_reRenderImages === 1 ? 'checked' : '');
        $reRenderImages->label = $this->_('Image re-rendering setting');
        $reRenderImages->entityEncodeText = false;
        $reRenderImages->label2 = $this->_('Re-render uploaded images after storing them');
        $reRenderImages->notes = $this->_('If checked, every uploaded image is decoded and saved again as a fresh copy of its own pixel data. This removes anything that relied on the original file bytes surviving untouched - e.g. a "polyglot" file that is simultaneously a valid image and valid PHP/HTML/JS code, or a payload hidden inside EXIF/metadata fields - regardless of the specific technique used. If unchecked, uploaded images are stored exactly as received.');
        $reRenderImages->notes .= '<br>'.sprintf($this->_('Just a note: this global setting can be overridden for each file upload field by using the %s method on the upload field.'), '<b>setImageReRender(true|false)</b>');
        $fieldset11->add($reRenderImages, $inputfields);

        $fieldset5->add($fieldset11, $inputfields);

        $inputfields->add($fieldset5);

        $fieldset6 = $this->wire('modules')->get('InputfieldFieldset');
        $fieldset6->label = $this->_('Statistics of blocked visitors');
        $fieldset6->description = $this->_('Get information about blocked visitors (IP, form) from the log files');
        $fieldset6->collapsed = 1;
        $fieldset6->icon = 'fa-bar-chart';

        // grab data from the log file if present

        $stat = $this->wire('modules')->get("InputfieldMarkup");
        $stat->attr('name', 'statistics');
        $stat->label = "";
        if ($this->wire('log')->exists('Failed-attempts-frontendforms')) {

            $logs = $this->wire('log')->getEntries('failed-attempts-frontendforms');

            $result = array();
            foreach ($logs as $element) {
                $date = $element['date'];
                $url = $element['url'];
                $user = $element['user'];
                $text = json_decode($element['text']);
                // skip log entries that aren't valid JSON, rather than
                // attempting to read a property off of null
                if (!$text) {
                    continue;
                }
                $ip = $text->IP;
                (isset($result[$ip])) ? $result[$ip]['count'] += 1 : $result[$ip] = array(
                    'data' => $date,
                    'user' => $user,
                    'url' => $url,
                    'count' => 1
                );
            }
            // sort array by count descending
            array_multisort(array_column($result, 'count'), SORT_DESC, SORT_NUMERIC, $result);
            // output table
            $value = $this->executeTable($result);
        } else {
            $value = $this->_('Nothing to show - logfile does not exist');
        }
        // show a hint to the user if logging failed attempts is not enabled
        if ((!$this->input_logFailedAttempts) || ($this->input_maxAttempts < 1)) {
            $hint_text = '<p>' . $this->_('Logging of failed attempts is not enabled. If you want to use this feature, you need to enable it inside "Measure 1: Restrict number of failed attempts".');
            $hint_text .= '<br>' . $this->_('"Max number of failed attempts" must be higher than 0 and  the checkbox "Log failed attempts" must be enabled.') . '</p>';
            $hint_text .= '<p><a id="enable-logging" href="#spam">' . $this->_('Go to the settings to enable logging of failed attemtps') . '</a></p>';
            $value .= '<div class="uk-alert-warning" data-uk-alert>' . $hint_text . '</div>';
        }

        $stat->value = '<p>' . $value . '</p>';
        $fieldset6->append($stat);

        $inputfields->add($fieldset6);

    }

    /**
     * Create new directory and copy files from another directory to this directory
     * Afterwards delete the old directory
     * These files are images for email templates
     * @param string $from
     * @param string $to
     * @return void
     * @throws WireException
     */
    protected function createFilesDir(string $from, string $to, bool $delete = true): void
    {
        // if a directory exists or directory was created successfully
        // ($recursive = true is required here: $to can be a nested path,
        // e.g. files/FrontendForms/template-images/, whose parent folder
        // may not exist yet - mkdir() only creates one level at a time by
        // default and would otherwise fail with "Unable to mkdir")
        if (($this->wire('files')->exists($to)) || ($this->wire('files')->mkdir($to, true))) {
            // check if files exists in the modules assets folder
            if ($this->wire('files')->exists($from)) {
                // scan directory if it contains files
                $files = $this->wire('files')->find($from);
                if ($files) {
                    // copy all files to the newly created FrontendForms directory under site/assets/files
                    $copied = $this->wire('files')->copy($from, $to);
                    // only remove the source folder once its contents have
                    // actually been copied to the destination - removing it
                    // unconditionally could otherwise leave neither location
                    // with the files (e.g. if the copy fails partway
                    // through), permanently losing the email template
                    // images.
                    if ($copied && $delete) {
                        $this->wire('files')->rmdir($from, true);
                    }
                }
            }
        }
    }

    /**
     * Copy captchaimage.php from the module to the root (on install), or
     * remove it from the root (on uninstall).
     *
     * The module's own copy (Formelements/Captcha/captchaimage.php) is
     * treated as the permanent, authoritative source and is never
     * deleted - only ever copied FROM. This keeps every uninstall/install
     * cycle simple and lossless without needing to copy the root file
     * back into the module first.
     * @param bool $install
     * @return void
     * @throws WireException
     */
    protected function createRemoveCaptchaImageFile(bool $install): void
    {
        $moduleFile = $this->modulePath . 'Formelements/Captcha/captchaimage.php';
        $rootFile = $this->wire('config')->paths->root . 'captchaimage.php';

        if (!$install) {
            // uninstall: just remove the root copy - the module's own
            // file was never touched, so there is nothing to preserve
            $this->wire('files')->unlink($rootFile);
            return;
        }

        $copied = $this->wire('files')->copy($moduleFile, $rootFile);

        if ($copied && !is_writable($rootFile)) {
            // captcha file could not be copied to the root folder
            $warning_text[] = sprintf($this->_('The captchaimage.php file could not be copied to the root directory (%s), because the root directory is not writeable.'), $this->wire('config')->paths->root);
            $warning_text[] = sprintf($this->_('Do not be worry! To fix this issue, please move the file from "/site/modules/FrontendForms/Formelements/Captcha/captchaimage.php" to "%s" by yourself.'), $rootFile);
            $warning_text[] = $this->_('Otherwise you will get an error if you try to use the CAPTCHA on your forms.');
            $this->wire('session')->warning(implode('<br>', $warning_text), Notice::allowMarkup);
        }
    }

    /**
     * Run during installation
     * @return void
     * @throws WireException
     */
    public function ___install(): void
    {

        //save default module configurations on install
        $data = self::getDefaultData();
        //save the path to the default font file manually to the config data
        $data['input_captchaFontFamily'] = $this->modulePath . 'assets/fonts/OpenSans-SemiBold.ttf';
        // save all other ttf fonts to the db
        $data['input_captchaFonts'] = $this->findAllFontfiles();

        if ($this->downloadPasswordsFromGitHub()) { // first download the file from GitHub
            $data['toppasswords_download'] = $this->wire('datetime')->date($this->default_dateformat);
            $data['last_check'] = $this->wire('datetime')->date($this->default_dateformat);
            // load password list data from GitHub
            $githubdata = $this->getDataFromGitHub(self::LAST_PASSWORDS_MODIFICATION_URL); //load JSON data from the file
            if ($githubdata && isset($githubdata[0]->commit->author->date)) {
                $last_update = $githubdata[0]->commit->author->date; // last modification date on GitHub
                $data['github_modified'] = $this->wire('datetime')->date($this->default_dateformat, $last_update);
            }
            $this->password_field = wire('fields')->get('pass');
            $this->password_object = new InputfieldPassword();
            // for the case that property requirements is not stored inside the db at this moment
            $requirements = $this->password_field->requirements ?? ["letter", "digit"];
            $this->password_object->requirements = $requirements;
            $passwordsArray = self::createArrayOfTxtFile($this->passwordPath);
            $data['input_blacklist'] = $this->cleanUpPasswordList($passwordsArray);
            $this->input_blacklist = $data['input_blacklist'];
        }

        // download the SPAM word (stopwords) list from GitHub, mirroring
        // the password list download above
        $data['last_stopword_check'] = $this->wire('datetime')->date($this->default_dateformat);
        if ($this->downloadStopwordsFromGitHub()) {
            $data['topspamwords_download'] = $this->wire('datetime')->date($this->default_dateformat);
            $spamGithubData = $this->getDataFromGitHub(self::LAST_SPAMWORDS_MODIFICATION_URL);
            if ($spamGithubData && isset($spamGithubData[0]->commit->author->date)) {
                $data['spamwords_github_modified'] = $this->wire('datetime')->date(
                    $this->default_dateformat,
                    $spamGithubData[0]->commit->author->date
                );
            }
        }
        // save the config data to the db
        wire('modules')->saveConfig($this, $data);

        // copy files from FrontendForms/assets/template-images to site/assets/files/Frontendforms
        $to = $this->wire('config')->paths->assets . 'files/FrontendForms/template-images/';
        $from = $this->modulePath . 'assets/template-images/';

        $this->createFilesDir($from, $to, false);

        // copy captchaimage.php from site/modules/FrontendForms/FormElements/Captcha/to the root dir
        $this->createRemoveCaptchaImageFile(true);

        // Restore any custom email templates that were backed up into the
        // module on a previous uninstall (see ___uninstall()), so a
        // deinstall-then-reinstall cycle (without the module's own files
        // being deleted from disk in between) doesn't lose them. Falls
        // back to just creating the empty folder if there is nothing to
        // restore (e.g. a fresh installation).
        $customTemplatesLive = $this->wire('config')->paths->site . 'frontendforms-custom-templates/';
        $customTemplatesBackup = $this->modulePath . 'assets/frontendforms-custom-templates/';
        if ($this->wire('files')->exists($customTemplatesBackup)) {
            $this->createFilesDir($customTemplatesBackup, $customTemplatesLive);
        }
        if (!$this->wire('files')->exists($customTemplatesLive, 'dir')) {
            $this->wire('files')->mkdir($customTemplatesLive, true);
        }

        // create the custom frameworks classes folder
        $this->createCustomFrameworksFolder();

    }

    /**
     * Running some code after the module has been updated
     * @param $fromVersion
     * @param $toVersion
     * @return void
     * @throws WireException
     */
    public function ___upgrade($fromVersion, $toVersion): void
    {

        // copy new captchaimage.php to the root
        $this->createRemoveCaptchaImageFile(true);

        // copy files from FrontendForms/assets/template-images to site/assets/files/FrontendForms
        $to = $this->wire('config')->paths->assets . 'files/FrontendForms/template-images/';
        $from = $this->modulePath . 'assets/template-images/';
        $this->createFilesDir($from, $to, false);

        // create custom email template folder if it does not exist
        if (!$this->wire('files')->exists($this->wire('config')->paths->site . 'frontendforms-custom-templates/', 'dir')) {
            $this->wire('files')->mkdir($this->wire('config')->paths->site . 'frontendforms-custom-templates/', true);
        }

        // create the custom frameworks classes folder
        $this->createCustomFrameworksFolder();

        // Version-specific migration steps. Each one is gated to the
        // specific fromVersion/toVersion range it applies to, so
        // ___upgrade() stays safe to extend with further, unrelated
        // migration steps for future version changes without them
        // accidentally re-running for upgrades they were never meant for.

        if ($this->isVersionUpgrade($fromVersion, $toVersion, 2, 3)) {
            // Usually all old files will be deleted by default in the automatic update process -
            // this is only a fallback if the update will be done manually without deleting the old module files
            $this->migrateOrphanedFilesFromV2ToV3();
        }
    }


    /**
     * Check whether a module version upgrade crosses from one given major
     * version to another - e.g. isVersionUpgrade($fromVersion, $toVersion, 2, 3)
     * is true for an upgrade from any 2.x version to any 3.x version, but
     * false for e.g. 2.3 -> 2.15, or 3.0 -> 3.1.
     *
     * Used by ___upgrade() to gate one-time, version-specific migration
     * steps (see migrateOrphanedFilesFromV2ToV3()) so they only run for
     * the exact transition they were written for, while ___upgrade()
     * itself stays reusable for handling further version changes later.
     *
     * @param string $fromVersion Version before the upgrade, e.g. "2.3.17"
     * @param string $toVersion Version after the upgrade, e.g. "3.0.0"
     * @param int $fromMajor Major version before the upgrade
     * @param int $toMajor Major version after the upgrade
     * @return bool
     */
    protected function isVersionUpgrade(
        string $fromVersion,
        string $toVersion,
        int $fromMajor,
        int $toMajor
    ): bool {

        $fromVersionMajor = (int) explode('.', $fromVersion, 2)[0];
        $toVersionMajor = (int) explode('.', $toVersion, 2)[0];

        return $fromVersionMajor === $fromMajor
            && $toVersionMajor === $toMajor;
    }

    /**
     * Remove the now-orphaned files/folders listed in migrateV2V3.json, left
     * over from version 2.x's directory layout, which version 3.x no
     * longer uses.
     * @return void
     * @throws WireException
     */
    protected function migrateOrphanedFilesFromV2ToV3(): void
    {
        $migrateJsonPath = $this->modulePath . 'migrateV2V3.json';
        $files = [];
        if ($this->wire('files')->exists($migrateJsonPath)) {
            $migrate = file_get_contents($migrateJsonPath);
            $decoded = json_decode((string) $migrate, true);
            if (is_array($decoded)) {
                $files = $decoded;
            }
        }
        // delete each file or folder from the migrateV2V3.json file
        foreach ($files as $file) {
            $this->removeOrphanedDataPath($file);
        }
    }

    /**
     * Remove a file or folder (including all of its contents) from its old
     * location, left over from a previous module version's directory
     * layout. The current version already ships with the module code at
     * its new location, so this is a cleanup step only - not a migration.
     * @param string $relativePath Path relative to the module root, e.g. "passwords.txt" or "some/nested/folder". May point to either a file or a folder.
     * @return void
     * @throws WireException
     */
    protected function removeOrphanedDataPath(string $relativePath): void
    {
        $files = $this->wire('files');
        $oldPath = $this->modulePath . ltrim($relativePath, '/');

        if ($files->exists($oldPath, 'dir')) {
            // recursively remove the folder and everything inside it
            $files->rmdir($oldPath, true);
        } elseif ($files->exists($oldPath)) {
            $files->unlink($oldPath);
        }
    }

    /**
     * Run during uninstallation
     * @return void
     * @throws WireException
     */
    public function ___uninstall(): void
    {
        // back up the user-customizable "frameworks" folder (custom CSS
        // class JSON files) into the module BEFORE removing
        // files/FrontendForms/ below - that removal is recursive and
        // would otherwise destroy this folder along with everything else
        // under files/FrontendForms/ before it could be preserved.
        //
        // Only back it up if no custom path is configured
        // (input_customframeworkpath): if the admin has explicitly moved
        // their custom class files elsewhere, this default-location
        // folder is not the active one and not something the module
        // should back up - just remove it.
        $from = $this->wire('config')->paths->assets . 'files/FrontendForms/frameworks/';
        if ($this->input_customframeworkpath) {
            $this->wire('files')->rmdir($from, true);
        } else {
            $to = $this->modulePath . 'assets/frameworks/';
            $this->createFilesDir($from, $to);
            $this->wire('files')->rmdir($from, true);
        }

        // remove site/assets/files/FrontendForms/ outright, without
        // copying it back into the module first: unlike
        // frontendforms-custom-templates below (which may contain genuine
        // admin edits), this folder's contents are just a working copy of
        // the module's own, permanent template images
        // (assets/template-images/), which install() already recreates
        // this folder from on the next install - nothing would be lost by
        // deleting it directly here.
        $from = $this->wire('config')->paths->assets . 'files/FrontendForms/';
        $this->wire('files')->rmdir($from, true);
        // copy files from site/frontendforms-custom-templates to FrontendForms/assets
        $from = $this->wire('config')->paths->site . 'frontendforms-custom-templates/';
        $to = $this->modulePath . 'assets/frontendforms-custom-templates/';
        $this->createFilesDir($from, $to);
        $this->wire('files')->rmdir($from, true);
        // delete captchaimage.php from root
        $this->createRemoveCaptchaImageFile(false); // delete captchaimage.php from root
        // remove passwords.txt - should be downloaded on next installation
        $this->wire('files')->unlink($this->passwordPath);
        // remove stopwords.txt - should be downloaded on next installation
        $this->wire('files')->unlink($this->stopwordPath);
    }



}