/*
 * Copyright (C) 2011 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#ifndef MediaPlayerPrivateAVFoundation_h
#define MediaPlayerPrivateAVFoundation_h

#if ENABLE(VIDEO) && USE(AVFOUNDATION)

#include "FloatSize.h"
#include "MediaPlayerPrivate.h"
#include "Timer.h"
#include <wtf/RetainPtr.h>

namespace WebCore {

class MediaPlayerPrivateAVFoundation : public MediaPlayerPrivateInterface {
public:

    virtual void repaint();
    virtual void metadataLoaded();
    virtual void playabilityKnown();
    virtual void rateChanged();
    virtual void loadedTimeRangesChanged();
    virtual void seekableTimeRangesChanged();
    virtual void timeChanged(double);
    virtual void seekCompleted(bool);
    virtual void didEnd();
    virtual void contentsNeedsDisplay() { }

    class Notification {
    public:
        enum Type {
            None,
            ItemDidPlayToEndTime,
            ItemTracksChanged,
            ItemStatusChanged,
            ItemSeekableTimeRangesChanged,
            ItemLoadedTimeRangesChanged,
            ItemPresentationSizeChanged,
            ItemIsPlaybackLikelyToKeepUpChanged,
            ItemIsPlaybackBufferEmptyChanged,
            ItemIsPlaybackBufferFullChanged,
            AssetMetadataLoaded,
            AssetPlayabilityKnown,
            PlayerRateChanged,
            PlayerTimeChanged,
            SeekCompleted,
            DurationChanged,
            ContentsNeedsDisplay,
        };
        
        Notification()
            : m_type(None)
            , m_time(0)
            , m_finished(false)
        {
        }

        Notification(Type type, double time)
            : m_type(type)
            , m_time(time)
            , m_finished(false)
        {
        }
        
        Notification(Type type, bool finished)
        : m_type(type)
        , m_time(0)
        , m_finished(finished)
        {
        }
        
        Type type() { return m_type; }
        bool isValid() { return m_type != None; }
        double time() { return m_time; }
        bool finished() { return m_finished; }
        
    private:
        Type m_type;
        double m_time;
        bool m_finished;
    };

    void scheduleMainThreadNotification(Notification);
    void scheduleMainThreadNotification(Notification::Type, double time = 0);
    void scheduleMainThreadNotification(Notification::Type, bool completed);
    void dispatchNotification();
    void clearMainThreadPendingFlag();

protected:
    MediaPlayerPrivateAVFoundation(MediaPlayer*);
    virtual ~MediaPlayerPrivateAVFoundation();

    // MediaPlayerPrivatePrivateInterface overrides.
    virtual void load(const String& url);
    virtual void cancelLoad() = 0;

    virtual void prepareToPlay();
    virtual PlatformMedia platformMedia() const = 0;

    virtual void play();
    virtual void pause();

    virtual IntSize naturalSize() const;
    virtual bool hasVideo() const { return m_cachedHasVideo; }
    virtual bool hasAudio() const { return m_cachedHasAudio; }
    virtual void setVisible(bool);
    virtual float duration() const;
    virtual float currentTime() const = 0;
    virtual void seek(float);
    virtual bool seeking() const;
    virtual void setRate(float);
    virtual bool paused() const;
    virtual void setVolume(float) = 0;
    virtual bool hasClosedCaptions() const { return m_cachedHasCaptions; }
    virtual void setClosedCaptionsVisible(bool) = 0;
    virtual MediaPlayer::NetworkState networkState() const { return m_networkState; }
    virtual MediaPlayer::ReadyState readyState() const { return m_readyState; }
    virtual float maxTimeSeekable() const;
    virtual PassRefPtr<TimeRanges> buffered() const;
    virtual bool didLoadingProgress() const;
    virtual void setSize(const IntSize&);
    virtual void paint(GraphicsContext*, const IntRect&) = 0;
    virtual void paintCurrentFrameInContext(GraphicsContext*, const IntRect&) = 0;
    virtual void setPreload(MediaPlayer::Preload);
#if USE(ACCELERATED_COMPOSITING)
    virtual PlatformLayer* platformLayer() const { return 0; }
    virtual bool supportsAcceleratedRendering() const = 0;
    virtual void acceleratedRenderingStateChanged();
#endif
    virtual MediaPlayer::MovieLoadType movieLoadType() const;
    virtual void prepareForRendering();
    virtual float mediaTimeForTimeValue(float) const = 0;

    virtual bool supportsFullscreen() const;
    virtual bool supportsScanning() const { return true; }

    // Required interfaces for concrete derived classes.
    virtual void createAVAssetForURL(const String&) = 0;
    virtual void createAVPlayer() = 0;
    virtual void createAVPlayerItem() = 0;

    enum ItemStatus {
        MediaPlayerAVPlayerItemStatusDoesNotExist,
        MediaPlayerAVPlayerItemStatusUnknown,
        MediaPlayerAVPlayerItemStatusFailed,
        MediaPlayerAVPlayerItemStatusReadyToPlay,
        MediaPlayerAVPlayerItemStatusPlaybackBufferEmpty,
        MediaPlayerAVPlayerItemStatusPlaybackBufferFull,
        MediaPlayerAVPlayerItemStatusPlaybackLikelyToKeepUp,
    };
    virtual ItemStatus playerItemStatus() const = 0;

    enum AssetStatus {
        MediaPlayerAVAssetStatusDoesNotExist,
        MediaPlayerAVAssetStatusUnknown,
        MediaPlayerAVAssetStatusLoading,
        MediaPlayerAVAssetStatusFailed,
        MediaPlayerAVAssetStatusCancelled,
        MediaPlayerAVAssetStatusLoaded,
        MediaPlayerAVAssetStatusPlayable,
    };
    virtual AssetStatus assetStatus() const = 0;

    virtual void platformSetVisible(bool) = 0;
    virtual void platformPlay() = 0;
    virtual void platformPause() = 0;
    virtual void checkPlayability() = 0;
    virtual void updateRate() = 0;
    virtual float rate() const = 0;
    virtual void seekToTime(float time) = 0;
    virtual unsigned totalBytes() const = 0;
    virtual PassRefPtr<TimeRanges> platformBufferedTimeRanges() const = 0;
    virtual float platformMaxTimeSeekable() const = 0;
    virtual float platformMaxTimeLoaded() const = 0;
    virtual float platformDuration() const = 0;

    virtual void beginLoadingMetadata() = 0;
    virtual void tracksChanged() = 0;
    virtual void sizeChanged() = 0;

    virtual void createContextVideoRenderer() = 0;
    virtual void destroyContextVideoRenderer() = 0;

    virtual void createVideoLayer() = 0;
    virtual void destroyVideoLayer() = 0;

    virtual bool hasAvailableVideoFrame() const = 0;

    virtual bool hasContextRenderer() const = 0;
    virtual bool hasLayerRenderer() const = 0;

protected:
    void updateStates();

    void setHasVideo(bool);
    void setHasAudio(bool);
    void setHasClosedCaptions(bool);
    void setDelayCallbacks(bool) const;
    void setIgnoreLoadStateChanges(bool delay) { m_ignoreLoadStateChanges = delay; }
    void setNaturalSize(IntSize);
    bool isLiveStream() const { return isinf(duration()); }

    enum MediaRenderingMode { MediaRenderingNone, MediaRenderingToContext, MediaRenderingToLayer };
    MediaRenderingMode currentRenderingMode() const;
    MediaRenderingMode preferredRenderingMode() const;

    bool metaDataAvailable() const { return m_readyState >= MediaPlayer::HaveMetadata; }
    float requestedRate() const { return m_requestedRate; }
    float maxTimeLoaded() const;
    bool isReadyForVideoSetup() const;
    virtual void setUpVideoRendering();
    virtual void tearDownVideoRendering();
    bool hasSetUpVideoRendering() const;

    static void mainThreadCallback(void*);
    
    void invalidateCachedDuration();

    const String& assetURL() const { return m_assetURL; }

    MediaPlayer* player() { return m_player; }

private:
    MediaPlayer* m_player;

    Vector<Notification> m_queuedNotifications;
    mutable Mutex m_queueMutex;

    mutable RefPtr<TimeRanges> m_cachedLoadedTimeRanges;

    MediaPlayer::NetworkState m_networkState;
    MediaPlayer::ReadyState m_readyState;

    String m_assetURL;
    MediaPlayer::Preload m_preload;

    IntSize m_cachedNaturalSize;
    mutable float m_cachedMaxTimeLoaded;
    mutable float m_cachedMaxTimeSeekable;
    mutable float m_cachedDuration;
    float m_reportedDuration;
    mutable float m_maxTimeLoadedAtLastDidLoadingProgress;
    float m_seekTo;
    float m_requestedRate;
    mutable int m_delayCallbacks;
    bool m_mainThreadCallPending;
    bool m_assetIsPlayable;
    bool m_visible;
    bool m_loadingMetadata;
    bool m_isAllowedToRender;
    bool m_cachedHasAudio;
    bool m_cachedHasVideo;
    bool m_cachedHasCaptions;
    bool m_ignoreLoadStateChanges;
    bool m_haveReportedFirstVideoFrame;
    bool m_playWhenFramesAvailable;
};

} // namespace WebCore

#endif // ENABLE(VIDEO) && USE(AVFOUNDATION)

#endif // MediaPlayerPrivateAVFoundation_h
