/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.apache.cocoon.el.impl.objectmodel;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.Map;

import org.apache.cocoon.el.objectmodel.ObjectModel;
import org.apache.cocoon.el.objectmodel.ObjectModelProvider;
import org.apache.commons.collections.ArrayStack;
import org.apache.commons.collections.KeyValue;
import org.apache.commons.collections.MultiMap;
import org.apache.commons.collections.iterators.ReverseListIterator;
import org.apache.commons.collections.keyvalue.DefaultKeyValue;
import org.apache.commons.collections.map.AbstractMapDecorator;
import org.apache.commons.collections.map.MultiValueMap;
import org.apache.commons.jxpath.DynamicPropertyHandler;
import org.apache.commons.jxpath.JXPathBeanInfo;
import org.apache.commons.jxpath.JXPathIntrospector;

/**
 * Prototype implementation of {@link ObjectModel} interface. It <b>must</b> be initialized manually for now.
 *
 */
public class ObjectModelImpl extends AbstractMapDecorator implements ObjectModel {
    //FIXME: It seems that there is no easy way to reuse MuliValueMap

    private static final String SEGMENT_SEPARATOR = "/";

    private ArrayStack localContexts;
    private Map singleValueMap;
    private MultiMap multiValueMap;
    private MultiMap multiValueMapForLocated;
    private Map initialEntries;

    //FIXME: This is a temporary solution
    private boolean modified;


    public ObjectModelImpl() {
        singleValueMap = new HashMap();
        //FIXME: Not sure if this makes sense
        //super.map = UnmodifiableMap.decorate(singleValueMap);
        super.map = singleValueMap;
        localContexts = new ArrayStack();
        multiValueMap = MultiValueMap.decorate(new HashMap(), StackReversedIteration.class);
        multiValueMapForLocated = MultiValueMap.decorate(new HashMap(), StackReversedIteration.class);
    }

    public static class StackReversedIteration extends ArrayStack {

        public Iterator iterator() {
            return new ReverseListIterator(this);
        }

        public ListIterator listIterator() {
            throw new UnsupportedOperationException();
        }
    }

    public Object get(Object key) {
        //FIXME: This should be done more elegantly
        if ("this".equals(key)) {
            return this;
        }

        return super.get(key);
    }

    public MultiMap getAll() {
        return UnmodifiableMultiMap.decorate(multiValueMap);
    }

    public Object put(Object key, Object value) {
        modified = true;
        if (!localContexts.empty()) {
            ((ArrayStack) localContexts.peek()).push(new DefaultKeyValue(key, value));
        }

        singleValueMap.put(key, value);
        multiValueMap.put(key, value);

        return value;
    }

    public void putAll(Map mapToCopy) {
        modified = true;
        if (!localContexts.empty()) {
            ArrayStack entries = (ArrayStack)localContexts.peek();
            for (Iterator keysIterator = mapToCopy.keySet().iterator(); keysIterator.hasNext();) {
                Object key = keysIterator.next();
                entries.push(new DefaultKeyValue(key, mapToCopy.get(key)));
            }
        }

        singleValueMap.putAll(mapToCopy);
        multiValueMap.putAll(mapToCopy);
    }

    /**
     * Locates map at given path
     * @param path where Map can be found
     * @param createIfNeeded indicates if map(s) should be created if no corresponding found
     * @return located Map or null if <code>createIfNeeded</code> is false and Map cannot be found
     */
    private Map locateMapAt(String path, boolean createIfNeeded) {
        if (path.lastIndexOf(SEGMENT_SEPARATOR) == -1) {
            return this;
        }

        Map map = this;
        int segmentBegin = 0;
        int segmentEnd = path.indexOf(SEGMENT_SEPARATOR);
        while (segmentEnd != -1) {
            String key = path.substring(segmentBegin, segmentEnd);
            if (map.containsKey(key)) {
                Object obj = map.get(key);
                if (!(obj instanceof Map)) {
                    throw new ClassCastException("Object at path " + path.substring(0, segmentEnd) + "is not a Map");
                }

                map = (Map)obj;
            } else {
                if (!createIfNeeded) {
                    return null;
                }

                Map newMap = new HashMap();
                map.put(key, newMap);
                map = newMap;
            }
            segmentBegin = segmentEnd + 1;
            segmentEnd = path.indexOf(SEGMENT_SEPARATOR, segmentBegin);
        }

        return map;
    }

    public void putAt(String path, Object value) {
        if (path == null) {
            throw new NullPointerException("Path cannot be null.");
        }
        if (path.length() == 0) {
            throw new IllegalArgumentException("Path cannot be empty");
        }

        Map map = locateMapAt(path, true);
        String key = path.substring(path.lastIndexOf(SEGMENT_SEPARATOR) + 1, path.length());
        if (!localContexts.empty()) {
            ((ArrayStack) localContexts.peek()).push(new PathValue(path, value));
        }
        map.put(key, value);
    }

    private void removeAt(String path, Object value) {
        if (path == null) {
            throw new NullPointerException("Path cannot be null.");
        }
        if (path.length() == 0) {
            throw new IllegalArgumentException("Path cannot be empty");
        }

        Map map = locateMapAt(path, false);
        String key = path.substring(path.lastIndexOf(SEGMENT_SEPARATOR) + 1, path.length());
        if (map == null) {
            return;
        }

        multiValueMapForLocated.remove(key, value);
        if (multiValueMap.containsKey(key)) {
            map.put(key, ((StackReversedIteration) multiValueMap.get(key)).peek());
        } else {
            map.remove(key);
        }
    }

    public void cleanupLocalContext() {
        if (localContexts.empty()) {
            throw new IllegalStateException("Local contexts stack is empty");
        }

        ArrayStack removeEntries = (ArrayStack)localContexts.pop();
        while (!removeEntries.isEmpty()) {
            if (removeEntries.peek() instanceof PathValue) {
                PathValue entry = (PathValue)removeEntries.pop();
                removeAt(entry.getPath(), entry.getValue());
            } else {
                KeyValue entry = (KeyValue)removeEntries.pop();
                Object key = entry.getKey();
                Object value = entry.getValue();

                multiValueMap.remove(key, value);
                if (multiValueMap.containsKey(key)) {
                    singleValueMap.put(key, ((StackReversedIteration) multiValueMap.get(key)).peek());
                } else {
                    singleValueMap.remove(key);
                }
            }
        }
    }

    public void markLocalContext() {
        localContexts.push(new ArrayStack());
    }

    public Map getInitialEntries() {
        return initialEntries;
    }

    public void setInitialEntries(Map initialEntries) {
        if (this.initialEntries != null) {
            throw new IllegalStateException("Object Model has initial entries set already.");
        }

        this.initialEntries = initialEntries;
        for (Iterator keysIterator = initialEntries.keySet().iterator(); keysIterator.hasNext(); ) {
            Object key = keysIterator.next();
            put(key, ((ObjectModelProvider)initialEntries.get(key)).getObject());
        }

        this.modified = false;
    }

    public void fillContext() {
        // Hack: I use jxpath to populate the context object's properties
        // in the jexl context
        Object contextObject = get(CONTEXTBEAN);
        if (contextObject == null) {
            //nothing to do
            return;
        }

        // FIXME Exception Handling
        final JXPathBeanInfo bi =
            JXPathIntrospector.getBeanInfo(contextObject.getClass());
        if (bi.isDynamic()) {
            Class cl = bi.getDynamicPropertyHandlerClass();
            try {
                DynamicPropertyHandler h =
                    (DynamicPropertyHandler) cl.newInstance();
                String[] result = h.getPropertyNames(contextObject);
                int len = result.length;
                for (int i = 0; i < len; i++) {
                    try {
                        put(result[i], h.getProperty(contextObject, result[i]));
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            PropertyDescriptor[] props =  bi.getPropertyDescriptors();
            int len = props.length;
            for (int i = 0; i < len; i++) {
                try {
                    Method read = props[i].getReadMethod();
                    if (read != null) {
                        put(props[i].getName(),
                            read.invoke(contextObject, null));
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private final class PathValue {
        private String path;
        private Object value;

        public PathValue(String path, Object value) {
            this.path = path;
            this.value = value;
        }

        public String getPath() {
            return this.path;
        }

        public Object getValue() {
            return this.value;
        }

    }

    /* (non-Javadoc)
     * @see ObjectModel#setParent(ObjectModel)
     */
    public void setParent(ObjectModel parentObjectModel) {
        if (this.modified) {
            throw new IllegalStateException("Setting parent may occur only if Object Model is empty.");
        }

        singleValueMap.putAll(parentObjectModel);
        multiValueMap.putAll(parentObjectModel.getAll());
    }
}