/*
 * 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.brooklyn.core.config;

import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;

import org.apache.brooklyn.core.config.internal.AbstractCollectionConfigKey;
import org.apache.brooklyn.util.collections.MutableSet;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.reflect.TypeParameter;
import com.google.common.reflect.TypeToken;

/** A config key representing a set of values. 
 * If a value is set using this *typed* key, it is _added_ to the set
 * (with a warning issued if a collection is passed in).
 * If a value is set against an equivalent *untyped* key which *is* a collection,
 * it will be treated as a set upon discovery and used as a base to which subkey values are added.
 * If a value is discovered against this key which is not a map or collection,
 * it is ignored.
 * <p>
 * To add all items in a collection, to add a collection as a single element, 
 * to clear the list, or to set a collection (clearing first), 
 * use the relevant {@link SetModification} in {@link SetModifications}.
 * <p>  
 * Specific values can be added in a replaceable way by referring to a subkey.
 */
//TODO Create interface
public class SetConfigKey<V> extends AbstractCollectionConfigKey<Set<V>, Set<Object>, V> {

    private static final long serialVersionUID = 751024268729803210L;
    @SuppressWarnings("unused")
    private static final Logger log = LoggerFactory.getLogger(SetConfigKey.class);

    @SuppressWarnings("serial")
    private static <V> TypeToken<Set<V>> typeTokenFor(TypeToken<V> subType) {
        return new TypeToken<Set<V>>() {}
                 .where(new TypeParameter<V>() {}, subType);
    }

    public static class Builder<V> extends BasicConfigKey.Builder<Set<V>,Builder<V>> {
        protected TypeToken<V> subType;
        
        public Builder(TypeToken<V> subType, String name) {
            super(typeTokenFor(subType), name);
            this.subType = subType;
        }
        public Builder(Class<V> subType, String name) {
            this(TypeToken.of(subType), name);
        }
        public Builder(SetConfigKey<V> key) {
            this(key.getName(), key);
        }
        public Builder(String newName, SetConfigKey<V> key) {
            super(newName, key);
            subType = key.getSubTypeToken();
        }
        @Override
        public Builder<V> self() {
            return this;
        }
        @Override
        @Deprecated
        public Builder<V> name(String val) {
            throw new UnsupportedOperationException("Builder must be constructed with name");
        }
        @Override
        @Deprecated
        public Builder<V> type(Class<Set<V>> val) {
            throw new UnsupportedOperationException("Builder must be constructed with type");
        }
        @Override
        @Deprecated
        public Builder<V> type(TypeToken<Set<V>> val) {
            throw new UnsupportedOperationException("Builder must be constructed with type");
        }
        @Override
        public SetConfigKey<V> build() {
            return new SetConfigKey<V>(this);
        }
    }

    public SetConfigKey(Builder<V> builder) {
        super(builder, builder.subType);
    }

    public SetConfigKey(TypeToken<V> subType, String name) {
        this(subType, name, name, null);
    }

    public SetConfigKey(TypeToken<V> subType, String name, String description) {
        this(subType, name, description, null);
    }

    @SuppressWarnings({ "unchecked" })
    public SetConfigKey(TypeToken<V> subType, String name, String description, Set<? extends V> defaultValue) {
        super(typeTokenFor(subType), subType, name, description, (Set<V>) defaultValue);
    }
    
    public SetConfigKey(Class<V> subType, String name) {
        this(TypeToken.of(subType), name, name, null);
    }

    public SetConfigKey(Class<V> subType, String name, String description) {
        this(TypeToken.of(subType), name, description, null);
    }

    public SetConfigKey(Class<V> subType, String name, String description, Set<? extends V> defaultValue) {
        this(TypeToken.of(subType), name, description, defaultValue);
    }

    @Override
    public String toString() {
        return String.format("%s[SetConfigKey:%s]", name, getTypeName());
    }

    @Override
    protected Set<Object> merge(boolean unmodifiable, Iterable<?>... sets) {
        MutableSet<Object> result = MutableSet.of();
        for (Iterable<?> set: sets) result.addAll(set);
        if (unmodifiable) return result.asUnmodifiable();
        return result;
    }
    
    public interface SetModification<T> extends StructuredModification<SetConfigKey<T>>, Set<T> {
    }
    
    public static class SetModifications extends StructuredModifications {
        /** when passed as a value to a SetConfigKey, causes each of these items to be added.
         * if you have just one, no need to wrap in a mod. */
        // to prevent confusion (e.g. if a set is passed) we require two objects here.
        public static final <T> SetModification<T> add(final T o1, final T o2, @SuppressWarnings("unchecked") final T ...oo) {
            Set<T> l = new LinkedHashSet<T>();
            l.add(o1); l.add(o2);
            for (T o: oo) l.add(o);
            return new SetModificationBase<T>(l, false);
        }
        /** when passed as a value to a SetConfigKey, causes each of these items to be added */
        public static final <T> SetModification<T> addAll(final Collection<T> items) { 
            return new SetModificationBase<T>(items, false);
        }
        /** when passed as a value to a SetConfigKey, causes the items to be added as a single element in the set */
        public static final <T> SetModification<T> addItem(final T item) {
            return new SetModificationBase<T>(Collections.singleton(item), false);
        }
        /** when passed as a value to a SetConfigKey, causes the set to be cleared and these items added */
        public static final <T> SetModification<T> set(final Collection<T> items) { 
            return new SetModificationBase<T>(items, true);
        }
    }

    public static class SetModificationBase<T> extends LinkedHashSet<T> implements SetModification<T> {
        private static final long serialVersionUID = 2715025591272457705L;
        private final boolean clearFirst;
        public SetModificationBase(Collection<T> delegate, boolean clearFirst) {
            super(delegate);
            this.clearFirst = clearFirst;
        }
        @SuppressWarnings({ "rawtypes", "unchecked" })
        @Override
        public Object applyToKeyInMap(SetConfigKey<T> key, Map target) {
            if (clearFirst) {
                StructuredModification<StructuredConfigKey> clearing = StructuredModifications.clearing();
                clearing.applyToKeyInMap(key, target);
            }
            for (T o: this) target.put(key.subKey(), o);
            return null;
        }
    }
}
