/** Datei: plugins/rest/assets.OLD/js/generator/data/form/group.js **/
/**
 * /data/form/group.js
 *
 * @author         Sparky
 * @copyright      2025 ARUNOX
 * @version        1.0.0
 *
 */

import { generator } from 'plugins/rest/core/generator';
import { router } from 'plugins/rest/core/router';

generator.extend( 'data/form/group', async ( config, data, container ) => {
    const wrapper = document.createElement( 'fieldset' );

    container.append( wrapper );

    wrapper.classList.add( 'form__fieldset' );

    if( config.title ) {
        const legend = document.createElement( 'legend' );
        legend.classList.add( 'form__legend' );
        legend.innerHTML = config.title;
        wrapper.appendChild( legend );

        wrapper.classList.add( 'has-legend' );
    }

    if( config.border !== false ) {
        wrapper.classList.add( 'has-border' );
    }

    for( const contentElement of config.content ) {
        if( contentElement.generator ) {
            await generator.generate( contentElement.generator, contentElement.config, data, wrapper );
        }
    }
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/control/checkbox.js **/
/**
 * generator/data/form/control/checkbox.js
 *
 * Erstellt eine Checkbox-Gruppe mit mehreren auswählbaren Optionen.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separater Generator
 */


import { generator } from 'plugins/rest/core/generator';
import { validator } from 'plugins/rest/core/validator';

generator.extend( 'data/form/control/checkbox', async ( config, data, wrapper ) => {
    const container = document.createElement( 'div' );
    let   value     = config.value || data[ config.key ] || [];
    let   elements  = [];

    if( !Array.isArray( value ) ) {
        value = JSON.parse( value );
    }

    wrapper.append( container );

    container.classList.add( 'form__control__group' );

    if( config.options ) {
        for( const option of config.options ) {
            const label     = document.createElement( 'label' );
            const element   = document.createElement( 'input' );

            element.type        = 'checkbox'
            element.name        = `${ config.key }[]`;
            element.value       = option.value;
            element.checked     = value.includes( option.value );
            element.required    = !!config.required;

            label.classList.add( 'form__control__label' );
            label.innerText     = option.label;

            label.prepend( element );
            container.append( label );

            elements.push( element );
        }
    }

    if( typeof config?.validate?.minChecked === 'undefined' ) {
        if( config.required && config.validate?.required ) {
            config.validate.minChecked = config.validate.required;
        }
    }

    if( typeof config?.validate?.minChecked === 'string' ) {
        config.validate.minChecked = {
            value   : 1,
            message : config.validate.minChecked,
        };
    }

    validator.add( elements, 'checkbox' );

    await generator.generate( 'data/form/additional/defaults', config, data, undefined, wrapper );
    await generator.generate( 'data/form/additional/validate', config, data, elements, wrapper );
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/control/range.js **/
/**
 * generator/data/form/control/range.js
 *
 * Erstellt ein Passwortfeld mit optionaler Bestätigungsprüfung.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separater Generator
 */


import { generator } from 'plugins/rest/core/generator';
import { validator } from 'plugins/rest/core/validator';

generator.extend( 'data/form/control/range', async ( config, data, wrapper ) => {
    const element   = document.createElement( 'input' );

    element.type    = 'range';
    element.name    = config.key;
    element.value   = data[ config.key ] ?? config.value ?? '50';
    element.min     = config.min    ?? '0';
    element.max     = config.max    ?? '100';
    element.step    = config.step   ?? '10';

    await generator.generate( 'data/form/additional/defaults', config, data, element, wrapper );
    await generator.generate( 'data/form/additional/validate', config, data, element, wrapper );

    return element;
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/control/radio.js **/
/**
 * generator/data/form/control/radio.js
 *
 * Erstellt eine Gruppe von Radio-Buttons für eine Einzelauswahl.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separater Generator
 */


import { generator } from 'plugins/rest/core/generator';
import { validator } from 'plugins/rest/core/validator';

generator.extend( 'data/form/control/radio', async ( config, data, wrapper ) => {
    const container = document.createElement( 'div' );
    let   elements  = [];

    wrapper.append( container );

    container.classList.add( 'form__control__group' );

    if( config.options ) {
        for( const option of config.options ) {
            const label     = document.createElement( 'label' );
            const element   = document.createElement( 'input' );

            element.type        = 'radio'
            element.name        = config.key;
            element.value       = option.value;
            element.checked     = option.value == ( config.value || data[ config.key ] );
            element.required    = !!config.required;

            label.classList.add( 'form__control__label' );
            label.innerText     = option.label;

            if( option.icon ) {
                const icon = await generator.generate( 'components/icon', {
                    name    : option.icon,
                    color   : option.color,
                    block   : 'form__control'
                }, {} );

                label.prepend( icon );
            }

            label.prepend( element );
            container.append( label );


            elements.push( element );
        }
    }

    validator.add( elements, 'radio' );

    await generator.generate( 'data/form/additional/defaults', config, data, undefined, wrapper );
    await generator.generate( 'data/form/additional/validate', config, data, elements, wrapper );
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/control/textarea.js **/
/**
 * generator/data/form/control/textarea.js
 *
 * Erstellt ein mehrzeiliges Texteingabefeld (`<textarea>`).
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separater Generator
 * @since           1.1.0   Unterstützung für dynamische Zeilenhöhe (`lines`)
 */


import { generator } from 'plugins/rest/core/generator';
import { router } from 'plugins/rest/core/router';

generator.extend( 'data/form/control/textarea', async ( config, data, wrapper ) => {
    const element   = document.createElement( 'textarea' );

    element.name            = config.key;
    element.innerHTML       = data[ config.key ] || config.value || '';
    element.style.resize    = config.resize || 'none';

    wrapper.style.setProperty( '--lines', config.lines || 1 );

    await generator.generate( 'data/form/additional/defaults', config, data, element, wrapper );
    await generator.generate( 'data/form/additional/validate', config, data, element, wrapper );

    return element;
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/control/progress.js **/
/**
 * generator/data/form/control/progress.js
 *
 * Erstellt ein Passwortfeld mit optionaler Bestätigungsprüfung.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separater Generator
 * @since           1.1.0   Unterstützung für Passwort-Bestätigung hinzugefügt
 */


import { router } from 'plugins/rest/core/router';
import { generator } from 'plugins/rest/core/generator';

generator.extend( 'data/form/control/progress', async ( config, data, wrapper ) => {
    const bar       = document.createElement( 'div' );
    const label     = document.createElement( 'div' );
    const element   = document.createElement( 'div' );
    const width     = data[ config.key ] ?? config.value ?? 0;

    bar.classList.add( 'progress__bar' )
    label.classList.add( 'progress__label' )
    element.classList.add( 'progress__wrapper' )

    bar.style.width = width + '%';

    if( config.color ) bar.style.setProperty( '--progress-color', config.color )

    if( config.api ) {
        router.fetchStream( config.api, data, {}, chunk => {
            bar.style.width = chunk.value + '%';

            if( chunk.label ) label.innerText = chunk.label;
            if( chunk.color ) bar.style.setProperty( '--progress-color', chunk.color );
        });
    }

    if( config.action ) {
        element.addEventListener('click', (event) => {
            event.preventDefault();
            event.stopPropagation();

            handleAction( config.action, {}, data, 'rest' );
        });
    }

    element.append( bar, label );
    wrapper.append( element );

    return element;
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/control/file.js **/
/**
 * /data/form/control/file.js
 *
 * @author         Sparky
 * @copyright      2025 ARUNOX
 * @version        1.0.0
 *
 */

import { generator } from 'plugins/rest/core/generator';
import { router } from 'plugins/rest/core/router';

generator.extend( 'data/form/control/file', async ( config, data, wrapper ) => {
    const element   = document.createElement( 'input' );
    const origin    = document.createElement( 'input' );

    element.type  = config.type;
    element.name  = config.key;

    if( config.accept )     element.accept      = config.accept;
    if( config.multiple )   element.multiple    = true;

    const fileLabel = document.createElement('span' );
    fileLabel.classList.add( 'form__control', 'is-fake-control' );
    fileLabel.innerText = 'Keine Datei ausgewählt';
    wrapper.appendChild( fileLabel );

    fileLabel.addEventListener( 'click', () => element.click() );

    element.addEventListener( 'change', () => {
        if( element.files.length > 0 ) {
            const fileNames = Array.from( element.files ).map( f => f.name ).join(', ');
            fileLabel.innerText = fileNames;
        } else {
            fileLabel.innerText = 'Keine Datei ausgewählt';
        }
    });

    if( data[ config.key ] ) {
        origin.type   = 'hidden';
        origin.name   = config.key;
        origin.value  = data[ config.key ] || "X";

        fileLabel.innerText = origin.value;
        config.required = false;
    }

    await generator.generate( 'data/form/additional/defaults', config, data, element, wrapper );
    await generator.generate( 'data/form/additional/validate', config, data, element, wrapper );

    if( data[ config.key ] ) {
        wrapper.insertBefore( origin, element );
    }

    return element;
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/control/password.js **/
/**
 * generator/data/form/control/password.js
 *
 * Erstellt ein Passwortfeld mit optionaler Bestätigungsprüfung.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separater Generator
 * @since           1.1.0   Unterstützung für Passwort-Bestätigung hinzugefügt
 */


import { generator } from 'plugins/rest/core/generator';
import { validator } from 'plugins/rest/core/validator';

generator.extend( 'data/form/control/password', async ( config, data, wrapper ) => {
    const element   = document.createElement( 'input' );

    element.name  = config.key;
    element.type  = 'password';

    if( config.validate?.confirm ) {
        validator.add( element, 'confirm' );
    }

    if( config.confirm ) {
        const parent    = wrapper.parentNode;

        config.confirm  = Object.assign( {}, config, {
            key         : config.key + '_confirm',
            label       : config.confirm,
            confirm     : false,
        });


        await generator.generate( 'data/form/control', config.confirm, data, parent );
    }

    await generator.generate( 'data/form/additional/defaults', config, data, element, wrapper );
    await generator.generate( 'data/form/additional/validate', config, data, element, wrapper );

    return element;
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/control/code.js **/
/**
 * generator/data/form/control/code.js
 *
 * Erstellt ein mehrzeiliges Texteingabefeld (`<textarea>`).
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separater Generator
 */

import { generator } from 'plugins/rest/core/generator';

generator.extend( 'data/form/control/code', async ( config, data, wrapper ) => {
	const value    = data[config.key] || config.value || '';
	const readonly = config.readonly !== false; // default = true
	const language = config.language || '';     // optional

	if (readonly) {
		const pre  = document.createElement('pre');
		const code = document.createElement('code');

		if (language) {
			code.classList.add(`language-${language}`);
		}

		code.textContent = value;
		pre.appendChild(code);
		wrapper.appendChild(pre);

		// Optional: Highlight.js oder Prism manuell triggern
		// await loadPrism(language);
		await loadHighlightJS();

		if (window.hljs) {
			window.hljs.highlightElement(code);
		} else if (window.Prism) {
			window.Prism.highlightElement(code);
		}
	} else {
		const textarea = document.createElement('textarea');
		textarea.name = config.key;
		textarea.value = value;
		textarea.classList.add('form__control--code-edit');

		// Optional Style
		textarea.style.fontFamily = 'monospace';
		textarea.style.minHeight = '150px';

		wrapper.appendChild(textarea);
	}

	await generator.generate('data/form/additional/defaults', config, data, wrapper.lastChild, wrapper);
	await generator.generate('data/form/additional/validate', config, data, wrapper.lastChild, wrapper);

	return element;
});

async function loadPrism(language) {
	if (!window.Prism) {
		await import('https://cdn.jsdelivr.net/npm/prismjs@1.29.0/prism.min.js');
	}

	if (language && !Prism.languages[language]) {
		try {
			await import(`https://cdn.jsdelivr.net/npm/prismjs@1.29.0/components/prism-${language}.min.js`);
		} catch (e) {
			console.warn(`⚠ Prism: Sprache '${language}' konnte nicht geladen werden.`);
		}
	}
}

const loadHighlightJS = async () => {
	if (window.hljs) return;

	// ✅ Browser-kompatibles Bundle laden
	await new Promise(resolve => {
		const script = document.createElement('script');
		script.src = 'https://cdn.jsdelivr.net/gh/highlightjs/cdn-release@11.8.0/build/highlight.min.js';
		script.onload = resolve;
		document.head.appendChild(script);
	});

	// ✅ CSS-Theme laden (z. B. GitHub-Style)
	const link = document.createElement('link');
	link.rel = 'stylesheet';
	link.href = 'https://cdn.jsdelivr.net/npm/highlight.js@11.9.0/styles/github.min.css';
	document.head.appendChild(link);
};


/** Datei: plugins/rest/assets.OLD/js/generator/data/form/control/select.js **/
/**
 * /data/form/control/select.js
 *
 * @author         Sparky
 * @copyright      2025 ARUNOX
 * @version        1.0.0
 *
 */

import { generator } from 'plugins/rest/core/generator';
import { router } from 'plugins/rest/core/router';

generator.extend( 'data/form/control/select', async ( config, data, wrapper ) => {
    const element   = document.createElement( 'select' );

    element.name  = config.key;

    if( config.choose ) {
        const choose = document.createElement( 'option' );

        choose.innerText    = config.choose;
        choose.selected     = true;
        choose.value        = config.choose_id ?? '';

        element.append( choose );
    }

    if( config.options ) {
        for( const optionConfig of config.options ) {
            const option = document.createElement( 'option' );

            option.value       = optionConfig.value;
            option.innerText   = optionConfig.label;
            option.selected    = optionConfig.value == ( config.value || data[ config.key ] );
            option.disabled    = !!optionConfig.disabled;

            element.append( option );
        }
    }

    await generator.generate( 'data/form/additional/defaults', config, data, element, wrapper );
    await generator.generate( 'data/form/additional/validate', config, data, element, wrapper );

    return element;
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/control.js **/
/**
 * generator/data/form/control.js
 *
 * Zentrale Steuerung für Formularelemente, die weitere Control-Generatoren lädt.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separater Generator
 */


import { generator } from 'plugins/rest/core/generator';
import { router } from 'plugins/rest/core/router';

generator.extend( 'data/form/control', async ( config, data, container ) => {
    const wrapper   = document.createElement( 'div' );
    const template  = `data/form/control/${config.type}`;
    let   element   = null;

    if( config.type != 'hidden' ) {
        container.append( wrapper );
        wrapper.classList.add( 'form__group', `form__control--${config.type}` );
    }

    if( config.label ) {
        const label = document.createElement( 'label' );
        label.classList.add( 'form__label' );
        label.innerHTML = config.label;
        label.htmlFor   = 'control_' + config.key;

        wrapper.appendChild( label );
    }

    if( !await generator.exists( template ) ) {
        element = document.createElement( 'input' );

        element.type        = config.type;
        element.name        = config.key;
        element.value       = data[ config.key ] || config.value || '';
        element.readOnly    = config.readonly || false;

        if( config.type != 'hidden' ) {
            await generator.generate( 'data/form/additional/defaults', config, data, element, wrapper );
            await generator.generate( 'data/form/additional/validate', config, data, element, wrapper );
        }

        if( config.type == 'hidden' ) {
            container.append( element );
        }
    }
    else element = await generator.generate( template, config, data, wrapper );

    // console.log( element );

    if( config.action && element ) {
        element.addEventListener('click', ( event ) => {
            event.preventDefault();
            event.stopPropagation();

            handleAction( config.action, {}, data, 'rest' );
        });
    }

});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/additional/defaults.js **/
/**
 * generator/data/form/additional/validate.js
 *
 * Verarbeitet die Validierungslogik für Formularelemente.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Datei erstellt
 */


import { generator } from 'plugins/rest/core/generator';
import { validator } from 'plugins/rest/core/validator';

generator.extend( 'data/form/additional/defaults', async ( config, data, element, wrapper ) => {
    if( typeof element !== 'undefined' ) {
        element.id      = 'control_' + config.key;

        if( element.hasAttribute( 'readonly' ) )    element.readonly    = true;
        if( element.hasAttribute( 'type' ) )        element.type        = config.type;
        if( element.hasAttribute( 'name' ) )        element.name        = config.key;

        element.classList.add( 'form__control' );

        if( config.required ) {
            element.required = true;
            validator.add( element, 'required' );
        }

        if( validator.exists( config.type ) ) {
            validator.add( element, config.type );
        }

        if( config.validate?.request ) {
            validator.add( element, 'request' );
        }
    }

    if( typeof wrapper !== 'undefined' ) {
        if( config.readonly ) {
            wrapper.classList.add( 'is-readonly' );
        }

        if( config.required ) {
            wrapper.classList.add( 'is-required' );

            const required = document.createElement( 'span' );
            required.classList.add( 'form__info', 'form__info--required' );
            required.innerHTML = typeof config.required === 'string' ? config.required : 'required';

            wrapper.append( required );
        }
    }

    if( typeof element !== 'undefined' && typeof wrapper !== 'undefined' ) {
        wrapper.append( element );

        element.addEventListener( 'focus', () => { wrapper.classList.add( 'has-focus' ); });
        element.addEventListener( 'blur', () => { wrapper.classList.remove( 'has-focus' ); });
    }
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/additional/feedback.js **/
/**
 * /data/form/additional/feedback.js
 *
 * @author         Sparky
 * @copyright      2025 ARUNOX
 * @version        1.0.0
 *
 */

import { generator } from 'plugins/rest/core/generator';

generator.extend( 'data/form/additional/feedback', async ( config, type, valid, wrapper ) => {
	let textField = valid === null ? 'waiting' : 'message';

	wrapper.classList.removeRexEx( /^(is|on|validate)-/ );

	if( type !== 'valid' )	wrapper.classList.add( `validate-${type}` );
	if( valid === null )	wrapper.classList.add( 'on-validate' );
	if( valid === true )	wrapper.classList.add( 'is-valid' );
	if( valid === false )	wrapper.classList.add( 'is-invalid' );


	const feedback = wrapper.querySelector('.form__info--feedback') || document.createElement( 'span' );
	feedback.classList.add( 'form__info', 'form__info--feedback' );
	feedback.innerHTML = '';

	wrapper.append( feedback );

	if( !config.validate ) return;

	if( typeof config.validate[ type ] === 'undefined' ) return;

	if( typeof config.validate[ type ] === 'string' ) {
		feedback.innerHTML = config.validate[ type ];
		return;
	}

	if( typeof config.validate[ type ][ textField ] === 'string' ) {
		feedback.innerHTML = config.validate[ type ][ textField ];
		return;
	}
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/additional/validate.js **/
/**
 * /data/form/additional/validate.js
 *
 * @author         Sparky
 * @copyright      2025 ARUNOX
 * @version        1.0.0
 *
 */

import { generator } from 'plugins/rest/core/generator';
import { router } from 'plugins/rest/core/router';
import { validator } from 'plugins/rest/core/validator';

generator.extend( 'data/form/additional/validate', async ( config, data, element, wrapper ) => {
	if( config.validate === false ) return;

	element.validate = config.validate;

	if( typeof config.validate === 'undefined' ) {
		config.validate = true;
	}

	if( typeof config.validate === 'string' ) {
		const validateType = config.validate;
		config.validate = {};
		config.validate[ validateType ] = true;
	}

	if( typeof config.validate === 'boolean' ) {
		config.validate = {};
	}

	if( typeof wrapper !== 'undefined' ) {
		wrapper.querySelectorAll( '.form__info--feedback' ).forEach( element => element.remove() );
	}

	if( typeof element !== 'undefined' ) {
		if( config.validate?.onCreate ?? false ) 	validator.validateAll( element, config, data, wrapper );
		if( config.validate?.onChange ?? true )  	validator.on( 'change', element, config, data, wrapper );
		if( config.validate?.onBlur ?? false )  	validator.on( 'blur', element, config, data, wrapper );

		validator.on( 'validate', element, config, data, wrapper );
	}
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/validators/checkbox.js **/
/**
 * generator/data/form/validators/checkbox.js
 *
 * Validator für Checkbox-Gruppen mit `minChecked` und `maxChecked` Regeln.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Datei erstellt
 */

import { validator } from 'plugins/rest/core/validator';

validator.extend( 'checkbox', async ( elements, config, data, wrapper ) => {
    const checked       = [ ...elements ].filter( input => input.checked ).length;
    const required      = [ ...elements ].filter( input => input.required ).length;
    const minChecked    = config.validate?.minChecked?.value ?? ( required ? 1 : 0 );
    const maxChecked    = config.validate?.maxChecked?.value ?? checked;

    if( checked < minChecked )  return 'minChecked';
    if( checked > maxChecked )  return 'maxChecked';

    return true;
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/validators/radio.js **/
/**
 * generator/data/form/validators/radio.js
 *
 * Validator für Radio-Button-Gruppen (mindestens eine Auswahl erforderlich).
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Datei erstellt
 */


import { validator } from 'plugins/rest/core/validator';

validator.extend( 'radio', async ( elements, config, data, wrapper ) => {
    if( ![ ...elements ].some( input => input.checked ) ) {
        return 'required';
    }

    return true;
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/validators/confirm.js **/
/**
 * generator/data/form/validators/confirm.js
 *
 * Validator zur Bestätigung von Eingaben (z. B. Passwort-Wiederholung).
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Datei erstellt
 */


import { validator } from 'plugins/rest/core/validator';
import { generator } from 'plugins/rest/core/generator';

validator.extend( 'confirm', async ( element, config, data, wrapper ) => {
    const mainId    = element.id.replace( /_confirm$/, '' );
    const main      = document.querySelector( `#${mainId}` );
    const confirm   = document.querySelector( `#${mainId}_confirm` );

    if( !main || !confirm ) return null;

    if( confirm.value !== main.value ) {
        return 'confirm';
    }

    const other     = element == main ? confirm : main;
    const otherWrap = other.closest('.form__group');

    generator.generate( 'data/form/additional/feedback', config, 'valid', true, otherWrap );

    return true;
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/validators/request.js **/
/**
 * generator/data/form/validators/request.js
 *
 * Validierung über API-Requests zur externen Überprüfung der Eingabe.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Datei erstellt
 */


import { validator } from 'plugins/rest/core/validator';
import { generator } from 'plugins/rest/core/generator';
import { router } from 'plugins/rest/core/router';

validator.extend( 'request', async ( element, config, data, wrapper ) => {
    if( typeof config.validate.request.waiting === 'string' ) {
        generator.generate( 'data/form/additional/feedback', config, 'request', null, wrapper );
    }

    const apiUri = router.parseRoute( config.validate.request, data );
    const result = await router.fetch( apiUri, { value: element.value } );

    if( !result.valid ) {
        return 'request';
    }

    return true;
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/validators/required.js **/
/**
 * generator/data/form/validators/required.js
 *
 * Validator zur Überprüfung, ob ein Feld ausgefüllt wurde.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separater Validator
 */


import { validator } from 'plugins/rest/core/validator';

validator.extend( 'required', async ( element, config, data, wrapper ) => {
    if( !element.value || element.value === '' ) {
        return 'required';
    }

    return true;
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/validators/float.js **/
/**
 * generator/data/form/validators/float.js
 *
 * Validator für Dezimalzahlen mit Punkt oder Komma als Trennzeichen.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Datei erstellt
 */


import { validator } from 'plugins/rest/core/validator';

validator.extend( 'float', async ( element, config, data, wrapper ) => {
    const regex = /^-?\d{1,3}(?:[.,]?\d+)*$/;

    if( !regex.test( element.value ) ) {
        return 'float';
    }

    return true;
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/validators/email.js **/
/**
 * generator/data/form/validators/email.js
 *
 * Validator für die Überprüfung von E-Mail-Adressen.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separater Validator
 */


import { validator } from 'plugins/rest/core/validator';

validator.extend( 'email', async ( element, config, data, wrapper ) => {
    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

    if( !regex.test( element.value ) ) {
        return 'email';
    }

    return true;
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/validators/url.js **/
/**
 * generator/data/form/validators/url.js
 *
 * Validator für URL-Eingaben.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separater Validator
 */


import { validator } from 'plugins/rest/core/validator';

validator.extend( 'url', async ( element, config, data, wrapper ) => {
    const regex = /^(https?:\/\/)?(www\.)?[\w-]+(\.[\w-]+)+([/?#].*)?$/;

    if( !regex.test( element.value ) ) {
        return 'url';
    }

    return true;
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/validators/number.js **/
/**
 * generator/data/form/validators/number.js
 *
 * Validator für numerische Eingaben.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separater Validator
 */


import { validator } from 'plugins/rest/core/validator';

// validator.extend( 'number', async ( element, config, data, wrapper ) => {
//     const regex = /^[0-9]+$/;
//
//     console.log( element, !!element.value.length, !regex.test( element.value ) );
//
//     if( !!element.value.length && !regex.test( element.value ) ) {
//         return 'number';
//     }
//
//     return true;
// });

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/validators/tel.js **/
/**
 * generator/data/form/validators/tel.js
 *
 * Validator für Telefonnummern (internationales Format).
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separater Validator
 */


import { validator } from 'plugins/rest/core/validator';

validator.extend( 'tel', async ( element, config, data, wrapper ) => {
    const regex = /^\+?[0-9\s\-()]{7,15}$/;

    if( element.value && !regex.test( element.value ) ) {
        return 'tel';
    }

    return true;
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/form/form.js **/
/**
 * /data/form/form.js
 *
 * @author         Sparky
 * @copyright      2025 ARUNOX
 * @version        1.0.0
 *
 */

import { generator } from 'plugins/rest/core/generator';
import { router } from 'plugins/rest/core/router';
import { handleAction } from 'plugins/rest/core/helpers';

generator.extend( 'data/form', async ( config, data, container ) => {
    const wrapper = document.createElement( config.action ? 'form' : 'div' );

    wrapper.classList.add( 'form__container' );

    container.append( wrapper );

    if( config.api ) {
        if( !config.api.resolved ) {
            config.api = router.parseRoute( config.api, data );
        }

        data = await router.fetch( config.api );
    }

    if( config.action ) {
        let lastSearchParams = handleRoute.match( /\?(.*)/);
        let formSearchParams = config.action.route.match( /\?(.*)/);

        if( lastSearchParams ) lastSearchParams = new URLSearchParams( lastSearchParams[1] );
        if( formSearchParams ) formSearchParams = new URLSearchParams( formSearchParams[1] );

        if( lastSearchParams ) {
            if( lastSearchParams.has('columns') && ( !formSearchParams || !formSearchParams.has('columns') ) ) {
                if( formSearchParams )  lastSearchParams = '&columns=' + lastSearchParams.get('columns');
                else                    lastSearchParams = '?columns=' + lastSearchParams.get('columns');

                config.action.route += lastSearchParams;
            }
        }

        // console.log( config.action.route );

        wrapper.noValidate = true;
        wrapper.actionConfig = router.parseRoute( config.action, data, {}, 'rest' );
    }

    for( const contentElement of config.content ) {
        if( contentElement.generator ) {
            await generator.generate( contentElement.generator, contentElement.config, data, wrapper );
        }
    }

    if( config.buttons ) {
        const buttons = document.createElement( 'div' );

        buttons.classList.add('form__buttons');

        for( const contentElement of config.buttons ) {

            // console.log( contentElement.config, handleRoute );

            if( contentElement.generator ) {
                await generator.generate( contentElement.generator, contentElement.config, data, buttons );
            }
        }

        wrapper.append( buttons );
    }
});

if( !window.formSubmitListener ) {
    document.addEventListener('submit', async (event) => {
        if( !event.target.matches('form') ) return;

        event.preventDefault();

        const form      = event.target;
        const inputs    = form.querySelectorAll('input, select, textarea');
        const promises  = [];

        inputs.forEach(input => {
            if( typeof input.validate !== 'undefined' ) {
                promises.push(new Promise((resolve) => {
                    input.addEventListener('validationComplete', () => {
                        resolve( !!input.closest('.is-valid') );
                    }, { once: true });

                    input.dispatchEvent( new Event('validate', { bubbles: true } ) );
                }));
            }
        });

        const results   = await Promise.all( promises );
        const isValid   = results.every( result => result );

        if( isValid ) {
            handleAction( form.actionConfig, new FormData( form ), {}, 'rest' );
        }

    });

    window.formSubmitListener = true;
}

/** Datei: plugins/rest/assets.OLD/js/generator/data/chart.js **/
/**
 * generator/data/chart.js
 *
 * Erstellt dynamische Diagramme mit Chart.js basierend auf einer Konfiguration.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         0.0.1
 *
 * @since           1.0.0   Implementierung des Chart-Generators mit Chart.js
 */

import { createElement, loadScript } from 'plugins/rest/core/helpers';

export const generateChartTemplate = async ( mainConfig, data = {}, parentContainer = null ) => {
	const container = createElement('div', ['chart-container']);

	// Titel hinzufügen
	// const chartTitle = createElement('h2', ['chart-title'], {}, config.title || 'Diagramm');
	// container.append(chartTitle);

	const canvas = createElement('canvas');
	container.append(canvas);

	try {
		await loadScript('https://cdn.jsdelivr.net/npm/chart.js');
		const ctx = canvas.getContext('2d');
		new Chart(ctx, {
			type: data.type || mainConfig.type || 'bar',
			data: {
				labels: data.labels,
				datasets: data.datasets
			},
			options: mainConfig.options || {}
		});
	} catch (error) {
		console.error('Fehler beim Laden von Chart.js:', error);
		container.innerHTML = '<p>Fehler beim Laden des Diagramms.</p>';
	}

	parentContainer.append( container );
};


/** Datei: plugins/rest/assets.OLD/js/generator/data/table/toolbar.js **/
/**
 * generator/data/table/toolbar.js
 *
 * Erstellt die Toolbar für die Tabelle (Suchfeld, Buttons etc.).
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.3.1
 *
 * @since           1.3.0   Erstellt als separate Datei
 * @since           1.3.1   Fix: Suchfeld filtert `tr` basierend auf `data-search`
 */

import { generator } from 'plugins/rest/core/generator';
import { sortTable } from './header.js';

generator.extend( 'data/table/toolbar', async ( config, data, tableContainer ) => {
    if( !config.search &&  !Array.isArray( config.buttons ) ) return;

    const toolbarContainer = document.createElement('div');
    toolbarContainer.classList.add('table__toolbar');
    toolbarContainer.elemets = {
        tableContainer  : tableContainer,
        buttonContainer : null,
        searchContainer : null,
        searchInput     : null,
        resetBtn        : null,
    };

    if( config.search || config.filter ) {
        const searchContainer   = document.createElement('div');
        const tableResetBtn     = await generator.generate( 'components/button', {
            color   : 'danger',
            type    : 'button',
            block   : 'table__search',
            title   : 'Filter zurücksetzen',
            icon    : 'bi bi-funnel',
        }, {}, null );

        searchContainer.classList.add('table__search');
        toolbarContainer.appendChild( searchContainer );

        toolbarContainer.elemets.searchContainer    = searchContainer;
        toolbarContainer.elemets.resetBtn           = tableResetBtn;

        if( config.search ) {
            const searchInput = document.createElement('input');
            searchInput.type = 'text';
            searchInput.placeholder = 'Suchen...';
            searchInput.classList.add('table__search__input');

            searchInput.addEventListener('input', () => searchTable( searchInput.value, toolbarContainer.elemets ));
            searchContainer.appendChild( searchInput );

            toolbarContainer.elemets.searchInput        = searchInput;
        }

        tableResetBtn.style.display = 'none';
        tableResetBtn.addEventListener( 'click', () => resetTable( config.filter, toolbarContainer.elemets ) );

        searchContainer.appendChild( tableResetBtn );

        if( config.order.buttons ) {
            for( const btnConfig of config.order.buttons ) {
                const button = await generator.generate( btnConfig.generator, btnConfig.config, {}, searchContainer );

                button.addEventListener( 'click', () => {
                    const table = tableContainer.querySelector('table');
                    button.dataset.order = btnConfig.config.order.order == 'asc' ? 'desc' : 'asc';
                    sortTable( btnConfig.config.order.column, null, button, table );
                });
            }
        }

        if( config.filter ) {
            tableContainer.addEventListener( 'loaded', () => filterTable( config.filter, toolbarContainer.elemets ));
        }
    }

    if( Array.isArray( config.buttons ) ) {
        const buttonContainer = document.createElement('div');
        buttonContainer.classList.add('table__buttons');
        config.buttons.forEach(buttonConfig => {
            generator.generate(buttonConfig.generator, buttonConfig.config, data, buttonContainer);
        });
        toolbarContainer.appendChild(buttonContainer);

        toolbarContainer.elemets.buttonContainer    = buttonContainer;
    }

    tableContainer.appendChild( toolbarContainer );

    return toolbarContainer;
});

function resetTable( config, elements ) {
    const tbody = elements.tableContainer.querySelector('tbody');
    const rows  = elements.tableContainer.querySelectorAll('.table__row');

    rows.forEach(row => {
        row.style.display = null;
    });

    const query  = window.location.hash.match( /\?(.*)/ );
    const hash   = window.location.hash.substring(1).replace( /\?.*/, '' );
    const filter = new URLSearchParams( query ? query[1] : '' );

    for( const [ index, value ] of config.query.entries() ) {
        if( filter.has( index ) && filter.get( index ) == value ) {
            filter.delete( index );
        }
    }

    if( filter.size )   history.pushState(null, null, `#${hash}?${filter.toString()}`);
    else                history.pushState(null, null, `#${hash}`);

    delete config.button.dataset.tabFilter;

    elements.resetBtn.style.display = 'none';

    if( elements.searchInput ) elements.searchInput.value = '';
}

function filterTable( filter, elements ) {
    const tbody = elements.tableContainer.querySelector('tbody');
    const rows  = elements.tableContainer.querySelectorAll('.table__row');

    let visibleRows = [];

    rows.forEach(row => {
        let isVisible = true;

        for( const [ column, value ] of filter.query.entries() ) {
            const filterable    = row.hasAttribute(`data-filter-${column}`);

            if( !filterable ) {
                filter.query.delete( column );
                continue;
            }

            const filterData    = row.getAttribute(`data-filter-${column}`) || '';
            const filterValue   = value.toLowerCase();

            if( isVisible ) isVisible = filterData == filterValue;
        }

        row.style.display = isVisible ? null : 'none';

        if( isVisible ) visibleRows.push( row );
    });

    if( visibleRows.length != rows.length ) elements.resetBtn.style.display = null;

    visibleRows.forEach( row => tbody.appendChild( row ) );
}

function searchTable( searchValue, elements ) {
    const tbody = elements.tableContainer.querySelector('tbody');
    const rows  = elements.tableContainer.querySelectorAll('.table__row');

    searchValue = searchValue.toLowerCase();

    let visibleRows = [];

    rows.forEach(row => {
        const searchData    = row.getAttribute('data-search') || '';
        const isVisible     = searchData.includes(searchValue);

        row.style.display = isVisible ? null : 'none';

        if( isVisible ) {
            visibleRows.push( row );
        }
    });

    if( visibleRows.length != rows.length ) elements.resetBtn.style.display = null;

    visibleRows.forEach( row => tbody.appendChild( row ) );
}

/** Datei: plugins/rest/assets.OLD/js/generator/data/table/header.js **/
/**
 * generator/data/table/header.js
 *
 * Erzeugt den Tabellenkopf (`<thead>`) basierend auf der Konfiguration.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.4.0
 *
 * @since           1.0.0   Erstellt als separate Datei
 * @since           1.3.1   Fix: Sortieren über `order`-Parameter in `table.dataset.config`
 * @since           1.3.2   Fix: Bestehendes `tbody` sortieren, statt komplette Tabelle zu erneuern
 * @since           1.3.3   Verbesserung: `sorting--asc`, `sorting--desc`, `sorting--current` für Sortierrichtung
 * @since           1.3.4   Fix: Originale Sortierlogik aus `table.js` wiederhergestellt + `dataset.order`
 * @since           1.4.0   Nutzung von `Promise.all()` für parallele Header-Generierung
 */


import { generator } from 'plugins/rest/core/generator';

generator.extend('data/table/header', async ( config, data, container ) => {
    const thead = document.createElement('thead');
    const row = document.createElement('tr');

    const headerCells = await Promise.all(
        config.columns.map( async ( column ) => {
            let cell = document.createElement('th' );
            let type = column.type || 'text'

            if( ! await generator.exists(`data/table/column/${type}-header` ) ) {
                type = 'text';
            }

            // await generator.generate(`data/table/column/${type}-header`, { column, config }, data, cell );

            if( column.title ) {
                cell.title = column.title;
            }

            if( column.icon ) {
                const icon = document.createElement('i');
                icon.classList.add('bi', column.icon || 'bi-info-circle');
                cell.appendChild(icon);

                if( !column.label ) {
                    cell.classList.add(`table__header__cell--type-${column.type}-icon`);
                    column.headerIconOnly = true;
                }
            }

            if( column.label ) {
                const labelText	= document.createTextNode( column.label );
                cell.appendChild( labelText );
            }


            cell.classList.add('table__cell', 'table__header__cell', `table__cell--type-${column.type}`);

            if( column.sortable ) {
                cell.classList.add('sortable');
                cell.dataset.key    = column.key;
                cell.dataset.order  = column.order?.order || 'asc';

                cell.addEventListener('click', () => sortTable( column.key, null, cell, container ));
            }

            if( !column.visible ) {
                cell.style.display = "none"; // ❌ Unsichtbar, aber existiert
            }

            return cell;
        }));

    // Alle Header-Zellen auf einmal hinzufügen
    headerCells.forEach(th => row.appendChild(th));

    container.appendChild(row);
});


export async function sortTable( column, order, cell, table ) {
    if (!table) return;

    const tbody = table.querySelector('tbody');

    if (!tbody) return;

    if( !order ) {
        order = cell.dataset.order === 'asc' ? 'desc' : 'asc';
    }

    const config  = table.RESTconfig;
    const columns = config.columns || [];
    const rules   = config.order.rules || {};

    for( const column of columns ) {
        const cells = table.querySelectorAll(`[data-key="${column.key}"]`);

        for( const oldCell of cells ) {
            if( oldCell.tagName == 'TD') {
                const newCell = oldCell.cloneNode(true );
                const rowData = oldCell.closest('tr').rowData;
                const value   = rowData[ column.key ];

                newCell.style.display = column.visible ? '' : 'none'; // 🔄 Sichtbarkeit aus `config` setzen


                newCell.innerHTML = '';

                await generator.generate('data/table/column', { value, column, config }, rowData, newCell, null );

                oldCell.parentNode.replaceChild( newCell, oldCell );

                if( cell == oldCell ) {
                    cell = newCell;
                    console.log( oldCell );
                }
            }
        }
    }

    if( rules[ column ]?.replace ) {
        for( const [ oldCol, newCol ] of Object.entries( rules[ column ].replace ) ) {
            table.querySelectorAll(`td[data-key="${oldCol}"]`).forEach(td => {
                const rowData = td.closest('tr').rowData;
                td.innerHTML = rowData[ newCol ] || ''-'';
                // td.dataset.key = newCol; // Key anpassen
            });
        }
    }

    if( rules[ column ]?.show ) {
        for( const showCol of rules[ column ].show ) {
            table.querySelectorAll(`td[data-key="${showCol}"], th[data-key="${showCol}"]`).forEach(el => {
                el.style.display = ''; // Wieder anzeigen
            });
        }
    }

    if( rules[ column ]?.hide ) {
        for( const hideCol of rules[ column ].hide ) {
            table.querySelectorAll(`td[data-key="${hideCol}"], th[data-key="${hideCol}"]`).forEach(el => {
                el.style.display = 'none'; // Wieder anzeigen
            });
        }
    }

    // Entferne vorherige Sortierklassen
    table.querySelectorAll('.table__header__cell').forEach(cell => {
        cell.classList.remove('sorting--asc', 'sorting--desc', 'sorting--current');
    });

    // Setze neue Sortierklasse
    if( cell ) {
        cell.dataset.order = order;
        cell.classList.add(`sorting--${order}`, 'sorting--current');
    }

    const container = table.closest( '.table__container' );
    if( container ) {
        container.dataset.sortingColumn = column;
        container.dataset.sortingOrder  = order;
    }

    // Reihen sortieren
    const rows = Array.from( tbody.rows );
    rows.sort((rowA, rowB) => {
        let a = rowA.rowData[ column ]?.trim() || '';
        let b = rowB.rowData[ column ]?.trim() || '';

        // Versuche als Zahl zu interpretieren, falls möglich
        if (!isNaN(a) && !isNaN(b)) {
            a = parseFloat(a);
            b = parseFloat(b);
        }

        return order === 'asc' ? String(a).localeCompare(String(b)) : String(b).localeCompare(String(a));
    });

    // Sortierte Reihen neu einfügen
    tbody.innerHTML = '';
    rows.forEach( row => tbody.append( row ) );
}

/** Datei: plugins/rest/assets.OLD/js/generator/data/table/row.js **/
/**
 * generator/data/table/row.js
 *
 * Erzeugt eine Tabellenzeile (`<tr>`) basierend auf der Konfiguration.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.4.4
 *
 * @since           1.0.0   Erstellt als separate Datei
 * @since           1.3.0   `column.action` wird ausgeführt
 * @since           1.3.1   `updateRow()` hinzugefügt für API-gestützte Updates
 * @since           1.3.2   Fix: `column.action` wird nach `updateRow()` erneut registriert
 * @since           1.3.3   Fix: `column`-Generator wiederhergestellt, anstatt `generateCell`
 * @since           1.3.4   `row.js` ruft `column.js` auf und überlässt ihm die `td`-Erstellung
 * @since           1.3.5   Fix: `updateRow()` Debugging & `await` für `generator.generate()` hinzugefügt
 * @since           1.3.6   Fix: `updateRow()` exportiert und `config`-Fehler behoben
 * @since           1.3.7   Fix: `updateRow()` prüft und setzt fehlendes `config.columns`
 * @since           1.3.8   Fix: `updateRow()` liest `config.columns` aus `table.dataset.config`, falls nicht vorhanden
 * @since           1.3.9   Fix: `table__row--updated` wird nach erfolgreichem Update gesetzt und nach 200ms entfernt
 * @since           1.4.0   Fix: `td`-Zellen erhalten `data-key`, um Sortierung zu ermöglichen
 * @since           1.4.3   Fix: `updateRow()` wiederhergestellt, bleibt jetzt dauerhaft bestehen
 * @since           1.4.4   Click-Event für `tr`-Zeilen wiederhergestellt.
 *                          - Falls `config.action` definiert ist, wird `handleClickAction()` ausgeführt.
 *                          - Zeilen reagieren jetzt wieder auf Klicks.
 */

import { updater } from 'plugins/rest/core/updater';
import { generator } from 'plugins/rest/core/generator';
import { handleAction } from 'plugins/rest/core/helpers';
import { sortTable } from './header.js';

generator.extend('data/table/row', async ( config, rowData, container, context ) => {
    let tableRow    = document.createElement('tr');

    if( container.tagName == 'TR') {
        tableRow        = container;
        container       = null;
    }
    else {
        tableRow.dataset.uuid = context.getUUID( context.parent?.route ?? '' );
    }

    // console.log( 'GENERATOR', 'data/table/.row', config, rowData, container );

    tableRow.classList.add('table__row');

    tableRow.RESTconfig     = config;
    tableRow.rowData        = rowData;
    tableRow.innerHTML      = '';

    let searchContent = [];

    for( const column of config.columns || [] ) {
        let value = '-';
        const td = document.createElement('td');

        if( rowData[ column.key ] !== undefined) {
            value = rowData[ column.key ];
        }
        else if( column.key.indexOf('.') > -1 ) {
            let current = rowData;

            for( const key of column.key.split('.') ) {
                current = current[ key ];
            }

            if( current !== undefined ) {
                value = current;
            }
        }

        await generator.generate('data/table/column', { value, column, config }, rowData, td, tableRow );

        td.setAttribute('data-key', column.key); // `data-key` für Sortierung

        if( value !== null ) {
            tableRow.setAttribute(`data-filter-${column.key}`, value.toString().toLowerCase() );
        }

        if( column.searchable ) {
            searchContent.push(td.textContent.trim());
        }

        if( !column.visible ) {
            td.style.display = "none"; // ❌ Unsichtbar, aber existiert
        }

        tableRow.appendChild(td);
    }

    tableRow.setAttribute('data-search', searchContent.join(' ').toLowerCase());

    if( config.action && !tableRow.classList.contains('js--click-bound') ) {
        tableRow.classList.add('cursor--pointer');

        if( tableRow && tableRow.RESTconfig.api.route && config.action.route ) {
            let rowSearchParams  = tableRow.RESTconfig.api.route.match( /\?(.*)/);
            let cellSearchParams = config.action.route.match( /\?(.*)/);

            if( rowSearchParams )   rowSearchParams  = new URLSearchParams( rowSearchParams[1] );
            if( cellSearchParams )  cellSearchParams = new URLSearchParams( cellSearchParams[1] );


            if( rowSearchParams ) {
                if( rowSearchParams.has('columns') && ( !cellSearchParams || !cellSearchParams.has('columns') ) ) {
                    if( cellSearchParams )  rowSearchParams = '&columns=' + rowSearchParams.get('columns');
                    else                    rowSearchParams = '?columns=' + rowSearchParams.get('columns');

                    config.action.route += rowSearchParams;

                }
                // else console.log( cell.RESTconfig.action.route );
            }
            // else console.log( tableRow.RESTconfig.api.route );
        }

        tableRow.addEventListener("click", async ( event ) => {
            if( ['a'].includes( event.target.tagName.toLowerCase() ) ) return false;

            await handleAction( config.action, {}, rowData, 'rest' );
        });

        tableRow.classList.add('js--click-bound');
    }

    if( container ) container.appendChild( tableRow );

    return tableRow;
});

updater.extend( 'data/table/row', async ( element, config, rowData ) => {

    if( !element || !rowData ) {
        console.error('updateRow Fehler: Fehlende Daten', { element, rowData, config });
        return;
    }

    if( !config.columns ) {
        console.error('updateRow Fehler: `config.columns` nicht vorhanden', { config });
        return;
    }

    element.classList.add( 'table__row--updated' );
    setTimeout(() => element.classList.remove('table__row--updated' ), 200 );

    // console.log( 'UPDATER', 'data/table/row', config, rowData, element );

    const newRow = await generator.generate( 'data/table/row', config, rowData, element );

    const container = element.closest( '.table__container' );
    if( container ) {
        const table  = container.querySelector('table');
        const column = container.dataset.sortingColumn;
        const order  = container.dataset.sortingOrder;

        if( column && order && table ) {
            sortTable( column, order, null, table );
        }
    }
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/table/table.js **/
/**
 * generator/data/table/table.js
 *
 * Hauptmodul für Tabellen, das die anderen Generatoren für Header, Zeilen & Toolbar integriert.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.3.5
 *
 * @since           1.0.0   Erstellt als separater Generator
 * @since           1.3.2   `config` wird in `table.dataset.config` gespeichert
 * @since           1.3.3   `reloadTable()` hinzugefügt, um die Tabelle neu zu laden
 * @since           1.3.4   `toolbar.js` integriert, um Suchfeld & Buttons bereitzustellen
 * @since           1.3.5   Fix: `toolbar` korrekt als Generator eingebunden
 */


import { generator } from 'plugins/rest/core/generator';
import { router } from 'plugins/rest/core/router';
import { sortTable } from './header.js';

generator.extend('data/table', async ( config, data, container, context ) => {
    const tableContainer = document.createElement('div');

    tableContainer.classList.add('table__container');

    // Toolbar mit Suchfeld und Buttons
    await generator.generate('data/table/toolbar', config, data, tableContainer );

    // Haupt-Tabelle
    const table         = document.createElement('table');
    const tbody         = document.createElement('tbody');
    const tableUUID     = context.getUUID();
    const generateRows  = async ( data, loading = false ) => {
        const hint = tbody.querySelector('.table__cell--type-hint');

        if( hint ) hint.closest('.table__row').remove();

        if( !loading && data && data.length ) {
            for( const rowData of data ) {
                await context.generate('data/table/row', config, rowData, tbody );
            }

            return;
        }

        const tableRow  = document.createElement('tr');
        const tableCell = document.createElement('td');

        tableCell.colSpan   = config.columns.length;
        tableCell.innerHTML = loading ? 'Daten werden geladen ...' : 'Keine Datensätze gefunden';

        tableRow.classList.add('table__row');
        tableCell.classList.add( 'table__cell', 'table__body__column', 'table__cell--type-hint' );

        tableRow.appendChild( tableCell )
        tbody.appendChild( tableRow )
    };

    table.classList.add('table');

    table.dataset.uuid  = tableUUID;
    table.RESTconfig    = config;

    tableContainer.appendChild( table );

    container.appendChild( tableContainer );

    if( config.columns ) {
        config.columns = config.columns.filter( item => Object.keys(item).length > 0 );
    }

    if( !config.columns ) return;

    if( config.api ) {
        if( !config.api.resolved ) {
            config.api = router.parseRoute( config.api, data );
        }

        router.fetch( config.api ).then( generateRows );

    }

    await generator.generate('data/table/header', config, data, table );
    await generateRows( data, true );

    table.appendChild(tbody);

    // Nach dem Generieren der Rows
    if( config.order && config.order.column ) {
        const headerCell = table.querySelector(`.table__header__cell[data-key="${config.order.column}"]`);
        const container  = table.closest( '.table__container' );

        sortTable( config.order.column, config.order.order, headerCell, table );  // Automatischer Sortieraufruf
    }

    tableContainer.dispatchEvent( new Event('loaded', { bubbles: true }) );
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/table/column.js **/
/**
 * generator/data/table/column.js
 *
 * Erzeugt eine einzelne Tabellenzelle (`<td>`) durch Aufruf des passenden Spalten-Generators.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.4.0
 *
 * @since           1.0.0   Erstellt als separater Generator
 * @since           1.1.0   Wiederhergestellt nach Entfernen von `generateCell`
 * @since           1.2.0   Setzt `td`-Attribute, lädt `column/<type>`, nutzt `column/text` als Fallback
 * @since           1.3.0   Unterstützung für `date`, `time`, `datetime` hinzugefügt
 * @since           1.3.1   Fix: Richtige Datei (`date.js`, `time.js`, `datetime.js`) wird geladen
 * @since           1.4.0   `executeAction()` nutzt jetzt `handleClickAction()` für API-Requests & Routenwechsel.
 */

import { router } from "plugins/rest/core/router";
import { generator } from 'plugins/rest/core/generator';
import { handleAction } from 'plugins/rest/core/helpers';

generator.extend('data/table/column', async ( config, rowData, cell, tableRow ) => {
    cell.classList.add('table__cell', 'table__body__column', `table__cell--type-${config.column.type || 'text'}`);

    cell.RESTconfig   = config.column;

    if( cell.RESTconfig.title ) {
        cell.title = cell.RESTconfig.title;
    }

    if( cell.RESTconfig.action ) {
        cell.style.cursor = 'pointer';

        if( tableRow && tableRow.RESTconfig.api.route && cell.RESTconfig.action.route ) {
            let rowSearchParams  = tableRow.RESTconfig.api.route.match( /\?(.*)/);
            let cellSearchParams = cell.RESTconfig.action.route.match( /\?(.*)/);

            if( rowSearchParams )   rowSearchParams  = new URLSearchParams( rowSearchParams[1] );
            if( cellSearchParams )  cellSearchParams = new URLSearchParams( cellSearchParams[1] );


            if( rowSearchParams ) {
                if( rowSearchParams.has('columns') && ( !cellSearchParams || !cellSearchParams.has('columns') ) ) {
                    if( cellSearchParams )  rowSearchParams = '&columns=' + rowSearchParams.get('columns');
                    else                    rowSearchParams = '?columns=' + rowSearchParams.get('columns');

                    cell.RESTconfig.action.route += rowSearchParams;

                }
                // else console.log( cell.RESTconfig.action.route );
            }
            // else console.log( tableRow.RESTconfig.api.route );
        }

        cell.addEventListener('click', async (event) => {
            event.preventDefault();
            event.stopPropagation();

            await handleAction( cell.RESTconfig.action, {}, rowData, 'rest' );
        });
    }

    // Korrekte Datei basierend auf dem Typ laden
    await generator.generate(`data/table/column/${cell.RESTconfig.type || 'text'}`, config, rowData, cell );

    if( config.column.buttons ) {
        const children  = cell.childNodes;
        const wrapper   = document.createElement('div');
        wrapper.classList.add( 'table__cell__inner' );

        if( children.length ) {
            for( const child of children ) {
                if( child.nodeName === '#text' ) {
                    const text = document.createElement('div');
                    text.classList.add( 'table__cell__inner__text' );
                    text.append( child );
                    wrapper.append( text );
                }
                else wrapper.append( child );
            }
        }

        for( const buttonConfig of config.column.buttons.values() ) {

            if( buttonConfig.config.visibility ) {
                let visible = true;

                for( let [ key, validValues ] of Object.entries( buttonConfig.config.visibility ) ) {

                    if( !validValues.includes( rowData[ key ] ) ) {
                        visible = false;
                        break;
                    }
                }

                if( !visible ) continue;
            }

            await generator.generate( buttonConfig.generator, buttonConfig.config, rowData, wrapper );
        }

        cell.append( wrapper );
    }
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/table/column/date.js **/
/**
 * generator/data/table/column/date.js
 *
 * Zeigt Datumswerte mit anpassbarem Format in Tabellenzellen an.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separate Datei
 */

import { generator } from 'plugins/rest/core/generator';

generator.extend('data/table/column/date', ( config, rowData, cell ) => {
    const value = new Date(config.value);
    cell.textContent = new Intl.DateTimeFormat('de-DE', { year: 'numeric', month: '2-digit', day: '2-digit' }).format(value);
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/table/column/status-header.js **/
/**
 * generator/data/table/column/status-header.js
 *
 * Header-Spaltengenerator für Status-Anzeigen mit Icons.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.1.0
 *
 * @since           1.0.0   Erstellt als separate Datei für Status-Header-Icons
 * @since           1.1.0   Unterstützung für `headerIconOnly`, um nur Icons im Header zu zeigen
 */

import { generator } from 'plugins/rest/core/generator';

generator.extend('data/table/column/status-header', ( config, data, container ) => {

    config.column.headerIconOnly = false;

    if( config.column.title ) {
        container.title = config.column.title;
    }

    if( config.column.icon ) {
        const icon = document.createElement('i');
        icon.classList.add('bi', config.column.icon || 'bi-info-circle');
        container.appendChild(icon);

        if( !config.column.label ) {
            container.classList.add(`table__header__cell--type-${config.column.type}-icon`);
            config.column.headerIconOnly = true;
        }
    }

    if( config.column.label ) {
        const labelText	= document.createTextNode( config.column.label );
        container.appendChild( labelText );
    }
});


/** Datei: plugins/rest/assets.OLD/js/generator/data/table/column/text.js **/
/**
 * generator/data/table/column/text.js
 *
 * Spaltengenerator für normalen Text.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.1.1
 *
 * @since           1.0.0   Erstellt als separater Generator
 * @since           1.1.0   Standard-Fallback für alle Spalten
 * @since           1.1.1   Fix: Kein `<td>` mehr erzeugt, sondern übergebenes `td` manipuliert
 */

import { generator } from 'plugins/rest/core/generator';

generator.extend('data/table/column/text', async ( config, rowData, container ) => {
    let option  = {};
    let icon    = null;

    container.innerHTML = '';

    if( config.column.options ) {
        if( typeof config.column.options === 'object' ) {
            config.column.options = Object.entries( config.column.options );
        }

        option = config.column.options.find( item => item.value == config.value );

        if( option ) {
            config.value = option.label;

            if( option.icon ) {
                icon = await generator.generate( 'components/icon', { name: option.icon }, {}, container );
            }
        }
    }

    if( config.column.color || option?.color ) {
        generator.generate( 'helpers/colorize', config.column?.color ?? {}, option?.color ?? {}, container, icon );
    }

    container.insertAdjacentHTML( 'beforeend', config.value || '-' );
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/table/column/datetime.js **/
/**
 * generator/data/table/column/datetime.js
 *
 * Zeigt Datums- und Zeitwerte mit anpassbarem Format an.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separate Datei
 */

import { generator } from 'plugins/rest/core/generator';

generator.extend('data/table/column/datetime', ( config, rowData, cell ) => {
    if( !config.value ) return;

    const value = new Date(config.value);

    cell.textContent = new Intl.DateTimeFormat('de-DE', { day: '2-digit', month: '2-digit', year: 'numeric', hour: '2-digit', minute: '2-digit' }).format(value);
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/table/column/amount.js **/
/**
 * generator/data/table/column/amount.js
 *
 * Spaltengenerator für normalen Text.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.1.1
 *
 * @since           1.0.0   Erstellt als separater Generator
 * @since           1.1.0   Standard-Fallback für alle Spalten
 * @since           1.1.1   Fix: Kein `<td>` mehr erzeugt, sondern übergebenes `td` manipuliert
 */

import { generator } from 'plugins/rest/core/generator';

generator.extend('data/table/column/amount', async ( config, rowData, container ) => {
    let option  = {};
    let icon    = null;

    container.innerHTML = '';
    container.removeAttribute('title');

    if( config.column.options ) {
        option = config.column.options.find( item => item.value == config.value );

        if( option ) {
            config.value = option.label;

            if( option.icon ) {
                icon = await generator.generate( 'components/icon', { name: option.icon }, {}, container );
            }
        }
    }

    if( config.column.color || option?.color ) {
        generator.generate( 'helpers/colorize', config.column?.color ?? {}, option?.color ?? {}, container, icon );
    }

    container.insertAdjacentHTML( 'beforeend', config.value || '-' );
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/table/column/time.js **/
/**
 * generator/data/table/column/time.js
 *
 * Spaltengenerator für Zeitwerte mit anpassbarem Format.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separate Datei
 */

import { generator } from 'plugins/rest/core/generator';

generator.extend('data/table/column/time', ( config, rowData, cell ) => {
    const value = new Date(config.value);
    cell.textContent = new Intl.DateTimeFormat('de-DE', { hour: '2-digit', minute: '2-digit' }).format(value);
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/table/column/icon.js **/
/**
 * generator/data/table/column/icon.js
 *
 * Spaltengenerator für Icons mit optionalem Tooltip.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.1.1
 *
 * @since           1.0.0   Erstellt als separater Generator
 * @since           1.1.1   Fix: Kein `<td>` mehr erzeugt, sondern übergebenes `td` manipuliert
 */

import { generator } from 'plugins/rest/core/generator';

generator.extend('data/table/column/icon', async ( config, rowData, container ) => {
    let icon        = null;
    let value       = config.value?.value || config.value?.icon || config.value;
    let iconConfig  = config.column.options?.[value] || {};

    if( typeof config.value === 'object' ) {
        iconConfig.icon   = config.value.icon;
        iconConfig.color  = config.value.color;
    }

    // console.log( typeof config.value, !iconConfig.icon, value, config.value, iconConfig, config.column.options );

    if( !iconConfig.icon ) {
        iconConfig.icon     = 'bi bi-question-diamond';
        iconConfig.title    = `${config.column.title} nicht definiert`;
    }

    container.title     = iconConfig.title ?? iconConfig.label ?? '';
    container.innerHTML = '';

    if( config.column.icon ) {
        icon = await generator.generate( 'components/icon', {
            name: iconConfig.icon || 'bi bi-question-diamond'
        }, {}, container );
    }

    generator.generate( 'helpers/colorize', config.column.color, iconConfig.color, container, icon );
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/table/column/status.js **/
/**
 * generator/data/table/column/status.js
 *
 * Spaltengenerator für Status-Anzeigen mit Farb- und Icon-Unterstützung.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.5.0
 *
 * @since           1.0.0   Erstellt als separate Datei
 * @since           1.3.0   `options.label` wird nur genutzt, wenn definiert
 * @since           1.3.1   `options.icon` Standard auf `?` gesetzt
 * @since           1.3.2   `route` als optional für klickbare Spalten
 * @since           1.3.3   `options.icon` Standard auf `question-diamond`, `color`-Option erweitert
 * @since           1.3.4   Farbmanagement überarbeitet: `color.name`, Farbwerte/-namen aus `options`, kontrastbasierte Textfarbe
 * @since           1.3.5   BEM-Klassen für Farbe (`text--<color>`, `icon--<color>`, `bg--<color>`), `color` automatisch erkannt, `background` als Default
 * @since           1.3.6   Fix: `color.target = text` setzt `.text--<color>`, nicht `.bg--<color>`
 * @since           1.3.7   Fix: Kein `<td>` mehr erzeugt, sondern übergebenes `td` manipuliert
 * @since           1.3.8   Fix: Farbe aus `options` wird priorisiert, falls vorhanden
 * @since           1.3.9   Fix: `title`-Attribut immer auf `td`, nicht auf das Icon
 * @since           1.4.0   Fix: `color`-Verarbeitung aus `options.color` wiederhergestellt
 * @since           1.4.1   Unterstützung für Icons ohne Labels in Zellen
 * @since           1.5.0   Neue Klasse `table__column--type-{type}-icon` für `headerIconOnly`
 */


import { generator } from 'plugins/rest/core/generator';

generator.extend('data/table/column/status', async ( config, rowData, container ) => {
    let icon = null;

    container.innerHTML = '';

    const statusConfig  = config.column.options?.[config.value] || { icon: 'bi-question-diamond', title: `${config.column.title} nicht definiert` };

    container.title = statusConfig.title ?? statusConfig.label;

    if( config.column.icon ) {
        icon = await generator.generate( 'components/icon', {
            name: statusConfig.icon || 'bi bi-question-diamond'
        }, {}, container );
    }

    if( config.column.headerIconOnly ) {
        container.classList.add(`table__cell--type-${config.column.type}-icon`);
    }

    // Nur Labels hinzufügen, wenn `headerIconOnly` nicht aktiv ist
    if( !config.column.headerIconOnly && statusConfig.label ) {
        container.appendChild(document.createTextNode(` ${statusConfig.label}`));
    }

    generator.generate( 'helpers/colorize', config.column.color, statusConfig.color, container, icon );
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/table/column/email.js **/
/**
 * generator/data/table/column/email.js
 *
 * Spaltengenerator für E-Mail-Adressen mit mailto-Links.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.1.0
 *
 * @since           1.0.0   Erstellt als separater Generator
 */

import { generator } from 'plugins/rest/core/generator';

generator.extend('data/table/column/email', ( config, rowData, container ) => {
    if (!config.value) {
        container.textContent = '-';
        return;
    }

    const link = document.createElement('a');
    link.href = `mailto:${config.value}`;
    link.textContent = config.value;
    link.classList.add('table__email');

    container.appendChild( link );
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/table/column/text-header.js **/
/**
 * generator/data/table/column/text-header.js
 *
 * Standard-Header-Spaltengenerator für Textspalten.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.0.0
 *
 * @since           1.0.0   Erstellt als separate Datei für generische Text-Header
 */

import { generator } from 'plugins/rest/core/generator';

generator.extend('data/table/column/text-header', ( config, data, container ) => {

    if( config.column.title ) {
        container.title = config.column.title;
    }

    if( config.column.label ) {
        const labelText	= document.createTextNode( config.column.label );
        container.appendChild( labelText );
    }
});


/** Datei: plugins/rest/assets.OLD/js/generator/data/table/column/url.js **/
/**
 * generator/data/table/column/url.js
 *
 * Spaltengenerator für Links innerhalb einer Tabellenzelle.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.1.1
 *
 * @since           1.0.0   Erstellt als separater Generator
 * @since           1.1.0   Standard-Fallback für alle Spalten
 * @since           1.1.1   Fix: Kein `<td>` mehr erzeugt, sondern übergebenes `td` manipuliert
 */

import { generator } from 'plugins/rest/core/generator';

generator.extend('data/table/column/url', ( config, rowData, cell ) => {
    cell.innerHTML = '';
    
    if( !config.value ) {
        cell.textContent = '-';
        return;
    }

    const href = config.column.href || config.value;

    const link = document.createElement('a');
    link.href = href.replace('{id}', rowData.id );
    link.textContent = config.value;
    link.target = '_blank';
    cell.appendChild(link);
});

/** Datei: plugins/rest/assets.OLD/js/generator/data/table/column/actions.js **/
/**
 * generator/data/table/column/actions.js
 *
 * Spaltengenerator für Aktionen/Buttons innerhalb einer Tabellenzelle.
 *
 * @author          Sparky
 * @copyright       2025 ARUNOX
 * @version         1.2.1
 *
 * @since           1.0.0   Erstellt als separater Generator
 * @since           1.2.1   Fix: Kein `<td>` mehr erzeugt, sondern übergebenes `td` manipuliert
 */

import { generator } from 'plugins/rest/core/generator';

generator.extend('data/table/column/actions', async ( config, rowData, container ) => {
    return;

    const wrapper = document.createElement('div');

    wrapper.classList.add( 'table__cell__inner' );

    if( config.column.buttons ) {
        for( const buttonConfig of config.column.buttons.values() ) {

            // if( action.visibleIf ) {
            //     for( let [key, validValues] of Object.entries(action.visibleIf) ) {
            //         if( !validValues.includes(rowData[key]) ) continue 2; // skip this action
            //     }
            // }

            await generator.generate( buttonConfig.generator, buttonConfig.config, rowData, wrapper );
        }
    }

    container.append( wrapper );
});