// Copyright 2006, 2007, 2008, 2009, 2011, 2012 The Apache Software Foundation
//
// Licensed 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.tapestry5.ioc.internal;

import org.apache.tapestry5.ioc.Messages;
import org.apache.tapestry5.ioc.def.ContributionDef;
import org.apache.tapestry5.ioc.def.ContributionDef2;
import org.apache.tapestry5.ioc.def.ServiceDef;
import org.apache.tapestry5.ioc.def.ServiceDef2;
import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
import org.apache.tapestry5.ioc.internal.util.InternalUtils;
import org.apache.tapestry5.ioc.internal.util.MessagesImpl;
import org.apache.tapestry5.plastic.PlasticUtils;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import static org.apache.tapestry5.ioc.internal.util.InternalUtils.asString;

final class IOCMessages
{
    private static final Messages MESSAGES = MessagesImpl.forClass(IOCMessages.class);

    static String buildMethodConflict(String serviceId, String conflict, String existing)
    {
        return MESSAGES.format("build-method-conflict", serviceId, conflict, existing);
    }

    static String serviceWrongInterface(String serviceId, Class actualInterface, Class requestedInterface)
    {
        return MESSAGES.format("service-wrong-interface", serviceId, actualInterface.getName(),
                requestedInterface.getName());
    }

    static String instantiateBuilderError(Class builderClass, Throwable cause)
    {
        return MESSAGES.format("instantiate-builder-error", builderClass.getName(), cause);
    }

    static String noServiceMatchesType(Class serviceInterface)
    {
        return MESSAGES.format("no-service-matches-type", serviceInterface.getName());
    }

    static String manyServiceMatches(Class serviceInterface, List<String> ids)
    {
        StringBuilder buffer = new StringBuilder();

        for (int i = 0; i < ids.size(); i++)
        {
            if (i > 0) buffer.append(", ");

            buffer.append(ids.get(i));
        }

        return MESSAGES.format("many-service-matches", serviceInterface.getName(), ids.size(), buffer.toString());
    }

    static String unknownScope(String name)
    {
        return MESSAGES.format("unknown-scope", name);
    }

    static String decoratorReturnedWrongType(Method method, String serviceId, Object returned, Class serviceInterface)
    {
        return MESSAGES.format("decorator-returned-wrong-type", asString(method), serviceId, returned,
                serviceInterface.getName());
    }

    static String recursiveServiceBuild(ServiceDef def)
    {
        return MESSAGES.format("recursive-service-build", def.getServiceId(), def.toString());
    }

    static String contributionWrongReturnType(Method method)
    {
        return MESSAGES.format("contribution-wrong-return-type", asString(method),
                PlasticUtils.toTypeName(method.getReturnType()));
    }

    static String tooManyContributionParameters(Method method)
    {
        return MESSAGES.format("too-many-contribution-parameters", asString(method));
    }

    static String noContributionParameter(Method method)
    {
        return MESSAGES.format("no-contribution-parameter", asString(method));
    }

    static String contributionMethodError(Method method, Throwable cause)
    {
        return MESSAGES.format("contribution-method-error", asString(method), cause);
    }

    static String contributionWasNull(String serviceId)
    {
        return MESSAGES.format("contribution-was-null", serviceId);
    }

    static String contributionKeyWasNull(String serviceId)
    {
        return MESSAGES.format("contribution-key-was-null", serviceId);
    }


    static String contributionWrongKeyType(String serviceId, Class actualClass,
                                           Class expectedClass)
    {
        return MESSAGES.format("contribution-wrong-key-type", serviceId, actualClass.getName(),
                expectedClass.getName());
    }

    static String tooManyConfigurationParameters(String methodId)
    {
        return MESSAGES.format("too-many-configuration-parameters", methodId);
    }

    static String genericTypeNotSupported(Type type)
    {
        return MESSAGES.format("generic-type-not-supported", type);
    }

    static String contributionDuplicateKey(String serviceId, Object key, ContributionDef existingDef)
    {
        return MESSAGES.format("contribution-duplicate-key", serviceId, key, existingDef);
    }

    static String errorBuildingService(String serviceId, ServiceDef serviceDef, Throwable cause)
    {
        return MESSAGES.format("error-building-service", serviceId, serviceDef, cause);
    }

    static String noPublicConstructors(Class moduleClass)
    {
        return MESSAGES.format("no-public-constructors", moduleClass.getName());
    }

    static String tooManyPublicConstructors(Class moduleClass, Constructor constructor)
    {
        return MESSAGES.format("too-many-public-constructors", moduleClass.getName(), constructor);
    }

    static String recursiveModuleConstructor(Class builderClass, Constructor constructor)
    {
        return MESSAGES.format("recursive-module-constructor", builderClass.getName(), constructor);
    }

    static String constructedConfiguration(Collection result)
    {
        return MESSAGES.format("constructed-configuration", result);
    }

    static String constructedConfiguration(Map result)
    {
        return MESSAGES.format("constructed-configuration", result);
    }

    static String serviceConstructionFailed(ServiceDef serviceDef, Throwable cause)
    {
        return MESSAGES.format("service-construction-failed", serviceDef.getServiceId(), cause);
    }

    static String serviceIdConflict(String serviceId, ServiceDef existing, ServiceDef conflicting)
    {
        return MESSAGES.format("service-id-conflict", serviceId, existing, conflicting);
    }

    static String noConstructor(Class implementationClass, String serviceId)
    {
        return MESSAGES.format("no-constructor", implementationClass.getName(), serviceId);
    }

    static String abstractServiceImplementation(Class implementationClass, String serviceId)
    {
        return MESSAGES.format("abstract-service-implementation", implementationClass.getName(), serviceId);
    }

    static String bindMethodMustBeStatic(String methodId)
    {
        return MESSAGES.format("bind-method-must-be-static", methodId);
    }

    static String errorInBindMethod(String methodId, Throwable cause)
    {
        return MESSAGES.format("error-in-bind-method", methodId, cause);
    }

    static String noAutobuildConstructor(Class clazz)
    {
        return MESSAGES.format("no-autobuild-constructor", clazz.getName());
    }

    private static String toJavaClassNames(List<Class> classes)
    {
        Class[] asArray = classes.toArray(new Class[classes.size()]);
        String[] namesArray = PlasticUtils.toTypeNames(asArray);
        List<String> names = CollectionFactory.newList(namesArray);

        return InternalUtils.joinSorted(names);
    }

    static String noServicesMatchMarker(Class objectType, List<Class> markers)
    {
        return MESSAGES.format("no-services-match-marker",
                PlasticUtils.toTypeName(objectType),
                toJavaClassNames(markers));
    }

    static String manyServicesMatchMarker(Class objectType, List<Class> markers,
                                          Collection<ServiceDef2> matchingServices)
    {
        return MESSAGES.format("many-services-match-marker",
                PlasticUtils.toTypeName(objectType),
                toJavaClassNames(markers),
                InternalUtils.joinSorted(matchingServices));
    }

    static String overlappingServiceProxyProviders()
    {
        return MESSAGES.get("overlapping-service-proxy-providers");
    }

    static String unexpectedServiceProxyProvider()
    {
        return MESSAGES.get("unexpected-service-proxy-provider");
    }

    static String noProxyProvider(String serviceId)
    {
        return MESSAGES.format("no-proxy-provider", serviceId);
    }

    static String contributionForNonexistentService(ContributionDef cd)
    {
        return MESSAGES.format("contribution-for-nonexistent-service", cd, cd.getServiceId());
    }

    static String contributionForUnqualifiedService(ContributionDef2 cd)
    {
        return MESSAGES.format("contribution-for-unqualified-service", cd, cd.getServiceInterface(), cd.getMarkers());
    }
}
