package org.apache.archiva.common.plexusbridge;

/*
 * 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.
 */

import com.google.inject.AbstractModule;
import org.apache.maven.bridge.MavenRepositorySystem;
import org.codehaus.plexus.DefaultContainerConfiguration;
import org.codehaus.plexus.DefaultPlexusContainer;
import org.codehaus.plexus.PlexusConstants;
import org.codehaus.plexus.PlexusContainerException;
import org.codehaus.plexus.classworlds.ClassWorld;
import org.codehaus.plexus.classworlds.realm.ClassRealm;
import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
import org.eclipse.sisu.inject.TypeArguments;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.inject.Inject;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.List;
import java.util.Map;

/**
 * Simple component which will initiate the plexus shim component
 * to see plexus components inside a guice container.<br>
 * So move all of this here to be able to change quickly if needed.
 *
 * @author Olivier Lamy
 */
@Service( "plexusSisuBridge" )
public class PlexusSisuBridge
{

    private MavenRepositorySystem mavenRepositorySystem = new MavenRepositorySystem();

    private Logger log = LoggerFactory.getLogger( getClass() );

    private boolean containerAutoWiring = true;

    private String containerClassPathScanning = PlexusConstants.SCANNING_INDEX;// PlexusConstants.SCANNING_ON;

    private String containerComponentVisibility = PlexusConstants.REALM_VISIBILITY;

    private URL overridingComponentsXml;

    private ClassRealm containerRealm;

    private DefaultPlexusContainer plexusContainer;

    class InternalBinder extends AbstractModule {

        @Override
        protected void configure( )
        {
            bind( MavenRepositorySystem.class ).toInstance( mavenRepositorySystem );
            // bind(TypeArguments.implicitKey( MavenRepositorySystem.class )).to(MavenRepositorySystem.class);
        }
    }

    @PostConstruct
    public void initialize()
        throws PlexusSisuBridgeException
    {
        DefaultContainerConfiguration conf = new DefaultContainerConfiguration();

        conf.setAutoWiring( containerAutoWiring );
        conf.setClassPathScanning( containerClassPathScanning );
        conf.setComponentVisibility( containerComponentVisibility );

        conf.setContainerConfigurationURL( overridingComponentsXml );

        ClassWorld classWorld = new ClassWorld();

        ClassLoader tccl = Thread.currentThread().getContextClassLoader();

        containerRealm = new ClassRealm( classWorld, "maven", tccl );

        // olamy hackhish but plexus-sisu need a URLClassLoader with URL filled

        if ( tccl instanceof URLClassLoader )
        {
            URL[] urls = ( (URLClassLoader) tccl ).getURLs();
            for ( URL url : urls )
            {
                containerRealm.addURL( url );
                log.debug("Added url {}", url);
            }
        }

        conf.setRealm( containerRealm );

        //conf.setClassWorld( classWorld );

        ClassLoader ori = Thread.currentThread().getContextClassLoader();

        try
        {
            Thread.currentThread().setContextClassLoader( containerRealm );
            InternalBinder binder = new InternalBinder( );
            plexusContainer = new DefaultPlexusContainer( conf, binder );

        }
        catch ( PlexusContainerException e )
        {
            throw new PlexusSisuBridgeException( e.getMessage(), e );
        } catch (Throwable ex) {
            log.error("PlexusSisuBridge initialization failed {}", ex.getMessage(), ex);
            throw new PlexusSisuBridgeException( ex.getMessage(), ex );
        }
        finally
        {
            Thread.currentThread().setContextClassLoader( ori );
        }
    }


    private URL[] getClassLoaderURLs( ClassLoader classLoader )
    {
        try
        {
            // can be WebappClassLoader when using tomcat maven plugin
            //java.net.URL[] getURLs
            Method method = classLoader.getClass().getMethod( "getURLs", new Class[]{ } );
            if ( method != null )
            {
                return (URL[]) method.invoke( classLoader );
            }
        }
        catch ( Exception e )
        {
            log.info( "ignore issue trying to find url[] from classloader {}", e.getMessage() );
        }
        return new URL[]{ };
    }

    public <T> T lookup( Class<T> clazz )
        throws PlexusSisuBridgeException
    {
        ClassLoader ori = Thread.currentThread().getContextClassLoader();
        try
        {
            Thread.currentThread().setContextClassLoader( containerRealm );
            return plexusContainer.lookup( clazz );
        }
        catch ( ComponentLookupException e )
        {
            throw new PlexusSisuBridgeException( e.getMessage(), e );
        }
        finally
        {
            Thread.currentThread().setContextClassLoader( ori );
        }
    }

    public <T> T lookup( Class<T> clazz, String hint )
        throws PlexusSisuBridgeException
    {
        ClassLoader ori = Thread.currentThread().getContextClassLoader();

        try
        {
            Thread.currentThread().setContextClassLoader( containerRealm );
            return plexusContainer.lookup( clazz, hint );
        }
        catch ( ComponentLookupException e )
        {
            throw new PlexusSisuBridgeException( e.getMessage(), e );
        }
        finally
        {
            Thread.currentThread().setContextClassLoader( ori );
        }
    }

    public <T> List<T> lookupList( Class<T> clazz )
        throws PlexusSisuBridgeException
    {
        ClassLoader ori = Thread.currentThread().getContextClassLoader();

        try
        {
            Thread.currentThread().setContextClassLoader( containerRealm );
            return plexusContainer.lookupList( clazz );
        }
        catch ( ComponentLookupException e )
        {
            throw new PlexusSisuBridgeException( e.getMessage(), e );
        }
        finally
        {
            Thread.currentThread().setContextClassLoader( ori );
        }
    }

    public <T> Map<String, T> lookupMap( Class<T> clazz )
        throws PlexusSisuBridgeException
    {
        ClassLoader ori = Thread.currentThread().getContextClassLoader();

        try
        {
            Thread.currentThread().setContextClassLoader( containerRealm );
            return plexusContainer.lookupMap( clazz );
        }
        catch ( ComponentLookupException e )
        {
            throw new PlexusSisuBridgeException( e.getMessage(), e );
        }
        finally
        {
            Thread.currentThread().setContextClassLoader( ori );
        }
    }
}