package org.andromda.core.translation.library;

import java.io.BufferedReader;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import org.andromda.core.common.ComponentContainer;
import org.andromda.core.common.ExceptionUtils;
import org.andromda.core.common.XmlObjectFactory;
import org.andromda.core.templateengine.TemplateEngine;
import org.andromda.core.translation.Translator;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.log4j.Logger;

/**
 * The LibraryTranslation object which is the intermediary object between the Library and the child Translation
 * instances.
 *
 * @author Chad Brandon
 * @author Bob Fields
 */
public class LibraryTranslation
{
    private static final Logger logger = Logger.getLogger(LibraryTranslation.class);

    /**
     * The parent library to which this LibraryTranslation belongs.
     */
    private Library library;

    /**
     * After processing by the CartridgeTemplate engine, will contain the processed translation.
     */
    private Translation translation;

    /**
     * The name of this library translation instance.
     */
    private String name;

    /**
     * Gets the name of this LibraryTranslation.
     *
     * @return String
     */
    public String getName()
    {
        return name;
    }

    /**
     * Sets the name.
     *
     * @param name the name
     */
    public void setName(final String name)
    {
        this.name = name;
    }

    /**
     * The path to the template.
     */
    private String template;

    /**
     * Gets the path to the template for this instance.
     *
     * @return String
     */
    public String getTemplate()
    {
        return template;
    }

    /**
     * Sets the path to the template.
     *
     * @param template the path to the template
     */
    public void setTemplate(final String template)
    {
        this.template = template;
    }

    /**
     * Returns the Library that this LibraryTranslation belongs too.
     *
     * @return Library
     */
    public Library getLibrary()
    {
        return library;
    }

    /**
     * Sets the {@link Library} to which this LibraryInstance belongs.
     *
     * @param library
     */
    public void setLibrary(final Library library)
    {
        this.library = library;
    }

    /**
     * The name given to the variable containing the context element.
     */
    private String variable;

    /**
     * Gets the variable name which is made available to the translation template.
     *
     * @return the variable name.
     */
    public String getVariable()
    {
        return this.variable;
    }

    /**
     * Sets the variable name which is made available to the translation template.
     *
     * @param variable the variable name.
     */
    public void setVariable(final String variable)
    {
        this.variable = variable;
    }

    /**
     * The Translator implementation to use. This is required.
     */
    private String translatorClass;

    /**
     * Sets the Translator class that will perform the translation processing.
     *
     * @param translatorClass the class of the translator.
     */
    public void setTranslator(final String translatorClass)
    {
        this.translatorClass = translatorClass;
        final ComponentContainer container = ComponentContainer.instance();
        container.unregisterComponent(translatorClass);
        container.registerComponentType(translatorClass);
    }

    /**
     * Gets the Translator instance that will perform processing of the template.
     *
     * @return Translator
     */
    public Translator getTranslator()
    {
        final String methodName = "LibraryTranslation.getTranslator";
        final Translator translator =
            (Translator)ComponentContainer.instance().findComponent(this.translatorClass, Translator.class);
        if (translator == null)
        {
            throw new LibraryException(
                methodName + " - a translator implementation must be defined, " +
                " please check your translator library --> '" + this.library.getResource() + '\'');
        }
        return translator;
    }

    /**
     * Calls the handlerMethod from a translation fragment. Each handle method must take a String as the first
     * argument (the body of the fragment from the translation template) and a Object for the second argument
     * (the node being parsed that we may need to retrieve any additional information from).
     *
     * @param name the name of the fragment to retrieve.
     * @param node the node Object which from the parsed expression.
     * @param kind the kind of the translation fragment to handle.
     */
    public void handleTranslationFragment(
        final String name,
        final String kind,
        final Object node)
    {
        ExceptionUtils.checkNull("node", node);
        if (this.translation != null && this.getTranslator() != null)
        {
            final String translation = this.getTranslationFragment(name, kind);
            final Fragment fragment = this.translation.getFragment(name);
            if (fragment != null)
            {
                String handlerMethod = fragment.getHandlerMethod();
                if (StringUtils.isNotBlank(handlerMethod))
                {
                    Class[] argTypes = {String.class, Object.class};
                    Method method = null;
                    // add the translation as the first arg
                    Object[] args = {translation, node};

                    try
                    {
                        method = this.getTranslator().getClass().getMethod(handlerMethod, argTypes);

                        method.invoke(
                            this.getTranslator(),
                            args);
                    }
                    catch (final NoSuchMethodException exception)
                    {
                        String errMsg =
                            "the translator '" + this.getTranslator().getClass() + "' must implement the method '" +
                            handlerMethod + '\'' + StringUtils.join(argTypes, ",") + '\'' +
                            " in order to handle processing of the fragment --> '" + name + '\'';
                        logger.error(errMsg);
                    }
                    catch (Throwable throwable)
                    {
                        if (throwable.getCause()!=null)
                        {
                            throwable = throwable.getCause();
                        }
                        // At least output the location where the error happened, not the entire stack trace.
                        StackTraceElement[] trace = throwable.getStackTrace();
                        String location = " AT " + trace[0].getClassName() + '.' + trace[0].getMethodName() + ':' + trace[0].getLineNumber();
                        if (throwable.getMessage()!=null)
                        {
                            location += ' ' + throwable.getMessage();
                        }
                        logger.error(this.getTranslator().getClass() + " " + throwable + " invoking " + this.getTranslator() + " METHOD " + method + " WITH " + Arrays.toString(args) + location + " fragment " + name);
                        throw new LibraryException(throwable);
                    }
                }
            }
        }
    }

    /**
     * Gets the current "translated" value of this fragmentName for resulting from the last processTranslation method
     *
     * @param name the name of the fragment to retrieve.
     * @param kind the kind or type of fragment to retrieve (this is the based on the expression type: body, inv, post,
     *             pre, etc).
     * @return String the value of the translated fragment or null of one wasn't found with the specified name.
     */
    public String getTranslationFragment(
        final String name,
        final String kind)
    {
        String fragment = null;
        if (this.translation != null)
        {
            fragment = this.translation.getTranslated(name, kind);
        }
        return fragment;
    }

    /**
     * The processed translation template as a Reader.
     *
     * @param translationInput
     */
    protected void setTranslation(final Reader translationInput)
    {
        ExceptionUtils.checkNull("translationInput", translationInput);
        try
        {
            this.translation = (Translation)XmlObjectFactory.getInstance(Translation.class).getObject(translationInput);
            this.translation.setLibraryTranslation(this);
        }
        catch (final Throwable throwable)
        {
            throw new LibraryException(throwable);
        }
    }

    /**
     * Processes the template belonging to this LibraryTranslation and returns the Translation objects. If
     * <code>template</code> hasn't been set (i.e. is null, then this method won't do anything but return a null
     * value).
     *
     * @param templateContext any key/value pairs that should be passed to the TemplateEngine while processing the
     *                        translation template.
     * @return Translation the Translation created from the processing the translation template.
     */
    public Translation processTranslation(Map<String, Object> templateContext)
    {
        logger.debug(
            "processing translation template --> '" + this.getTemplate() + '\'' + "' with templateContext --> '" +
            templateContext + '\'');
        if (this.getTemplate() != null)
        {
            if (templateContext == null)
            {
                templateContext = new LinkedHashMap<String, Object>();
            }
            this.getLibrary().populateTemplateContext(templateContext);

            try
            {
                final TemplateEngine engine = this.getLibrary().getTemplateEngine();

                final StringWriter output = new StringWriter();
                engine.processTemplate(
                    this.getTemplate(),
                    templateContext,
                    output);
                final String outputString = output.toString();
                final BufferedReader input = new BufferedReader(new StringReader(outputString));
                if (logger.isDebugEnabled())
                {
                    logger.debug("processed output --> '" + outputString + '\'');
                }

                // load Reader into the translation
                this.setTranslation(input);
            }
            catch (final Throwable throwable)
            {
                throw new LibraryException(throwable);
            }
        }
        return this.translation;
    }

    /**
     * @see Object#toString()
     */
    public String toString()
    {
        return ToStringBuilder.reflectionToString(this);
    }
}