/*
 *  Copyright 2019 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.data.type;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Stream;

import org.apache.cocoon.xml.AttributesImpl;
import org.apache.cocoon.xml.XMLUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Triple;
import org.w3c.dom.Element;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.cms.data.Reference;
import org.ametys.core.model.type.AbstractElementType;
import org.ametys.core.model.type.ModelItemTypeHelper;
import org.ametys.runtime.model.ViewItem;
import org.ametys.runtime.model.compare.DataChangeType;
import org.ametys.runtime.model.compare.DataChangeTypeDetail;
import org.ametys.runtime.model.exception.BadItemTypeException;
import org.ametys.runtime.model.type.DataContext;

/**
 * Abstract class for reference type of elements
 */
public abstract class AbstractReferenceElementType extends AbstractElementType<Reference>
{
    /** The separator between the type and the value for the string representation of a reference */
    protected static final String __SEPARATOR = "#";
    
    @Override
    public Reference convertValue(Object value) throws BadItemTypeException
    {
        if (value instanceof String)
        {
            String strValue = (String) value;
            if (StringUtils.isEmpty(strValue))
            {
                return null;
            }
            
            if (strValue.startsWith(__SEPARATOR))
            {
                strValue = strValue.substring(1);
                String referenceValue = StringUtils.substringAfter(strValue, __SEPARATOR);
                String referenceType = StringUtils.substringBefore(strValue, __SEPARATOR);
                return new Reference(referenceValue, referenceType);
            }
            else
            {
                return new Reference(strValue);
            }
        }
        
        return super.convertValue(value);
    }
    
    @Override
    public String toString(Reference value)
    {
        if (value != null)
        {
            // If the type is the reference default type, do not export it
            if (value.getType().equals(Reference.DEFAULT_TYPE))
            {
                return value.getValue();
            }
            
            return __SEPARATOR + value.getType() + __SEPARATOR + value.getValue();
        }
        else
        {
            return null;
        }
    }
    
    @SuppressWarnings("unchecked")
    public Object fromJSONForClient(Object json, DataContext context)
    {
        if (json == null)
        {
            return json;
        }
        else if (json instanceof String)
        {
            return convertValue(json);
        }
        else if (json instanceof Map)
        {
            return _json2Reference((Map<String, Object>) json);
        }
        else if (json instanceof List)
        {
            List<Object> jsonList = (List<Object>) json;
            Reference[] result = new Reference[jsonList.size()];
            for (int i = 0; i < jsonList.size(); i++)
            {
                Object singleJSON = jsonList.get(i);
                if (singleJSON instanceof Map)
                {
                    result[i] = _json2Reference((Map<String, Object>) singleJSON);
                }
                else if (singleJSON instanceof String)
                {
                    result[i] = convertValue(singleJSON);
                }
                else
                {
                    throw new IllegalArgumentException("Try to convert the non reference JSON object '" + json + "' into a reference");
                }
            }
            return result;
        }
        else
        {
            throw new IllegalArgumentException("Try to convert the non reference JSON object '" + json + "' into a reference");
        }
    }
    
    private Reference _json2Reference(Map<String, Object> json)
    {
        // If the reference is empty, return null
        return Optional.ofNullable(json)
                       .filter(reference -> !reference.isEmpty()
                            && reference.get(Reference.VALUE_IDENTIFIER) != null && reference.get(Reference.VALUE_IDENTIFIER) instanceof String
                            && reference.get(Reference.TYPE_IDENTIFIER) == null || reference.get(Reference.TYPE_IDENTIFIER) instanceof String)
                       .map(reference -> new Reference((String) reference.get(Reference.VALUE_IDENTIFIER), (String) reference.get(Reference.TYPE_IDENTIFIER)))
                       .orElse(null);
    }
    
    @Override
    protected Object _singleValueToJSON(Reference value, DataContext context)
    {
        Map<String, Object> referenceInfos = new HashMap<>();
        
        referenceInfos.put(Reference.VALUE_IDENTIFIER, value.getValue());
        referenceInfos.put(Reference.TYPE_IDENTIFIER, value.getType());
        
        return referenceInfos;
    }
    
    @Override
    protected Reference _singleValueFromXML(Element element, Optional<Object> additionalData)
    {
        String type = element.getAttribute(Reference.TYPE_IDENTIFIER);
        String value = element.getTextContent();
        return new Reference(value, type);
    }
    
    @Override
    protected void _singleValueToSAX(ContentHandler contentHandler, String tagName, Reference value, Optional<ViewItem> viewItem, DataContext context, AttributesImpl attributes) throws SAXException
    {
        AttributesImpl localAttributes = new AttributesImpl(attributes);
        localAttributes.addCDATAAttribute("type", value.getType());
        XMLUtils.createElement(contentHandler, tagName, localAttributes, value.getValue());
    }
    
    @Override
    protected Stream<Triple<DataChangeType, DataChangeTypeDetail, String>> _compareMultipleValues(Reference[] value1, Reference[] value2)
    {
        throw new UnsupportedOperationException("Unable to compare multiple values of type '" + getId() + "'");
    }
    
    @Override
    protected Stream<Triple<DataChangeType, DataChangeTypeDetail, String>> _compareSingleValues(Reference value1, Reference value2)
    {
        if (ModelItemTypeHelper.areSingleObjectsBothNotNullAndDifferents(value1, value2))
        {
            return Stream.of
                         (
                             ModelItemTypeHelper.compareSingleObjects(value1.getType(), value2.getType(), Reference.TYPE_IDENTIFIER),
                             ModelItemTypeHelper.compareSingleObjects(value1.getValue(), value2.getValue(), Reference.VALUE_IDENTIFIER)
                         )
                         .filter(Optional::isPresent)
                         .map(Optional::get);
        }
        else
        {
            return Stream.of(ModelItemTypeHelper.compareSingleObjects(value1, value2, StringUtils.EMPTY))
                         .filter(Optional::isPresent)
                         .map(Optional::get);
        }
    }
    
    public boolean isSimple()
    {
        return false;
    }
    
    @Override
    protected boolean _useJSONForEdition()
    {
        return true;
    }
}