/*
 * WMPMedia.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL9
// 2011/12/07
// 2012/01/05 Updated

#pragma once

#include <sol/wmp/WMPObject.h>
#include <sol/HTMLEncoder.h>

//2012/01/05
#include <sol/wmp/WMPMetadataPicture.h>
#include <sol/wmp/WMPMetadataText.h>

#include <sol/Writer.h>

namespace SOL {

class WMPMedia :public WMPObject {

private:
    IWMPMedia3Ptr media;

public:
    WMPMedia(IWMPMediaPtr ptr)
    :media(ptr)
    {
        if (ptr == NULL) {
            throw NullPointerException("IWMPMediaPtr is NULL", 0);
        }
    }

public:
    ~WMPMedia()
    {
        media = NULL;    
    }

public:
    IWMPMediaPtr getMedia()
    {
        return media;
    }


    VARIANT_BOOL getIsIdentical(struct IWMPMedia * pIWMPMedia)
    {
        return media->GetisIdentical(pIWMPMedia);
    }

    _bstr_t getSourceURL()
    {
        return media->GetsourceURL();
    }


    _bstr_t getName()
    {
        return media->Getname();
    }


    void putName(_bstr_t pbstrName)
    {
        media->Putname(pbstrName);
    }


    long getImageSourceWidth()
    {
        return media->GetimageSourceWidth();
    }

    
    long getImageSourceHeight()
    {
        return media->GetimageSourceHeight();
    }

    
    long getMarkerCount()
    {
        return media->GetmarkerCount();
    }


    double getMarkerTime(long markerNum)
    {
        return media->getMarkerTime(markerNum);
    }

    
    _bstr_t getMarkerName(long markerNum)
    {
        return media->getMarkerName(markerNum);
    }

    
    double getDuration()
    {
        return media->Getduration();
    }

    
    _bstr_t getDurationString()
    {
        return media->GetdurationString();
    }

    
    long getAttributeCount()
    {
        return media->GetattributeCount();
    }

    
    _bstr_t getAttributeName(long lIndex)
    {
        return media->getAttributeName(lIndex);
    }


    _bstr_t getItemInfo(_bstr_t bstrItemName)
    {
        return media->getItemInfo(bstrItemName);
    }

    //2011/12/23
    //This returns a string "True" or "False" for Cdrom, but returns an empty string "" for other media.
    _bstr_t isSelectedForRip()
    {
        return media->getItemInfo(_bstr_t("SelectedForRip"));
    }

    //2011/12/29
    HRESULT selectForRip(bool flag)
    {
        _bstr_t bflag = "False";
        if (flag) {
            bflag = "True";
        }
        return media->setItemInfo(_bstr_t("SelectedForRip"), bflag);
    }

    HRESULT setItemInfo(_bstr_t bstrItemName, _bstr_t bstrVal)
    {
        return media->setItemInfo(bstrItemName, bstrVal);
    }


    _bstr_t getItemInfoByAtom(long lAtom)
    {
        return media->getItemInfoByAtom(lAtom);
    }



    VARIANT_BOOL isMemberOf(struct IWMPPlaylist * pPlaylist)
    {
        return media->isMemberOf(pPlaylist);

    }

    VARIANT_BOOL isReadOnlyItem(_bstr_t bstrItemName)
    {
        return media->isReadOnlyItem(bstrItemName);
    }

//<IWMPMedia2>
    IWMPErrorItemPtr getError ( )
    {
        return media->GetError ( );
    }
//</IWMPMedia2>


//<IWMPMedia3>
    long getAttributeCountByType (
        _bstr_t bstrType,
        _bstr_t bstrLanguage )
    {
        return media->getAttributeCountByType (
            bstrType,
            bstrLanguage );
    }

    _variant_t getItemInfoByType (
        _bstr_t bstrType,
        _bstr_t bstrLanguage,
        long lIndex )
    {
        return media->getItemInfoByType (
            bstrType,
            bstrLanguage,
            lIndex );
    }
//</IWMPMedia3>

//2012/01/04
public:
    IWMPMetadataPicturePtr getMetadataPicture()
    {
        IWMPMetadataPicturePtr picture = NULL;
        _bstr_t type = "WM/Picture";
        _bstr_t lang = "";
        long count = getAttributeCountByType(type, lang);

        for (long n = 0; n<count; n++) {
            _variant_t var = getItemInfoByType (type, lang, n);
            if (var.vt == VT_DISPATCH) {
                IWMPMetadataPicture* ipicture = NULL;

                if (SUCCEEDED(var.pdispVal->QueryInterface(
                            __uuidof(IWMPMetadataPicture), (void**)&ipicture)) ) {
                    picture = ipicture;
                      break;
                }
            }
        }
        return picture;
    }

//2012/01/04
public:
    IWMPMetadataTextPtr getMetadataText()
    {
        IWMPMetadataTextPtr text = NULL;
        _bstr_t type = "WM/Text";
        _bstr_t lang = "";
        long count = getAttributeCountByType(type, lang);

        for (long n = 0; n<count; n++) {
            _variant_t var = getItemInfoByType (type, lang, n);
            if (var.vt == VT_DISPATCH) {
                IWMPMetadataText* itext = NULL;

                if (SUCCEEDED(var.pdispVal->QueryInterface(
                            __uuidof(IWMPMetadataText), (void**)&itext)) ) {
                    text = itext;
                    break;
                }
            }
        }
        return text;
    }


public:
    virtual void showProperties(HWND hwnd=NULL)
    {
        HTMLEncoder encoder;
        _bstr_t url;
        encoder.encode((const wchar_t*)getSourceURL(), url);
        _tprintf(_T("<Media>\n"));        

        _tprintf(_T("<Name>%s</Name>\n"), (const TCHAR*)getName());        
        _tprintf(_T("<SourceURL>%s</SourceURL>\n"), (const TCHAR*)url);            
        _tprintf(_T("<ImageSourceWidth>%d</ImageSourceWidth>\n"), getImageSourceWidth());        
        _tprintf(_T("<ImageSourceHeight>%d</ImageSourceHeight>\n"), getImageSourceHeight());        

        long mc = getMarkerCount();        
        _tprintf(_T("<Marker Count=\"%d\">\n"), mc);        

        for (long i = 0; i<mc; i++) {
            double mtime = getMarkerTime(i);
            _tprintf(_T("<MarkerTime>%f</MarkerTime>\n<MarkerName>%s</MarkerName>\n"),
                    media->getMarkerTime(i),
                (const TCHAR*)getMarkerName(i)
                );
        }
        _tprintf(_T("</Marker>\n"));        
        _tprintf(_T("<Duration>%f</Duration>\n"),  getDuration());
        _tprintf(_T("<DurationString>%s</DurationString>\n"), (const TCHAR*) getDurationString());
        _tprintf(_T("<SelectedForRip>%s</SelectedForRip>\n"), (const TCHAR*)isSelectedForRip());

        long count = getAttributeCount();
        _tprintf(_T("<Attributes Count=\"%d\">\n"), count);        
        
        for (long n = 0; n<count; n++) {
            _bstr_t name = getAttributeName(n);
            _bstr_t value = getItemInfo(name);            

            _bstr_t isReadOnly = "";
            if (isReadOnlyItem(name) == VARIANT_TRUE) {
                isReadOnly = "ReadOnly=\"True\"";
            }
            _bstr_t bname;
            _bstr_t bvalue;
            encoder.encode((const wchar_t*)name, bname);
            encoder.encode((const wchar_t*)value, bvalue);
            
            _tprintf(_T("<Attribute Name=\"%s\" Value=\"%s\" %s/>\n"),
                (const TCHAR*)bname,
                (const TCHAR*)bvalue,
                (const TCHAR*)isReadOnly);
        }
        _tprintf(_T("</Attributes>\n"));

        //2012/01/05
        try {
            WMPMetadataPicture picture = getMetadataPicture();
            picture.showProperties();
        } catch (...) {
        }
        try {
            WMPMetadataText text = getMetadataText();
            text.showProperties();
        } catch (...) {
        }
        _tprintf(_T("</Media>\n"));        
    } 

public:
    //2012/01/22
    virtual void writeProperties(Writer& writer)
    {
        HTMLEncoder encoder;
        _bstr_t url;
        encoder.encode((const wchar_t*)getSourceURL(), url);
        writer.writeln(L"<Media>");        

        writer.writeln(L"<Name>%s</Name>", (const wchar_t*)getName());        
        writer.writeln(L"<SourceURL>%s</SourceURL>", (const wchar_t*)url);            
        writer.writeln(L"<ImageSourceWidth>%d</ImageSourceWidth>", getImageSourceWidth());        
        writer.writeln(L"<ImageSourceHeight>%d</ImageSourceHeight>", getImageSourceHeight());        

        long mc = getMarkerCount();        
        writer.writeln(L"<Marker Count=\"%d\">", mc);        

        for (long i = 0; i<mc; i++) {
            double mtime = getMarkerTime(i);
            writer.writeln(L"<MarkerTime>%f</MarkerTime>\r\n<MarkerName>%s</MarkerName>",
                    media->getMarkerTime(i),
                (const wchar_t*)getMarkerName(i)
                );
        }
        writer.writeln(L"</Marker>");        

        writer.writeln(L"<Duration>%f</Duration>",  getDuration());
        writer.writeln(L"<DurationString>%s</DurationString>", (const wchar_t*) getDurationString());
    
        writer.writeln(L"<SelectedForRip>%s</SelectedForRip>", (const wchar_t*)isSelectedForRip());

        long count = getAttributeCount();
        writer.writeln(L"<Attributes Count=\"%d\">", count);        
        
        for (long n = 0; n<count; n++) {
            _bstr_t name = getAttributeName(n);
            _bstr_t value = getItemInfo(name);            

            _bstr_t isReadOnly = "";
            if (isReadOnlyItem(name) == VARIANT_TRUE) {
                isReadOnly = "ReadOnly=\"True\"";
            }
            _bstr_t bname;
            _bstr_t bvalue;
            encoder.encode((const wchar_t*)name, bname);
            encoder.encode((const wchar_t*)value, bvalue);
            
            writer.writeln(L"<Attribute Name=\"%s\" Value=\"%s\" %s/>",
                (const wchar_t*)bname,
                (const wchar_t*)bvalue,
                (const wchar_t*)isReadOnly);
        }
        writer.writeln(L"</Attributes>");

        //2012/01/05
        try {
            WMPMetadataPicture picture = getMetadataPicture();
            picture.writeProperties(writer);
        } catch (...) {
        }

        try {
            WMPMetadataText text = getMetadataText();
            text.writeProperties(writer);
        } catch (...) {
        }

        writer.writeln(L"</Media>");        
    } 
};

}