/*
 * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 */
package org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer;

import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.MixinNode;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializerFactory;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;

/**
 *
 * Dispatches the serialization process of nodes according to schema and returns
 * the serialized elements.
 *
 * @param <E>
 *            type of serialized elements
 */
public interface NodeSerializerDispatcher<E> {

    Iterable<E> dispatchChildElement(Object childSchema,
            DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild);

    /**
     * Abstract implementation that implements the dispatch conditions. Only
     * requires serializers to be provided. The same instance of serializer can
     * be provided in case it is immutable.
     */
    public static abstract class BaseNodeSerializerDispatcher<E> implements NodeSerializerDispatcher<E> {
        private final FromNormalizedNodeSerializerFactory<E> factory;

        protected BaseNodeSerializerDispatcher(final FromNormalizedNodeSerializerFactory<E> factory) {
            this.factory = Preconditions.checkNotNull(factory);
        }

        @Override
        public final Iterable<E> dispatchChildElement(Object childSchema,
                DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
            if (dataContainerChild instanceof ContainerNode) {
                return onContainerNode(childSchema, dataContainerChild);
            } else if (dataContainerChild instanceof LeafNode<?>) {
                return onLeafNode(childSchema, dataContainerChild);
            } else if (dataContainerChild instanceof AnyXmlNode) {
                return onAnyXmlNode(childSchema, dataContainerChild);
            } else if (dataContainerChild instanceof MixinNode) {
                if (dataContainerChild instanceof LeafSetNode<?>) {
                    return onLeafListNode(childSchema, dataContainerChild);
                } else if (dataContainerChild instanceof MapNode) {
                    return onListNode(childSchema, dataContainerChild);
                } else if (dataContainerChild instanceof ChoiceNode) {
                    return onChoiceNode(childSchema, dataContainerChild);
                } else if (dataContainerChild instanceof AugmentationNode) {
                    return onAugmentationSchema(childSchema, dataContainerChild);
                }
            }
            throw new IllegalArgumentException("Unable to serialize " + childSchema);
        }

        private Iterable<E> onAugmentationSchema(Object childSchema,
                DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
            checkSchemaCompatibility(childSchema, AugmentationSchema.class, dataContainerChild);
            return factory.getAugmentationNodeSerializer().serialize((AugmentationSchema) childSchema,
                    (AugmentationNode) dataContainerChild);
        }

        private Iterable<E> onChoiceNode(Object childSchema,
                DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
            checkSchemaCompatibility(childSchema, org.opendaylight.yangtools.yang.model.api.ChoiceNode.class,
                    dataContainerChild);
            return factory.getChoiceNodeSerializer()
                    .serialize((org.opendaylight.yangtools.yang.model.api.ChoiceNode) childSchema,
                            (ChoiceNode) dataContainerChild);
        }

        private Iterable<E> onListNode(Object childSchema,
                DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
            checkSchemaCompatibility(childSchema, ListSchemaNode.class, dataContainerChild);
            return factory.getMapNodeSerializer().serialize((ListSchemaNode) childSchema, (MapNode) dataContainerChild);
        }

        private Iterable<E> onLeafListNode(Object childSchema,
                DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
            checkSchemaCompatibility(childSchema, LeafListSchemaNode.class, dataContainerChild);
            return factory.getLeafSetNodeSerializer().serialize((LeafListSchemaNode) childSchema,
                    (LeafSetNode<?>) dataContainerChild);
        }

        private Iterable<E> onLeafNode(Object childSchema,
                DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
            checkSchemaCompatibility(childSchema, LeafSchemaNode.class, dataContainerChild);
            Iterable<E> elements = factory.getLeafNodeSerializer().serialize((LeafSchemaNode) childSchema,
                    (LeafNode<?>) dataContainerChild);
            checkOnlyOneSerializedElement(elements, dataContainerChild);
            return elements;
        }

        private Iterable<E> onAnyXmlNode(Object childSchema,
                DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
            checkSchemaCompatibility(childSchema, AnyXmlSchemaNode.class, dataContainerChild);
            Iterable<E> elements = factory.getAnyXmlNodeSerializer().serialize((AnyXmlSchemaNode) childSchema,
                    (AnyXmlNode) dataContainerChild);
            checkOnlyOneSerializedElement(elements, dataContainerChild);
            return elements;
        }

        private static void checkOnlyOneSerializedElement(Iterable<?> elements,
                DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
            final int size = Iterables.size(elements);
            Preconditions.checkArgument(size == 1,
                    "Unexpected count of elements for entry serialized from: %s, should be 1, was: %s",
                    dataContainerChild, size);
        }

        private Iterable<E> onContainerNode(Object childSchema,
                DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
            checkSchemaCompatibility(childSchema, ContainerSchemaNode.class, dataContainerChild);

            Iterable<E> elements = factory.getContainerNodeSerializer().serialize((ContainerSchemaNode) childSchema,
                    (ContainerNode) dataContainerChild);
            checkOnlyOneSerializedElement(elements, dataContainerChild);
            return elements;
        }

        private static void checkSchemaCompatibility(Object childSchema, Class<?> containerSchemaNodeClass,
                DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
            Preconditions.checkArgument(containerSchemaNodeClass.isAssignableFrom(childSchema.getClass()),
                    "Incompatible schema: %s with node: %s, expected: %s", childSchema, dataContainerChild,
                    containerSchemaNodeClass);
        }
    }
}