/** Datei: plugins/rest/assets.OLD/js/arunox/_OLD/data/table/row.js **/
/**
 * rest/arunox/generators/data/table/row.js
 *
 * Some Javascript codes without further description
 *
 * @author         Sparky
 * @copyright      2025 ARUNOX
 * @version        1.0.0
 * @since          1.0.0  File is created
 */



// 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/arunox/_OLD/data/table/table.js **/
/**
 * rest/arunox/generators/data/table/table.js
 *
 * Some Javascript codes without further description
 *
 * @author         Sparky
 * @copyright      2025 ARUNOX
 * @version        1.0.0
 * @since          1.0.0  File is created
 */

ARUNOX.Hooks.register( 'generator.data/table->create.OLD', function( [ type, name, hook, config, data ] ) {
    type = 'htmltag';
    name = 'table';
    hook = `${type}.${name}`;

    ARUNOX.Theme.bindHooks( type, name, hook );

    return [ type, name, hook, config, data ];
}, 0 );



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 ) );
}

/** Datei: plugins/rest/assets.OLD/js/arunox/_OLD/data/table/column.js **/
/**
 * rest/arunox/generators/data/table/column.js
 *
 * Some Javascript codes without further description
 *
 * @author         Sparky
 * @copyright      2025 ARUNOX
 * @version        1.0.0
 * @since          1.0.0  File is created
 */

ARUNOX.Registry.generator.register( 'data/table/column', class RestTemplateDefault extends ARUNOX.Theme.Component {
    static htmlTag      = 'td';

    create( config, data ) {
        const cell	    = this;
        const tableRow	= this.parent;

        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();

                ARUNOX.Router.handle( cell.RESTconfig.action, {}, data, 'rest' );
            });
        }

        // Korrekte Datei basierend auf dem Typ laden
        if( !this.hooks.exists( `customize/columns/${config.column.type || 'text'}` ) ) {
            config.column.type = 'text';
        }

        this.apply( `customize/columns/${config.column.type || 'text'}`, config, data );
        // generator.generate(`data/table/column/${cell.RESTconfig.type || 'text'}`, config, data, 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( data[ key ] ) ) {
                            visible = false;
                            break;
                        }
                    }

                    if( !visible ) continue;
                }

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

            cell.append( wrapper );
        }
    }
});