/*
 * 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.
 */
package org.apache.wicket.core.util.resource.locator.caching;

import java.util.Locale;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.apache.wicket.core.util.resource.UrlResourceStream;
import org.apache.wicket.core.util.resource.locator.IResourceNameIterator;
import org.apache.wicket.core.util.resource.locator.IResourceStreamLocator;
import org.apache.wicket.request.resource.ResourceReference.Key;
import org.apache.wicket.util.lang.Args;
import org.apache.wicket.util.resource.FileResourceStream;
import org.apache.wicket.util.resource.IResourceStream;


/**
 * Locating resources can take a significant amount of time, especially since there are often
 * several CSS, JavaScript and image resources on any given page. To facilitate localization and
 * styling, Wicket will usually make several attempts at locating each resource (i.e. first with an
 * "en_US" suffix, then "en", and so on); multiply these attempts by the number of resources on the
 * page and this starts to add up.
 * <p>
 * This locator mitigates this problem by caching (indefinitely) references to
 * {@link UrlResourceStream} and {@link FileResourceStream} objects as they are found, and
 * {@link NullResourceStreamReference} for all which are missing so they are not looked up again and
 * again.
 */
public class CachingResourceStreamLocator implements IResourceStreamLocator
{
        private final ConcurrentMap<CacheKey, IResourceStreamReference> cache;

        private final IResourceStreamLocator delegate;

        /**
         * Construct.
         * 
         * @param resourceStreamLocator
         *            the delegate
         */
        public CachingResourceStreamLocator(final IResourceStreamLocator resourceStreamLocator)
        {
                Args.notNull(resourceStreamLocator, "resourceStreamLocator");

                delegate = resourceStreamLocator;

                cache = new ConcurrentHashMap<>();
        }

        /**
         * {@inheritDoc}
         * 
         * Checks for {@link IResourceStreamReference} in the cache and returns <code>null</code> if the
         * result is {@link NullResourceStreamReference#INSTANCE}, or {@link FileResourceStream} /
         * {@link UrlResourceStream} if there is an entry in the cache. Otherwise asks the delegate to
         * find one and puts it in the cache.
         */
        @Override
        public IResourceStream locate(Class<?> clazz, String path)
        {
                CacheKey key = new CacheKey(clazz.getName(), path, null, null, null, null, true);
                IResourceStreamReference resourceStreamReference = cache.get(key);

                final IResourceStream result;
                if (resourceStreamReference == null)
                {
                        result = delegate.locate(clazz, path);

                        updateCache(key, result);
                }
                else
                {
                        result = resourceStreamReference.getReference();
                }

                return result;
        }

        private void updateCache(CacheKey key, IResourceStream stream)
        {
                if (null == stream)
                {
                        cache.put(key, NullResourceStreamReference.INSTANCE);
                }
                else if (stream instanceof FileResourceStream)
                {
                        FileResourceStream fileResourceStream = (FileResourceStream)stream;
                        cache.put(key, new FileResourceStreamReference(fileResourceStream));
                }
                else if (stream instanceof UrlResourceStream)
                {
                        UrlResourceStream urlResourceStream = (UrlResourceStream)stream;
                        cache.put(key, new UrlResourceStreamReference(urlResourceStream));
                }
        }

        @Override
        public IResourceStream locate(Class<?> scope, String path, String style, String variation,
                Locale locale, String extension, boolean strict)
        {
                CacheKey key = new CacheKey(scope.getName(), path, extension, locale, style, variation, strict);
                IResourceStreamReference resourceStreamReference = cache.get(key);

                final IResourceStream result;
                if (resourceStreamReference == null)
                {
                        result = delegate.locate(scope, path, style, variation, locale, extension, strict);

                        updateCache(key, result);
                }
                else
                {
                        result = resourceStreamReference.getReference();
                }

                return result;
        }

        @Override
        public IResourceNameIterator newResourceNameIterator(String path, Locale locale, String style,
                String variation, String extension, boolean strict)
        {
                return delegate.newResourceNameIterator(path, locale, style, variation, extension, strict);
        }

        /**
         * Clears the resource cache.
         * 
         * @since 6.16.0
         */
        public void clearCache()
        {
                cache.clear();
        }

        /**
         * A specialization of {@link org.apache.wicket.request.resource.ResourceReference.Key} that
         * additionally takes the file extension into account
         */
        private static class CacheKey extends Key
        {
                private static final long serialVersionUID = 1L;

                /**
                 * The file extension
                 */
                private final String extension;

                /** Whether the key was looked up using a strict matching search */
                private final boolean strict;

                private CacheKey(String scope, String name, String extension, Locale locale, String style, String variation, boolean strict)
                {
                        super(scope, name, locale, style, variation);

                        this.extension = extension;
                        this.strict = strict;
                }

                @Override
                public int hashCode()
                {
                        final int prime = 31;
                        int result = super.hashCode();
                        result = prime * result + ((extension == null) ? 0 : extension.hashCode());
                        result = prime * result + (strict ? 1231 : 1237);
                        return result;
                }

                @Override
                public boolean equals(Object obj)
                {
                        if (this == obj)
                                return true;
                        if (!super.equals(obj))
                                return false;
                        if (getClass() != obj.getClass())
                                return false;
                        CacheKey other = (CacheKey)obj;
                        if (extension == null)
                        {
                                if (other.extension != null)
                                        return false;
                        }
                        else if (!extension.equals(other.extension))
                                return false;
                        if (strict != other.strict)
                                return false;
                        return true;
                }
        }
}