/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * 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 com.android.camera.processing.imagebackend;

import android.net.Uri;

import com.android.camera.debug.Log;
import com.android.camera.one.v2.camera2proxy.ImageProxy;

import com.google.common.annotations.VisibleForTesting;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import javax.annotation.Nullable;

/**
 * Implements the ability for the object to send events to multiple listeners in
 * a thread-safe manner. Also, listeners can also filter messages based on the a
 * specific image result.
 * <p>
 * TODO: Replace this object with a more generic listener class. TODO: Replace
 * the image filter code with something more efficient.
 */
public class ImageProcessorProxyListener implements ImageProcessorListener {

    private final static Log.Tag TAG = new Log.Tag("IProxyListener");

    private final List<ImageProcessorListener> mRegisteredListeners;

    private final HashMap<ImageProcessorListener, Long> mImageFilter;

    /**
     * Wrapper for the log to avoid direct references to Android Log objects
     * that will crash unit tests. Subclasses may override this method for
     * debugging.
     *
     * @param message
     */
    protected void logWrapper(String message) {
        // Uncomment for more verbose messaging.
        // Log.v(TAG, message);
    }

    ImageProcessorProxyListener() {
        mRegisteredListeners = new ArrayList<ImageProcessorListener>();
        mImageFilter = new HashMap<ImageProcessorListener, Long>();
    }

    /**
     * Returns the size of the ImageFilter so that we ensure that there are no
     * reference leaks.
     *
     * @return the number of elements in the mapping between
     *         ImageProcessorListener and their ids.
     */
    @VisibleForTesting
    public int getMapSize() {
        synchronized (mRegisteredListeners) {
            return mImageFilter.size();
        }
    }

    /**
     * Returns the number of ImageProcessorListener held by the system so that
     * we ensure that there are no reference leaks.
     *
     * @return the number of registered ImageProcessorListener
     */
    @VisibleForTesting
    public int getNumRegisteredListeners() {
        synchronized (mRegisteredListeners) {
            return mRegisteredListeners.size();
        }
    }

    /**
     * Register a listener filtered by a particular image object. If image is
     * null, then events from all image processing will be sent to the
     * registered listener.
     *
     * @param listener The listener to be registered.
     * @param image The specific image to filter the events to the listener. If
     *            null, then the listener receives events from all images that
     *            are being processed.
     */
    public void registerListener(ImageProcessorListener listener,
            @Nullable ImageProxy image) {
        synchronized (mRegisteredListeners) {
            logWrapper("There are " + mRegisteredListeners.size()
                    + " listeners before addition");
            if (!mRegisteredListeners.contains(listener)) {
                mRegisteredListeners.add(listener);
                logWrapper("Listener will be overwritten.");
            }

            if (image == null) {
                mImageFilter.put(listener, null);
            } else {
                mImageFilter.put(listener, image.getTimestamp());
            }
            logWrapper("There are " + mRegisteredListeners.size()
                    + " listeners after addition");
        }

        return;
    }

    private List<ImageProcessorListener> filteredListeners(long imageId) {
        List<ImageProcessorListener> filteredList = new ArrayList<ImageProcessorListener>();

        for (ImageProcessorListener l : mRegisteredListeners) {
            if (mImageFilter.get(l) == null || mImageFilter.get(l) == imageId) {
                filteredList.add(l);
            }
        }

        return filteredList;
    }

    public void unregisterListener(ImageProcessorListener listener) {
        synchronized (mRegisteredListeners) {
            if (mRegisteredListeners.contains(listener)) {
                mRegisteredListeners.remove(listener);
                mImageFilter.remove(listener);
                logWrapper("There are " + mRegisteredListeners.size()
                        + " listeners after removal");
            } else {
                logWrapper("Couldn't find listener.  There are " + mRegisteredListeners.size()
                        + " listeners after removal");
            }
        }
    }

    public void onStart(TaskImageContainer.TaskInfo job) {
        final List<ImageProcessorListener> listeners;
        synchronized (mRegisteredListeners) {
            listeners = filteredListeners(job.contentId);
        }

        for (ImageProcessorListener l : listeners) {
            l.onStart(job);
        }
    }

    public void onResultCompressed(TaskImageContainer.TaskInfo job,
            TaskImageContainer.CompressedPayload payload) {
        final List<ImageProcessorListener> listeners;
        synchronized (mRegisteredListeners) {
            listeners = filteredListeners(job.contentId);
        }

        for (ImageProcessorListener l : listeners) {
            l.onResultCompressed(job, payload);
        }
    }

    public void onResultUncompressed(TaskImageContainer.TaskInfo job,
            TaskImageContainer.UncompressedPayload payload) {
        final List<ImageProcessorListener> listeners;
        synchronized (mRegisteredListeners) {
            listeners = filteredListeners(job.contentId);
        }

        for (ImageProcessorListener l : listeners) {
            l.onResultUncompressed(job, payload);
        }
    }

    public void onResultUri(TaskImageContainer.TaskInfo job, Uri uri) {
        final List<ImageProcessorListener> listeners;
        synchronized (mRegisteredListeners) {
            listeners = filteredListeners(job.contentId);
        }

        for (ImageProcessorListener l : listeners) {
            l.onResultUri(job, uri);
        }
    }

}