/*
 *  Copyright 2001-2013 Stephen Colebourne
 *
 *  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.joda.beans.impl.direct;

import java.util.AbstractCollection;
import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.joda.beans.MetaProperty;

/**
 * A map of name to meta-property designed for use by {@code DirectBean}.
 * <p>
 * This meta-property map implementation is designed primarily for code-generation.
 * It stores a reference to the meta-bean and the meta-properties.
 * The meta-properties are accessed using {@link DirectMetaBean#metaPropertyGet(String)}.
 * <p>
 * This class is immutable and thread-safe.
 * 
 * @author Stephen Colebourne
 */
@SuppressWarnings("rawtypes")
public final class DirectMetaPropertyMap implements Map<String, MetaProperty<?>> {

    /** The meta-bean. */
    private final DirectMetaBean metaBean;
    /** The property names. */
    private final Set<String> keys;
    /** The meta-properties. */
    private final Collection<MetaProperty<?>> values;
    /** The map entries. */
    private final Set<Entry<String, MetaProperty<?>>> entries;

    /**
     * Constructor.
     * 
     * @param metaBean  the meta-bean, not null
     * @param parent  the superclass parent, may be null
     * @param propertyNames  the property names, not null
     */
    @SuppressWarnings("unchecked")
    public DirectMetaPropertyMap(final DirectMetaBean metaBean, DirectMetaPropertyMap parent, String... propertyNames) {
        if (metaBean == null) {
            throw new NullPointerException("MetaBean must not be null");
        }
        this.metaBean = metaBean;
        int parentSize = 0;
        final Entry<String, MetaProperty<?>>[] metaProperties;
        if (parent != null) {
            parentSize = parent.size();
            metaProperties = Arrays.copyOf(((Entries) parent.entries).metaProperties, parentSize + propertyNames.length);
        } else {
            metaProperties = new Entry[propertyNames.length];
        }
        for (int i = 0; i < propertyNames.length; i++) {
            metaProperties[i + parentSize] = new AbstractMap.SimpleImmutableEntry(propertyNames[i], metaBean.metaPropertyGet(propertyNames[i]));
        }
        keys = new Keys(metaProperties);
        values = new Values(metaProperties);
        entries = new Entries(metaProperties);
    }

    //-----------------------------------------------------------------------
    @Override
    public int size() {
        return keys.size();
    }

    @Override
    public boolean isEmpty() {
        return size() == 0;
    }

    @SuppressWarnings("unchecked")
    @Override
    public MetaProperty<Object> get(Object propertyName) {
        if (propertyName  instanceof String) {
            return (MetaProperty<Object>) metaBean.metaPropertyGet((String) propertyName);
        }
        return null;
    }

    @Override
    public boolean containsKey(Object propertyName) {
        return propertyName instanceof String &&
                metaBean.metaPropertyGet(propertyName.toString()) != null;
    }

    @Override
    public boolean containsValue(Object value) {
        return value instanceof MetaProperty &&
                metaBean.metaPropertyGet(((MetaProperty<?>) value).name()) != null;
    }

    //-----------------------------------------------------------------------
    @Override
    public MetaProperty<?> put(String key, MetaProperty<?> value) {
        throw new UnsupportedOperationException("DirectBean meta-property map cannot be modified");
    }

    @Override
    public MetaProperty<?> remove(Object key) {
        throw new UnsupportedOperationException("DirectBean meta-property map cannot be modified");
    }

    @Override
    public void putAll(Map<? extends String, ? extends MetaProperty<?>> m) {
        throw new UnsupportedOperationException("DirectBean meta-property map cannot be modified");
    }

    @Override
    public void clear() {
        throw new UnsupportedOperationException("DirectBean meta-property map cannot be modified");
    }

    //-----------------------------------------------------------------------
    @Override
    public Set<String> keySet() {
        return keys;
    }

    @Override
    public Collection<MetaProperty<?>> values() {
        return values;
    }

    @Override
    public Set<Entry<String, MetaProperty<?>>> entrySet() {
        return entries;
    }

    //-----------------------------------------------------------------------
    /**
     * Collection implementation for the keys.
     */
    private static final class Keys extends AbstractSet<String> {
        private final Entry<String, MetaProperty<?>>[] metaProperties;

        private Keys(Entry<String, MetaProperty<?>>[] metaProperties) {
            this.metaProperties = metaProperties;
        }

        @Override
        public Iterator<String> iterator() {
            return new Iterator<String>() {
                private int index;
                @Override
                public boolean hasNext() {
                    return index < metaProperties.length;
                }
                @Override
                public String next() {
                    return metaProperties[index++].getKey();
                }
                @Override
                public void remove() {
                    throw new UnsupportedOperationException();
                }
            };
        }

        @Override
        public int size() {
            return metaProperties.length;
        }
    }

    /**
     * Collection implementation for the values.
     */
    private static final class Values extends AbstractCollection<MetaProperty<?>> {
        private final Entry<String, MetaProperty<?>>[] metaProperties;

        private Values(Entry<String, MetaProperty<?>>[] metaProperties) {
            this.metaProperties = metaProperties;
        }

        @Override
        public Iterator<MetaProperty<?>> iterator() {
            return new Iterator<MetaProperty<?>>() {
                private int index;
                @Override
                public boolean hasNext() {
                    return index < metaProperties.length;
                }
                @Override
                public MetaProperty<?> next() {
                    return metaProperties[index++].getValue();
                }
                @Override
                public void remove() {
                    throw new UnsupportedOperationException();
                }
            };
        }

        @Override
        public int size() {
            return metaProperties.length;
        }
    }

    /**
     * Collection implementation for the entries.
     */
    private static final class Entries extends AbstractSet<Entry<String, MetaProperty<?>>> {
        private final Entry<String, MetaProperty<?>>[] metaProperties;

        private Entries(Entry<String, MetaProperty<?>>[] metaProperties) {
            this.metaProperties = metaProperties;
        }

        @Override
        public Iterator<Entry<String, MetaProperty<?>>> iterator() {
            return new Iterator<Entry<String, MetaProperty<?>>>() {
                private int index;
                @Override
                public boolean hasNext() {
                    return index < metaProperties.length;
                }
                @Override
                public Entry<String, MetaProperty<?>> next() {
                    return metaProperties[index++];
                }
                @Override
                public void remove() {
                    throw new UnsupportedOperationException();
                }
            };
        }

        @Override
        public int size() {
            return metaProperties.length;
        }
    }

}