/*
 * 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.eclipse.sisu.plexus;

import javax.inject.Inject;
import javax.inject.Singleton;

import java.io.StringReader;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.Module;
import com.google.inject.TypeLiteral;
import com.google.inject.spi.TypeConverter;
import com.google.inject.spi.TypeConverterBinding;
import org.apache.maven.api.xml.XmlNode;
import org.apache.maven.internal.xml.XmlNodeBuilder;
import org.codehaus.plexus.util.xml.Xpp3Dom;
import org.codehaus.plexus.util.xml.pull.MXParser;
import org.codehaus.plexus.util.xml.pull.XmlPullParser;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
import org.eclipse.sisu.Priority;
import org.eclipse.sisu.bean.BeanProperties;
import org.eclipse.sisu.bean.BeanProperty;
import org.eclipse.sisu.inject.Logs;
import org.eclipse.sisu.inject.TypeArguments;

/**
 * {@link PlexusBeanConverter} {@link Module} that converts Plexus XML configuration into beans.
 */
@Singleton
@Priority(10)
@Deprecated
public final class PlexusXmlBeanConverter implements PlexusBeanConverter {
    // ----------------------------------------------------------------------
    // Constants
    // ----------------------------------------------------------------------

    private static final String CONVERSION_ERROR = "Cannot convert: \"%s\" to: %s";

    // ----------------------------------------------------------------------
    // Implementation fields
    // ----------------------------------------------------------------------

    private final Collection<TypeConverterBinding> typeConverterBindings;

    // ----------------------------------------------------------------------
    // Constructors
    // ----------------------------------------------------------------------

    @Inject
    PlexusXmlBeanConverter(final Injector injector) {
        typeConverterBindings = injector.getTypeConverterBindings();
    }

    // ----------------------------------------------------------------------
    // Public methods
    // ----------------------------------------------------------------------

    @SuppressWarnings({"unchecked", "rawtypes"})
    public Object convert(final TypeLiteral role, final String value) {
        if (value.trim().startsWith("<")) {
            try {
                final MXParser parser = new MXParser();
                parser.setInput(new StringReader(value));
                parser.nextTag();

                return parse(parser, role);
            } catch (final Exception e) {
                throw new IllegalArgumentException(String.format(CONVERSION_ERROR, value, role), e);
            }
        }

        return convertText(value, role);
    }

    // ----------------------------------------------------------------------
    // Implementation methods
    // ----------------------------------------------------------------------

    /**
     * Parses a sequence of XML elements and converts them to the given target type.
     *
     * @param parser The XML parser
     * @param toType The target type
     * @return Converted instance of the target type
     */
    private Object parse(final MXParser parser, final TypeLiteral<?> toType) throws Exception {
        parser.require(XmlPullParser.START_TAG, null, null);

        final Class<?> rawType = toType.getRawType();
        if (XmlNode.class.isAssignableFrom(rawType)) {
            return XmlNodeBuilder.build(parser);
        }
        if (Xpp3Dom.class.isAssignableFrom(rawType)) {
            return new Xpp3Dom(XmlNodeBuilder.build(parser));
        }
        if (Properties.class.isAssignableFrom(rawType)) {
            return parseProperties(parser);
        }
        if (Map.class.isAssignableFrom(rawType)) {
            return parseMap(parser, TypeArguments.get(toType.getSupertype(Map.class), 1));
        }
        if (Collection.class.isAssignableFrom(rawType)) {
            return parseCollection(parser, TypeArguments.get(toType.getSupertype(Collection.class), 0));
        }
        if (rawType.isArray()) {
            return parseArray(parser, TypeArguments.get(toType, 0));
        }
        return parseBean(parser, toType, rawType);
    }

    /**
     * Parses a sequence of XML elements and converts them to the appropriate {@link Properties} type.
     *
     * @param parser The XML parser
     * @return Converted Properties instance
     */
    private static Properties parseProperties(final XmlPullParser parser) throws Exception {
        final Properties properties = newImplementation(parser, Properties.class);
        while (parser.nextTag() == XmlPullParser.START_TAG) {
            parser.nextTag();
            // 'name-then-value' or 'value-then-name'
            if ("name".equals(parser.getName())) {
                final String name = parser.nextText();
                parser.nextTag();
                properties.put(name, parser.nextText());
            } else {
                final String value = parser.nextText();
                parser.nextTag();
                properties.put(parser.nextText(), value);
            }
            parser.nextTag();
        }
        return properties;
    }

    /**
     * Parses a sequence of XML elements and converts them to the appropriate {@link Map} type.
     *
     * @param parser The XML parser
     * @return Converted Map instance
     */
    private Map<String, Object> parseMap(final MXParser parser, final TypeLiteral<?> toType) throws Exception {
        @SuppressWarnings("unchecked")
        final Map<String, Object> map = newImplementation(parser, HashMap.class);
        while (parser.nextTag() == XmlPullParser.START_TAG) {
            map.put(parser.getName(), parse(parser, toType));
        }
        return map;
    }

    /**
     * Parses a sequence of XML elements and converts them to the appropriate {@link Collection} type.
     *
     * @param parser The XML parser
     * @return Converted Collection instance
     */
    private Collection<Object> parseCollection(final MXParser parser, final TypeLiteral<?> toType) throws Exception {
        @SuppressWarnings("unchecked")
        final Collection<Object> collection = newImplementation(parser, ArrayList.class);
        while (parser.nextTag() == XmlPullParser.START_TAG) {
            collection.add(parse(parser, toType));
        }
        return collection;
    }

    /**
     * Parses a sequence of XML elements and converts them to the appropriate array type.
     *
     * @param parser The XML parser
     * @return Converted array instance
     */
    private Object parseArray(final MXParser parser, final TypeLiteral<?> toType) throws Exception {
        // convert to a collection first then convert that into an array
        final Collection<?> collection = parseCollection(parser, toType);
        final Object array = Array.newInstance(toType.getRawType(), collection.size());

        int i = 0;
        for (final Object element : collection) {
            Array.set(array, i++, element);
        }

        return array;
    }

    /**
     * Parses a sequence of XML elements and converts them to the appropriate bean type.
     *
     * @param parser The XML parser
     * @return Converted bean instance
     */
    private Object parseBean(final MXParser parser, final TypeLiteral<?> toType, final Class<?> rawType)
            throws Exception {
        final Class<?> clazz = loadImplementation(parseImplementation(parser), rawType);

        // simple bean? assumes string constructor
        if (parser.next() == XmlPullParser.TEXT) {
            final String text = parser.getText();

            // confirm element doesn't contain nested XML
            if (parser.next() != XmlPullParser.START_TAG) {
                return convertText(text, clazz == rawType ? toType : TypeLiteral.get(clazz));
            }
        }

        if (String.class == clazz) {
            // mimic plexus: discard any strings containing nested XML
            while (parser.getEventType() == XmlPullParser.START_TAG) {
                final String pos = parser.getPositionDescription();
                Logs.warn("Expected TEXT, not XML: {}", pos, new Throwable());
                parser.skipSubTree();
                parser.nextTag();
            }
            return "";
        }

        final Object bean = newImplementation(clazz);

        // build map of all known bean properties belonging to the chosen implementation
        final Map<String, BeanProperty<Object>> propertyMap = new HashMap<>();
        for (final BeanProperty<Object> property : new BeanProperties(clazz)) {
            final String name = property.getName();
            if (!propertyMap.containsKey(name)) {
                propertyMap.put(name, property);
            }
        }

        while (parser.getEventType() == XmlPullParser.START_TAG) {
            // update properties inside the bean, guided by the cached property map
            final BeanProperty<Object> property = propertyMap.get(Roles.camelizeName(parser.getName()));
            if (property != null) {
                property.set(bean, parse(parser, property.getType()));
                parser.nextTag();
            } else {
                throw new XmlPullParserException("Unknown bean property: " + parser.getName(), parser, null);
            }
        }

        return bean;
    }

    /**
     * Parses an XML element looking for the name of a custom implementation.
     *
     * @param parser The XML parser
     * @return Name of the custom implementation; otherwise {@code null}
     */
    private static String parseImplementation(final XmlPullParser parser) {
        return parser.getAttributeValue(null, "implementation");
    }

    /**
     * Attempts to load the named implementation, uses default implementation if no name is given.
     *
     * @param name The optional implementation name
     * @param defaultClazz The default implementation type
     * @return Custom implementation type if one was given; otherwise default implementation type
     */
    private static Class<?> loadImplementation(final String name, final Class<?> defaultClazz) {
        if (null == name) {
            return defaultClazz; // just use the default type
        }

        // TCCL allows surrounding container to influence class loading policy
        final ClassLoader tccl = Thread.currentThread().getContextClassLoader();
        if (tccl != null) {
            try {
                return tccl.loadClass(name);
            } catch (final Exception e) {
                // drop through...
            } catch (final LinkageError e) {
                // drop through...
            }
        }

        // assume custom type is in same class space as default
        final ClassLoader peer = defaultClazz.getClassLoader();
        if (peer != null) {
            try {
                return peer.loadClass(name);
            } catch (final Exception e) {
                // drop through...
            } catch (final LinkageError e) {
                // drop through...
            }
        }

        try {
            // last chance - classic model
            return Class.forName(name);
        } catch (final Exception e) {
            throw new TypeNotPresentException(name, e);
        } catch (final LinkageError e) {
            throw new TypeNotPresentException(name, e);
        }
    }

    /**
     * Creates an instance of the given implementation using the default constructor.
     *
     * @param clazz The implementation type
     * @return Instance of given implementation
     */
    private static <T> T newImplementation(final Class<T> clazz) {
        try {
            return clazz.newInstance();
        } catch (final Exception e) {
            throw new IllegalArgumentException("Cannot create instance of: " + clazz, e);
        } catch (final LinkageError e) {
            throw new IllegalArgumentException("Cannot create instance of: " + clazz, e);
        }
    }

    /**
     * Creates an instance of the given implementation using the given string, assumes a public string constructor.
     *
     * @param clazz The implementation type
     * @param value The string argument
     * @return Instance of given implementation, constructed using the given string
     */
    private static <T> T newImplementation(final Class<T> clazz, final String value) {
        try {
            return clazz.getConstructor(String.class).newInstance(value);
        } catch (final Exception e) {
            final Throwable cause = e instanceof InvocationTargetException ? e.getCause() : e;
            throw new IllegalArgumentException(String.format(CONVERSION_ERROR, value, clazz), cause);
        } catch (final LinkageError e) {
            throw new IllegalArgumentException(String.format(CONVERSION_ERROR, value, clazz), e);
        }
    }

    /**
     * Creates an instance of the implementation named in the current XML element, or the default if no name is given.
     *
     * @param parser The XML parser
     * @param defaultClazz The default implementation type
     * @return Instance of custom implementation if one was given; otherwise instance of default type
     */
    @SuppressWarnings("unchecked")
    private static <T> T newImplementation(final XmlPullParser parser, final Class<T> defaultClazz) {
        return (T) newImplementation(loadImplementation(parseImplementation(parser), defaultClazz));
    }

    /**
     * Converts the given string to the target type, using {@link TypeConverter}s registered with the {@link Injector}.
     *
     * @param value The string value
     * @param toType The target type
     * @return Converted instance of the target type
     */
    private Object convertText(final String value, final TypeLiteral<?> toType) {
        final String text = value.trim();

        final Class<?> rawType = toType.getRawType();
        if (rawType.isAssignableFrom(String.class)) {
            return text; // compatible type => no conversion needed
        }

        // use temporary Key as quick way to auto-box primitive types into their equivalent object types
        final TypeLiteral<?> boxedType =
                rawType.isPrimitive() ? Key.get(rawType).getTypeLiteral() : toType;

        for (final TypeConverterBinding b : typeConverterBindings) {
            if (b.getTypeMatcher().matches(boxedType)) {
                return b.getTypeConverter().convert(text, toType);
            }
        }

        // last chance => attempt to create an instance of the expected type: use the string if non-empty
        return text.length() == 0 ? newImplementation(rawType) : newImplementation(rawType, text);
    }
}
