/*****************************************************************************
 * events.hpp : matroska demuxer
 *****************************************************************************
 * Copyright (C) 2003-2004 VLC authors and VideoLAN
 *
 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
 *          Steve Lhomme <steve.lhomme@free.fr>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 *****************************************************************************/

#ifndef VLC_MKV_DEMUX_EVENTS_HPP
#define VLC_MKV_DEMUX_EVENTS_HPP

#include <vlc_common.h>
#include <vlc_threads.h>
#include <vlc_mouse.h>

#include <list>
#include <memory>

struct vlc_spu_highlight_t;

namespace mkv {

struct p_block;

class event_thread_t
{
public:
    event_thread_t(demux_t *);
    virtual ~event_thread_t();

    void SendData( mkv_track_t &, block_t * );
    void AbortThread();
    int SendEventNav( demux_query_e );
    void SetHighlight( vlc_spu_highlight_t & spu_hl );

    bool AddTrack( mkv_track_t & );
    void DelTrack( mkv_track_t & );

private:
    struct ESInfo {
        ESInfo( mkv_track_t & track_, event_thread_t& owner )
            : track( track_ )
            , owner( owner )
        {
            vlc_mouse_Init( &mouse_state );
        }

        bool operator==( const mkv_track_t & t ) const {
            return track.p_es == t.p_es;
        }

        mkv_track_t & track;
        event_thread_t& owner;
        vlc_mouse_t mouse_state;
    };

    struct EventInfo {
        enum {
            ESMouseEvent,
            ButtonDataEvent,
        } type;

        EventInfo( const vlc_mouse_t & state_old, const vlc_mouse_t & state_new )
            : type( ESMouseEvent )
            , mouse{ state_old, state_new }
        {
        }

        EventInfo( block_t * block )
            : type( ButtonDataEvent )
            , button_data( block, block_Release )
        {
        }

        union {
            struct {
                const vlc_mouse_t state_old;
                const vlc_mouse_t state_new;
            } mouse;

            struct {
                const NavivationKey key;
            } nav;
        };

        std::shared_ptr<block_t> button_data;
    };

    void EventThread();
    static void *EventThread(void *);
    void EnsureThreadLocked();

    static void EventMouse( vlc_mouse_t const* state, void* userdata );

    void HandleMouseEvent( EventInfo const& );
    void HandleButtonData( EventInfo const& );

    demux_t      *p_demux;

    bool         is_running;
    vlc_thread_t thread;

    vlc_mutex_t  lock;
    vlc_cond_t   wait;
    bool         b_abort = false;

    typedef std::list<ESInfo> es_list_t;
    es_list_t es_list;               //protected by "lock"

    typedef std::list<EventInfo> pending_events_t;
    pending_events_t pending_events; // protected by "lock"

    void QueueEvent(const EventInfo & e)
    {
        vlc_mutex_locker lock_guard( &lock );

        EnsureThreadLocked();

        pending_events.push_back( e );
        vlc_cond_signal( &wait );
    }

    bool HandleKeyEvent( NavivationKey key );
    void HandleMousePressed( unsigned x, unsigned y );
    void HandleButtonData( block_t * );
};
} // namespace

#endif