/**
 * ProtocolLib - Bukkit server library that allows access to the Minecraft protocol. Copyright (C) 2012 Kristian S.
 * Stangeland
 * <p>
 * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later
 * version.
 * <p>
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 * <p>
 * You should have received a copy of the GNU General Public License along with this program; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
package com.comphenix.protocol.utility;

import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Represents a dynamic package and an arbitrary number of cached classes.
 *
 * @author Kristian
 */
final class CachedPackage {

    private final String packageName;
    private final ClassSource source;
    private final Map<String, Optional<Class<?>>> cache;

    /**
     * Construct a new cached package.
     *
     * @param packageName - the name of the current package.
     * @param source      - the class source.
     */
    CachedPackage(String packageName, ClassSource source) {
        this.source = source;
        this.packageName = packageName;
        this.cache = new ConcurrentHashMap<>();
    }

    /**
     * Correctly combine a package name and the child class we're looking for.
     *
     * @param packageName - name of the package, or an empty string for the default package.
     * @param className   - the class name.
     * @return We full class path.
     */
    public static String combine(String packageName, String className) {
        if (packageName == null || packageName.isEmpty()) {
            return className;
        } else {
            return packageName + "." + className;
        }
    }

    /**
     * Associate a given class with a class name.
     *
     * @param className - class name.
     * @param clazz     - type of class.
     */
    public void setPackageClass(String className, Class<?> clazz) {
        if (clazz != null) {
            this.cache.put(className, Optional.of(clazz));
        } else {
            this.cache.remove(className);
        }
    }

    private Optional<Class<?>> resolveClass(String className) {
        return source.loadClass(combine(packageName, className));
    }

    /**
     * Retrieve the class object of a specific class in the current package.
     *
     * @param className - the specific class.
     * @return Class object.
     * @throws RuntimeException If we are unable to find the given class.
     */
    public Optional<Class<?>> getPackageClass(String className, String... aliases) {
        return cache.computeIfAbsent(className, x -> {
            Optional<Class<?>> clazz = resolveClass(className);
            if (clazz.isPresent()) {
                return clazz;
            }

            for (String alias : aliases) {
                clazz = resolveClass(alias);
                if (clazz.isPresent()) {
                    return clazz;
                }
            }

            return Optional.empty();
        });
    }
}