/*
 *  Copyright 2012 Chris Pheby
 *
 *  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.jadira.scanner.classfile;

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.List;
import java.util.WeakHashMap;

import javassist.bytecode.ClassFile;

import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import org.jadira.scanner.classfile.filter.ClassFileFilter;
import org.jadira.scanner.classfile.filter.NameFilter;
import org.jadira.scanner.classfile.filter.PackageFileFilter;
import org.jadira.scanner.classpath.projector.ClasspathProjector;
import org.jadira.scanner.core.api.Allocator;
import org.jadira.scanner.core.api.Projector;
import org.jadira.scanner.core.helper.JavassistClassFileHelper;
import org.jadira.scanner.core.spi.AbstractFileResolver;
import org.jadira.scanner.core.utils.reflection.ClassLoaderUtils;
import org.jadira.scanner.file.locator.JdkBaseClasspathUrlLocator;

import de.schlichtherle.io.FileInputStream;

public class ClassFileResolver extends AbstractFileResolver<ClassFile> {

    private static final WeakHashMap<File, ClassFile> CACHED_CLASSFILES = new WeakHashMap<File, ClassFile>();
    
	private static final Projector<File> CLASSPATH_PROJECTOR = ClasspathProjector.SINGLETON;
	
    private static final List<URL> JDK_BASE_CLASSPATH_JARS = new JdkBaseClasspathUrlLocator().locate();

	private final ClassFileAssigner assigner = new ClassFileAssigner();

	private final ClassLoader[] classLoaders;
	
    public ClassFileResolver() {    	
        this.classLoaders  = ClassLoaderUtils.getClassLoaders();
	}
    
    public ClassFileResolver(ClassLoader... classLoaders) {    	
        super(JDK_BASE_CLASSPATH_JARS);
        this.classLoaders  = ClassLoaderUtils.getClassLoaders(classLoaders);
	}
	
	public ClassFileResolver(List<URL> classpaths, ClassLoader... classLoaders) {
		super(JDK_BASE_CLASSPATH_JARS);
		getDriverData().addAll(classpaths);
		this.classLoaders  = ClassLoaderUtils.getClassLoaders(classLoaders);
	}

	@Override
	public String toString() {

		ToStringBuilder builder = new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE);
		builder.append(getDriverData().toArray());

		return builder.toString();
	}

	@Override
	protected Allocator<ClassFile, File> getAssigner() {
		return assigner;
	}

	private final class ClassFileAssigner implements Allocator<ClassFile, File> {

		@Override
		public ClassFile allocate(File e) {

		    ClassFile res = CACHED_CLASSFILES.get(e);
		    if (res != null) {
		        return res;
		    }
		    
			FileInputStream tis = null;
			
			try {
				tis = new FileInputStream(e);
				res = JavassistClassFileHelper.constructClassFileForPath(e.getPath(), tis);
				CACHED_CLASSFILES.put(e, res);
				return res;
			} catch (FileNotFoundException e1) {
				throw new IllegalArgumentException(e + " is not a valid File", e1);
			} catch (IOException e1) {
				throw new IllegalArgumentException("Could not load ClassFile for " + e, e1);
			} finally {
				if (tis != null) {
					try {
						tis.close();
					} catch (IOException e1) {
						// Ignore
					}
				}
			}
		}
	}
	
	public ClassFile resolveClassFile(String name) {
		
		ClassFile cf = null;
		
        String className = name.replace('.', '/').concat(".class");
		
		for (ClassLoader classLoader : classLoaders) {
		    
    		if (classLoader != null) {
    			
    			InputStream is = classLoader.getResourceAsStream(className);
    			if (is == null) {
    			    continue;
    			}
    			BufferedInputStream fin = new BufferedInputStream(is);
    			
    			try {
    				cf = new ClassFile(new DataInputStream(fin));
    				if (cf != null) {
    					return cf;
    				}
    			} catch (IOException e) {
    				// Ignore
    			}
    		}
		}
			
		cf = resolveFirst(null, CLASSPATH_PROJECTOR, new PackageFileFilter(name, true), new NameFilter(name));
		if (cf == null) {
			cf = resolveFirst(null, CLASSPATH_PROJECTOR, new ClassFileFilter(name));
		}
		return cf;
	}
}