/*
 *  Copyright 2020 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.content.version;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.cocoon.ProcessingException;
import org.apache.commons.lang3.NotImplementedException;

import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.AbstractViewItemGroup;
import org.ametys.runtime.model.ElementDefinition;
import org.ametys.runtime.model.ModelViewItemGroup;
import org.ametys.runtime.model.SimpleViewItemGroup;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.ViewElement;
import org.ametys.runtime.model.ViewItem;
import org.ametys.runtime.model.ViewItemContainer;
import org.ametys.runtime.model.ViewItemGroup;

// Wrap another view, to be able to wrap its own ViewElement to modify the ViewElement#toJson
class CompareView implements ViewItemContainer
{
    private final View _wrapped;
    private final Set<String> _externalAndLocalMetadata;
    
    CompareView(View fromView, Set<String> externalAndLocalMetadata)
    {
        _wrapped = new View();
        _populateViewItemContainerWithWrappedElements(fromView, _wrapped);
        _externalAndLocalMetadata = externalAndLocalMetadata;
    }
    
    private void _populateViewItemContainerWithWrappedElements(ViewItemContainer sourceOfCopy, ViewItemContainer toPopulate)
    {
        for (ViewItem viewItem : sourceOfCopy.getViewItems())
        {
            toPopulate.addViewItem(_wrapViewElement(viewItem));
        }
    }
    
    private ViewItem _wrapViewElement(ViewItem item)
    {
        if (item instanceof ViewElement)
        {
            return new CompareViewElement((ViewElement) item);
        }
        else if (item instanceof ModelViewItemGroup)
        {
            return new CompareModelViewItemGroup((ModelViewItemGroup) item);
        }
        else if (item instanceof SimpleViewItemGroup)
        {
            return new CompareSimpleViewItemGroup((SimpleViewItemGroup) item);
        }
        else
        {
            throw new IllegalArgumentException("Unexpected and unhandled ViewItem class '" + item.getClass() + "' to wrap it into a CompareView. Please contact your administrator.");
        }
    }

    @Override
    public List<ViewItem> getViewItems()
    {
        return _wrapped.getViewItems();
    }

    @Override
    public void addViewItem(ViewItem item)
    {
        throw new NotImplementedException("Should not be called");
    }

    @Override
    public void insertViewItem(ViewItem item, int index)
    {
        throw new NotImplementedException("Should not be called");
    }
    
    Map<String, Object> toJSON() throws ProcessingException
    {
        return _wrapped.toJSON();
    }
    
    // Wrap another group, to be able to wrap its own ViewElement to modify the ViewElement#toJson
    private abstract static class AbstractCompareViewItemGroup implements ViewItemGroup
    {
        protected AbstractViewItemGroup _wrapped;
        
        @Override
        public Map<String, Object> toJSON() throws ProcessingException
        {
            return _wrapped.toJSON();
        }

        @Override
        public String getName()
        {
            return _wrapped.getName();
        }

        @Override
        public List<ViewItem> getViewItems()
        {
            return _wrapped.getViewItems();
        }

        @Override
        public void addViewItem(ViewItem item)
        {
            throw new NotImplementedException("Should not be called");
        }

        @Override
        public void insertViewItem(ViewItem item, int index)
        {
            throw new NotImplementedException("Should not be called");
        }

        @Override
        public String getRole()
        {
            return _wrapped.getRole();
        }

        @Override
        public void setRole(String role)
        {
            _wrapped.setRole(role);
        }
    }
    
    private class CompareModelViewItemGroup extends AbstractCompareViewItemGroup
    {
        CompareModelViewItemGroup(ModelViewItemGroup fromGroup)
        {
            var wrapped = new ModelViewItemGroup(); // empty constructor and not ModelViewItemGroup.of(fromGroup.getDefinition()), in order to avoid duplication of view items
            wrapped.setDefinition(fromGroup.getDefinition());
            _wrapped = wrapped;
            _populateViewItemContainerWithWrappedElements(fromGroup, _wrapped);
        }
    }
    
    private class CompareSimpleViewItemGroup extends AbstractCompareViewItemGroup
    {
        CompareSimpleViewItemGroup(SimpleViewItemGroup fromGroup)
        {
            var wrapped = new SimpleViewItemGroup();
            wrapped.setName(fromGroup.getName());
            wrapped.setLabel(fromGroup.getLabel());
            wrapped.setDescription(fromGroup.getDescription());
            wrapped.setRole(fromGroup.getRole());
            _wrapped = wrapped;
            _populateViewItemContainerWithWrappedElements(fromGroup, _wrapped);
        }
    }
    
    // Extends ViewElement, so as to modify the ElementDefinition#toJson
    private class CompareViewElement extends ViewElement
    {
        CompareViewElement(ViewElement wrapped)
        {
            @SuppressWarnings("unchecked")
            CompareElementDefinition compareElementDefinition = new CompareElementDefinition(wrapped.getDefinition());
            setDefinition(compareElementDefinition);
        }
    }
    
    // here we are able to modify the ElementDefinition#toJson as we want
    private class CompareElementDefinition<T> extends ElementDefinition<T>
    {
        CompareElementDefinition(ElementDefinition<T> definitionToCopy)
        {
            super(definitionToCopy);
        }
        
        /*
         * Here is the business logic for what we created all those wrappers
         */
        @Override
        public Map<String, Object> toJSON() throws ProcessingException
        {
            Map<String, Object> elementDefinitionJson = new HashMap<>(super.toJSON());
            
            @SuppressWarnings("unchecked")
            Map<String, I18nizableText> widgetParams = (Map<String, I18nizableText>) elementDefinitionJson.computeIfAbsent("widget-params", __ -> new HashMap<>());
            String widgetToWrap = (String) elementDefinitionJson.get("widget");
            widgetParams.put("comparator-wrapped-widget", new I18nizableText(widgetToWrap));
            elementDefinitionJson.put("widget", "edition.comparison");
            _handleExternal(widgetToWrap, widgetParams);
            
            // for a reason, type can be 'rich-text' while it expects 'rich_text'
            elementDefinitionJson.computeIfPresent("type", (__, type) -> ((String) type).replaceAll("-", "_"));
            
            return elementDefinitionJson;
        }
        
        private void _handleExternal(String widgetToWrap, Map<String, I18nizableText> widgetParams)
        {
            if (_externalAndLocalMetadata.contains(getPath()))
            {
                // Do as in org.ametys.cms.content.GetMetadataSetDefAction.metadataDefinition2JsonObject
                // Should be more generic
                widgetParams.put("comparator-wrapped-widget", new I18nizableText("edition.externalizable"));
                widgetParams.put("wrapped-widget", new I18nizableText(widgetToWrap)); // wrapped widget for externalizable (so, it is wrapped twice)
            }
        }
    }
}