/*
 * WMPNetworkProperty.cpp 
 * Copyright (c) 2012 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// 2011/12/08 Sample program to show properties of a Windows media network
// by using SOL::WMPNetwork.


#include <sol/Object.h>
#include <sol/ole/OleSite.h>
#include <sol/wmp/WMPMedia.h>
#include <sol/wmp/WMPNetwork.h>
#include <sol/wmp/WMPError.h>

#include <sol/ole/MediaEventsListener.h>
#include <sol/ArgListT.h>
#include <sol/Locale.h>
#include <sol/FileWriter.h>


namespace SOL {

#define WM_PLAY_FINISHED (WM_USER + 2011)
#define WM_PLAYING       (WM_USER + 2012)
#define WM_MEDIAENDED    (WM_USER + 2013)
#define WM_TRANSIONING   (WM_USER + 2014)
#define WM_ERROR         (WM_USER + 2021)

//MediaProperty shows properties of a Windows media.

class WMPNetworkProperty :public Object {

private:
    //Local MediaEventsListener class derived from SOL::MediaEventsListner 
    //-----------------------------------------------------------
    //<InnerClass>
    class __MediaEventsListener :public MediaEventsListener {
    private:
        Writer* writer;

    public:
        //Constructor
        __MediaEventsListener(DWORD thread)
            :MediaEventsListener(thread)
        {
        }

    public:
        void putWriter(Writer* writer)
        {
            this->writer = writer;
        }

    public:
        virtual void writeProperties(Writer* writer)
        {
            try {
                IWMPPlayer4* pPlayer = getPlayer();
                IWMPNetwork* pNetwork = NULL;
                HRESULT hr = pPlayer->get_network(&pNetwork);
                if (FAILED(hr)) {
                    printf("Failed to get_network\n");
                    throw hr;
                }

                WMPNetwork network = pNetwork;
                network.writeProperties(*writer);
                //printf("\n");
            } catch (...) {
            }
        }

    public:
        virtual void __stdcall PlayStateChange (__in long NewState)
        {
            const TCHAR* name =getPlayStateName(NewState);
            writer->writeln(L"<PlayStateChange NewState=\"%s\">", name);
            if (NewState == 1) {
                //Playing has stopped, so post a user-defined message WM_PLAY_FINISHED 
                //to terminate a message loop in _tmain.
                postThreadMessage(WM_PLAY_FINISHED, 0, 0);
            }

            if (NewState == 3) {
                //We are notified to be 'Playing' a media
                writeProperties(writer);
                postThreadMessage(WM_PLAYING, 0, 0);
            }
            if (NewState == 8) {
                //We are notified to be 'MediaEnded' for a current media.
                writeProperties(writer);
                postThreadMessage(WM_MEDIAENDED, 0, 0);
            }
            if (NewState == 9) {
                //We are notified to be 'Transitioning'.
                writeProperties(writer);
            }
            writer->writeln(L"</PlayStateChange>");

        }
    public:
        virtual void __stdcall Error() 
        {
            IWMPError* pError = NULL;
            IWMPPlayer4* pPlayer = getPlayer();

            if (SUCCEEDED(pPlayer -> get_Error(&pError)) ) {
                WMPError error = pError;
                error.show();
            }

            postThreadMessage(WM_ERROR, 0, 0);    
        }

    };
    // </InnerClass> 
    //-----------------------------------------------------------

private:
    IOleObject*  oleObject;
    IWMPPlayer4*   pPlayer;

    COleSite oleSite;
    __MediaEventsListener mediaEvents;
    
public:
    // Constructor
    WMPNetworkProperty(Writer* writer)
        :oleObject(NULL),
        pPlayer(NULL),
        mediaEvents(GetCurrentThreadId())
    {
        try {
            HRESULT hr = CoCreateInstance( __uuidof(WindowsMediaPlayer), 0, CLSCTX_INPROC_SERVER, 
                IID_IOleObject, (void **)&oleObject);

            if (FAILED(hr)) {
                throw Exception("Failed to cocreateInstance\n", hr);
            }

            hr = oleObject->QueryInterface(__uuidof(IWMPPlayer), (void**)&pPlayer);
            if (FAILED(hr)) {
                throw Exception("Failed to queryInterface\n", hr);
            }

            hr = oleObject-> SetClientSite(&oleSite);
            if (FAILED(hr)) {
                throw Exception("SetClientSite failed\n", hr);
            }
    
            hr = mediaEvents.Advise(oleObject, __uuidof(IWMPEvents));
            if (FAILED(hr)) {
                throw Exception("Advise failed\n", hr);
            }

            IWMPSettings *pSetting = NULL;
            hr = pPlayer->QueryInterface(__uuidof(IWMPSettings), (void **)&pSetting);
            if (FAILED(hr)) {
                throw Exception("QueryInterface to Setting failed\n", hr);
            }
            //set Auto-start
            pSetting->put_autoStart(VARIANT_TRUE);
            //set Silent- mode
            pSetting->put_mute(VARIANT_TRUE);

            mediaEvents.putWriter(writer);
            mediaEvents.putPlayer(pPlayer);

            pSetting->Release();

        } catch (Exception& ex) {
            ex.printf();
        } catch (HRESULT hr) {

        }
    }

public:
    // Destructor
    ~WMPNetworkProperty()
    {
        mediaEvents.Unadvise(oleObject, __uuidof(IWMPEvents));

        if (oleObject) {
            oleObject->Release();
        }
        if (pPlayer) {
            pPlayer->Release();
        }
    }

public:
    void play(const TCHAR* file)
    {
        _bstr_t filename = file;
        pPlayer->put_URL(filename);
    }


public:
    virtual void display(const TCHAR* file, HWND hwnd=NULL)
    {
        // Play a windows media for file.
        play(file);

        // Enter a typical windows-message-loop.
        MSG msg;
        while (GetMessage(&msg, NULL, 0, 0)) {
            if (msg.message == WM_PLAY_FINISHED) {
                //We got a message from MediaEventsListener class to termainte this message loop
                break;
            }

            if (msg.message == WM_ERROR) {
                break;
            }

            if (msg.message == WM_PLAYING) {
                // Stop a play by using a IWMPControls interface.
                IWMPControls* pControls = NULL;
                HRESULT hr = pPlayer->QueryInterface(__uuidof(IWMPControls), (void **)&pControls);
                if (SUCCEEDED(hr)) {
                    pControls->stop();
                    pControls->Release();
                }
            }
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
};

}

// Console application 
void _tmain(int argc, _TCHAR* argv[])
{
    if (argc != 3) {
        _tprintf(_T("Usage: %s url xmlFile\n"), argv[0]);
        _tprintf(_T("Ex: %s http://www.antillia.com/chichibu/fudasho/fudasho_1/shimabuji_fall_1122.wmv sample.xml\n"), argv[0]);
        return;
    }

    _bstr_t url = argv[1];
    const TCHAR* xmlFile = argv[2];

    Locale locale;

    OleInitialize(NULL);
    try {
        FileWriter writer = xmlFile;

        writer.writeln(L"<?xml version=\"1.0\" encoding=\"UTF-16\"?>");
        writer.writeln(L"<%s>", argv[0]);

        WMPNetworkProperty networkProperty(&writer);
        networkProperty.display(argv[1]);

        writer.writeln(L"</%s>", argv[0]);

    } catch (Exception& ex) {
        ex.printf();
    } catch (HRESULT hr) {
        printf("Exception HRESULT=%x\n", hr);
    } catch (...) {
    }
    OleUninitialize();
}