/*
 *  Copyright 2023 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.cms.search.ui.model.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

import org.apache.cocoon.ProcessingException;

import org.ametys.cms.search.ui.model.SearchUIColumn;
import org.ametys.cms.search.ui.model.SearchUIColumnHelper;
import org.ametys.plugins.repository.model.CompositeDefinition;
import org.ametys.plugins.repository.model.RepeaterDefinition;
import org.ametys.runtime.model.DefinitionContext;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.ModelViewItem;
import org.ametys.runtime.model.ModelViewItemGroup;
import org.ametys.runtime.model.ViewItem;
import org.ametys.runtime.model.ViewItemAccessor;

/**
 * This class represents a result column
 */
public class RepeaterSearchUIColumn extends ModelViewItemGroup<RepeaterDefinition> implements SearchUIColumn<RepeaterDefinition>
{
    private int _width = -1;
    private boolean _hidden;
    private boolean _editable = true;
    private boolean _sortable = true;
    private boolean _allowSortOnMultipleJoin;
    private Optional<String> _defaultSorter = Optional.empty();
    private Optional<String> _renderer = Optional.empty();
    private Optional<String> _converter = Optional.empty();
    
    public int getWidth()
    {
        return _width > 0
                ? _width
                : SearchUIColumnHelper.getDefaultColumnWidth(this);
    }
    
    public void setWidth (int width)
    {
        _width = width;
    }
    
    public boolean isHidden()
    {
        return _hidden;
    }
    
    public void setHidden (boolean hidden)
    {
        _hidden = hidden;
    }
    
    public boolean isEditable()
    {
        return _editable && SearchUIColumnHelper.isEditionAllowed(this);
    }
    
    public void setEditable (boolean editable)
    {
        _editable = editable;
    }
    
    public boolean isSortable()
    {
        return _sortable && SearchUIColumnHelper.isSortAllowed(this);
    }
    
    public void setSortable (boolean sortable)
    {
        _sortable = sortable;
    }
    
    public boolean allowSortOnMultipleJoin()
    {
        return _allowSortOnMultipleJoin;
    }
    
    public void setAllowSortOnMultipleJoin(boolean allowSortOnMultipleJoin)
    {
        _allowSortOnMultipleJoin = allowSortOnMultipleJoin;
    }
    
    public String getDefaultSorter()
    {
        return isSortable()
                ? _defaultSorter.orElse(null)
                : null;
    }
    
    public void setDefaultSorter(Optional<String> defaultSorter)
    {
        _defaultSorter = defaultSorter;
    }
    
    public String getRenderer()
    {
        return _renderer
                .orElse("Ametys.plugins.cms.search.SearchGridHelper.renderRepeater");
    }
    
    public void setRenderer(Optional<String> renderer)
    {
        this._renderer = renderer;
    }
    
    public String getConverter()
    {
        return _converter
                .orElse("Ametys.plugins.cms.search.SearchGridHelper.convertRepeater");
    }
    
    public void setConverter(Optional<String> converter)
    {
        this._converter = converter;
    }
    
    @Override
    public RepeaterSearchUIColumn createInstance()
    {
        return new RepeaterSearchUIColumn();
    }

    @Override
    public Map<String, Object> toJSON(DefinitionContext context) throws ProcessingException
    {
        Map<String, Object> json = super.toJSON(context);

        if (!json.isEmpty())
        {
            json.putAll(SearchUIColumnHelper.columnPropertiesToJSON(this));
        }
        return json;
    }
    
    @Override
    protected Map<String, Object> _childrenToJSON(DefinitionContext context) throws ProcessingException
    {
        Map<String, Object> result = new HashMap<>();
        List<Map<String, Object>> subColumnsAsJSON = new ArrayList<>();
        
        ViewItemAccessor viewItemAccessor = getViewItems().isEmpty() ? _createRepeaterSearchUIColumn() : this;
        for (ModelViewItem subColumn : _getSubColumns(viewItemAccessor))
        {
            subColumnsAsJSON.add(subColumn.toJSON(context));
        }
        
        result.put("columns", subColumnsAsJSON);
        return result;
    }
    
    private RepeaterSearchUIColumn _createRepeaterSearchUIColumn()
    {
        RepeaterSearchUIColumn repeaterSearchUIColumn = new RepeaterSearchUIColumn();
        repeaterSearchUIColumn.setDefinition(getDefinition());
        
        repeaterSearchUIColumn.addViewItems(_createViewItems(repeaterSearchUIColumn));
        
        return repeaterSearchUIColumn;
    }
    
    private List<ViewItem> _createViewItems(ModelViewItemGroup group)
    {
        List<ViewItem> viewItems = new ArrayList<>();
        
        for (ModelItem modelItem : group.getDefinition().getModelItems())
        {
            if (modelItem instanceof CompositeDefinition compositeDefinition)
            {
                ModelViewItemGroup<CompositeDefinition> compositeViewItem = new ModelViewItemGroup<>();
                compositeViewItem.setDefinition(compositeDefinition);
                
                compositeViewItem.addViewItems(_createViewItems(compositeViewItem));
                
                viewItems.add(compositeViewItem);
            }
            else
            {
                SearchUIColumn column = SearchUIColumnHelper.createModelItemColumn(modelItem);
                viewItems.add(column);
            }
        }
        
        return viewItems;
    }
    
    private List<ModelViewItem> _getSubColumns(ViewItemAccessor viewItemAccessor)
    {
        List<ModelViewItem> subColumns = new ArrayList<>();
        
        org.ametys.plugins.repository.model.ViewHelper.visitView(viewItemAccessor, 
            (element, definition) -> {
                // attribute
                subColumns.add(element);
            },
            (group, definition) -> {
                // composite
                // CMS-10740 - explode composite to have all its children at first level
                subColumns.addAll(_getSubColumns(group));
            },
            (group, definition) -> {
                // repeater
                subColumns.add(group);
            },
            group -> {
                // group
                subColumns.addAll(_getSubColumns(group));
            }
        );
        
        return subColumns;
    }
    
    @Override
    public void copyTo(ViewItem item)
    {
        super.copyTo(item);
        
        assert item instanceof RepeaterSearchUIColumn;
        RepeaterSearchUIColumn column = (RepeaterSearchUIColumn) item;
        
        column.setWidth(_width);
        column.setHidden(_hidden);
        
        column.setEditable(_editable);
        column.setSortable(_sortable);
        column.setAllowSortOnMultipleJoin(_allowSortOnMultipleJoin);
        column.setDefaultSorter(_defaultSorter);
        
        column.setRenderer(_renderer);
        column.setConverter(_converter);
    }
}