/*
 * 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.felix.ipojo.manipulator.metadata.annotation.model.literal;

import static java.lang.String.format;
import static org.objectweb.asm.Type.getType;

import java.io.Serializable;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.felix.ipojo.manipulator.metadata.annotation.model.AnnotationDiscovery;
import org.apache.felix.ipojo.manipulator.metadata.annotation.model.Playback;
import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.FieldVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Type;

/**
 * User: guillaume
 * Date: 08/07/13
 * Time: 17:15
 */
public class AnnotationPlayback implements Playback {

    public static final List<? extends Class<? extends Serializable>> BOXED_TYPES = Arrays.asList(Byte.class, Long.class, Character.class, Boolean.class, Double.class, Float.class, Integer.class, Short.class);
    private final Annotation m_annotation;
    private final Type m_annotationType;

    public AnnotationPlayback(final Annotation annotation) {
        m_annotation = annotation;
        m_annotationType = Type.getType(annotation.annotationType());
    }

    private Map<String, Object> getValues() {
        Map<String, Object> values = new HashMap<String, Object>();
        for (Method method : m_annotation.annotationType().getDeclaredMethods()) {
            try {
                values.put(method.getName(), method.invoke(m_annotation));
            } catch (Throwable t) {
                throw new IllegalStateException(
                        format("Cannot get value of the %s.%s attribute",
                               m_annotation.annotationType().getSimpleName(),
                               method.getName()),
                        t
                );
            }
        }
        return values;
    }
    public void accept(final FieldVisitor visitor) {
        AnnotationVisitor av = visitor.visitAnnotation(m_annotationType.getDescriptor(),
                                                       true);
        if (av != null) {
            accept(av);
        }
    }

    public void accept(final ClassVisitor visitor) {
        AnnotationVisitor av = visitor.visitAnnotation(m_annotationType.getDescriptor(),
                                                       true);
        if (av != null) {
            accept(av);
        }
    }

    public void accept(final MethodVisitor visitor) {
        AnnotationVisitor av = visitor.visitAnnotation(m_annotationType.getDescriptor(),
                                                       true);
        if (av != null) {
            accept(av);
        }
    }

    public void accept(final MethodVisitor visitor, final int index) {
        AnnotationVisitor av = visitor.visitParameterAnnotation(index,
                                                                m_annotationType.getDescriptor(),
                                                                true);
        if (av != null) {
            accept(av);
        }
    }

    public void accept(final AnnotationDiscovery visitor) {
        AnnotationVisitor av = visitor.visitAnnotation(m_annotationType.getDescriptor());
        if (av != null) {
            accept(av);
        }
    }

    private void accept(final AnnotationVisitor visitor) {
        // As per the ASM doc, visit methods must be called in a given order:
        // 1. visit()
        // 2. visitEnum()
        // 3. visitAnnotation()
        // 4. visitArray()

        // So values must be sorted
        Map<String, Object> values = getValues();
        accept(values, visitor);
        acceptEnum(values, visitor);
        acceptAnnotation(values, visitor);
        acceptArray(values, visitor);

        // Do not forget to visitEnd()
        visitor.visitEnd();

        // TODO This should disappear, only useful for testing
        if (!values.isEmpty()) {
            // We missed something during serialization
            throw new IllegalStateException(
                    format("Attributes of @%s could not be serialized: %s",
                           m_annotation.annotationType().getSimpleName(),
                           values.keySet())
            );
        }
    }

    private void acceptAnnotation(final Map<String, Object> values, final AnnotationVisitor visitor) {
        Map<String, Object> copy = new HashMap<String, Object>(values);
        for (Map.Entry<String, Object> entry : copy.entrySet()) {

            Class<?> type = entry.getValue().getClass();
            if (Annotation.class.isAssignableFrom(type)) {

                Annotation annotation = (Annotation) entry.getValue();
                AnnotationVisitor annotationVisitor = visitor.visitAnnotation(entry.getKey(),
                                                                              getType(annotation.annotationType()).getDescriptor());
                if (annotationVisitor != null) {
                    AnnotationPlayback playback = new AnnotationPlayback(annotation);
                    playback.accept(annotationVisitor);
                }

                values.remove(entry.getKey());
            }
        }
    }

    private void acceptEnum(final Map<String, Object> values, final AnnotationVisitor visitor) {

        Map<String, Object> copy = new HashMap<String, Object>(values);
        for (Map.Entry<String, Object> entry : copy.entrySet()) {

            Class<?> type = entry.getValue().getClass();
            if (type.isEnum()) {
                Enum<?> enumValue = (Enum<?>) entry.getValue();
                visitor.visitEnum(entry.getKey(),
                                  getType(type).getDescriptor(),
                                  enumValue.name());

                values.remove(entry.getKey());
            }
        }
    }

    private void accept(final Map<String, Object> values, final AnnotationVisitor visitor) {

        Map<String, Object> copy = new HashMap<String, Object>(values);
        for (Map.Entry<String, Object> entry : copy.entrySet()) {

            Class<?> type = entry.getValue().getClass();
            if (isSimpleType(type)) {

                // Accept Byte, Boolean, Character, Short, Integer, Long, Float, Double
                // Accept String
                // Accept Array of byte, boolean, char, short, int, long, float, double
                visitor.visit(entry.getKey(), transform(entry.getValue()));

                values.remove(entry.getKey());
            }
        }
    }

    private boolean isSimpleType(final Class<?> type) {
        return isPrimitive(type) ||
                String.class.equals(type) ||
                Class.class.equals(type) ||
                (type.isArray() && isPrimitive(type.getComponentType()));
    }

    private boolean isPrimitive(final Class<?> type) {
        if (type.isPrimitive()) {
            return true;
        }

        if (BOXED_TYPES.contains(type)) {
            return true;
        }

        return false;
    }

    private void acceptArray(final Map<String, Object> values, final AnnotationVisitor visitor) {
        Map<String, Object> copy = new HashMap<String, Object>(values);
        for (Map.Entry<String, Object> entry : copy.entrySet()) {

            Class<?> type = entry.getValue().getClass();
            if (type.isArray()) {

                // Simple arrays have been visited using AnnotationVisitor.visit(String, Object)

                AnnotationVisitor arrayVisitor = visitor.visitArray(entry.getKey());
                if (arrayVisitor != null) {
                    Object[] array = (Object[]) entry.getValue();
                    Class<?> componentType = array.getClass().getComponentType();
                    Type asmType = Type.getType(componentType);

                    if (componentType.isEnum()) {
                        for (Object o : array) {
                            Enum eValue = (Enum) o;
                            arrayVisitor.visitEnum(null, asmType.getDescriptor(), eValue.name());
                        }
                    } else if (componentType.isAnnotation()) {
                        for (Object o : array) {
                            Annotation annotation = (Annotation) o;
                            AnnotationVisitor annotationVisitor = arrayVisitor.visitAnnotation(null, asmType.getDescriptor());
                            if (annotationVisitor != null) {
                                AnnotationPlayback playback = new AnnotationPlayback(annotation);
                                playback.accept(annotationVisitor);
                            }
                        }
                    } else {
                        for (Object o : array) {
                            arrayVisitor.visit(null, transform(o));
                        }
                    }

                    arrayVisitor.visitEnd();
                }

                values.remove(entry.getKey());
            }
        }
    }

    private Object transform(final Object value) {
        if (value instanceof Class) {
            return getType((Class) value);
        }
        return value;
    }
}