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



// SOL9
// 2011/12/12

#pragma once

#include <sol/wmp/WMPObject.h>

namespace SOL {

class WMPNetwork :public WMPObject {

private:
    IWMPNetworkPtr network;

public:
    WMPNetwork(IWMPNetworkPtr ptr)
    :network(ptr)
    {
        if(ptr == NULL) {
            throw NullPointerException("IWMPNetworkPtr is NULL", 0);
        }
    }

public:
    ~WMPNetwork()
    {
        network = NULL;
    }

public:
    long getBandWidth()
    {
        return network->GetbandWidth();
    }

    long getRecoveredPackets()
    {
        return network->GetrecoveredPackets();
    }

    _bstr_t getSourceProtocol()
    {
        return network->GetsourceProtocol();
    }

    long getReceivedPackets()
    {
        return network->GetreceivedPackets();
    }

    long getLostPackets()
    {
        return network->GetlostPackets();
    }

    long getReceptionQuality()
    {
        return network->GetreceptionQuality();
    }

    long getBufferingCount()
    {
        return network->GetbufferingCount();
    }

    long getBufferingProgress()
    {
        return network->GetbufferingProgress();
    }

    long getBufferingTime()
    {
        return network->GetbufferingTime();
    }

    void putBufferingTime(long plBufferingTime)
    {
        network->PutbufferingTime(plBufferingTime);
    }

    long getFrameRate()
    {
        return network->GetframeRate();
    }

    long getMaxBitRate()
    {
        return network->GetmaxBitRate();
    }

    long getBitRate()
    {
        return network->GetbitRate();
    }

/*
The getProxySettings returns the following values:
0: A proxy server is not being used.
1: The proxy settings for the current browser are being used (only valid for HTTP).
2: The manually specified proxy settings are being used.
3: The proxy settings are being auto-detected
*/
    long getProxySettings(_bstr_t bstrProtocol)
    {
        return network->getProxySettings(bstrProtocol);
    }

    HRESULT setProxySettings(_bstr_t bstrProtocol, long lProxySetting)
    {
        return network->setProxySettings(bstrProtocol, lProxySetting);
    }

    _bstr_t getProxyName(_bstr_t bstrProtocol)
    {
        return network->getProxyName(bstrProtocol);
    }

    HRESULT setProxyName(_bstr_t bstrProtocol, _bstr_t bstrProxyName)
    {
        return network->setProxyName(bstrProtocol, bstrProxyName);
    }

    long getProxyPort(_bstr_t bstrProtocol)
    {
        return network->getProxyPort(bstrProtocol);
    }

    HRESULT setProxyPort(_bstr_t bstrProtocol, long lProxyPort)
    {
        return network->setProxyPort(bstrProtocol, lProxyPort);
    }

    _bstr_t getProxyExceptionList(_bstr_t bstrProtocol)
    {
        return network->getProxyExceptionList(bstrProtocol);
    }

    HRESULT setProxyExceptionList(_bstr_t bstrProtocol, _bstr_t pbstrExceptionList)
    {
        return network->setProxyExceptionList(bstrProtocol, pbstrExceptionList);
    }

    VARIANT_BOOL getProxyBypassForLocal(_bstr_t bstrProtocol)
    {
        return network->getProxyBypassForLocal(bstrProtocol);
    }

    const TCHAR* getProxyBypassFlagForLocal(_bstr_t bstrProtocol)
    {
        const TCHAR* flag = _T("false");
        if (network->getProxyBypassForLocal(bstrProtocol) == VARIANT_TRUE) {
            flag = _T("true");
        }
        return flag;
    }

    HRESULT setProxyBypassForLocal(_bstr_t bstrProtocol, VARIANT_BOOL fBypassForLocal)
    {
        return network->setProxyBypassForLocal(bstrProtocol, fBypassForLocal);
    }

    long getmaxBandwidth()
    {
        return network->GetmaxBandwidth();
    }

    void putMaxBandwidth(long lMaxBandwidth)
    {
        network->PutmaxBandwidth(lMaxBandwidth);
    }

    long getDownloadProgress()
    {
        return network->GetdownloadProgress();
    }

    long getEncodedFrameRate()
    {
        return network->GetencodedFrameRate();
    }

    long getFramesSkipped()
    {
        return network->GetframesSkipped();
    }

//
public:
    virtual void showProperties(HWND hwnd = NULL)
    {
        _tprintf(_T("<WMPNetwork>\n"));
        _tprintf(_T("<BandWidth>%ld</BandWidth>\n"),  getBandWidth() );
        _tprintf(_T("<ReceivedPackets>%ld</ReceivedPackets>\n"), getRecoveredPackets() );
        _tprintf(_T("<LostPackets>%ld</LostPackets>\n"), getLostPackets() );
        _tprintf(_T("<ReceptionQuality>%ld</ReceptionQuality>\n"), getReceptionQuality() );
        _tprintf(_T("<BufferingCount>%ld</BufferingCount>\n"), getBufferingCount() );
        _tprintf(_T("<BufferingProgress>%ld</BufferingProgress>\n"), getBufferingProgress() );
        _tprintf(_T("<BufferingTime>%ld</BufferingTime>\n"), getBufferingTime() );

        try {
            _tprintf(_T("<FrameRate>%ld</FrameRate>\n"), getFrameRate() );
        } catch (...) {
        }
        try {
            _tprintf(_T("<MaxBitRate>%ld</MaxBitRate>\n"), getMaxBitRate() );
        } catch (...) {
        }
        try {
            _tprintf(_T("<BitRate>%ld</BitRate>\n"), getBitRate() );
        } catch (...) {
        }

        _bstr_t bstrProtocol[2] = {_bstr_t("HTTP"), _bstr_t("MMS") };
        for (int i = 0; i< SizeOf(bstrProtocol); i++) {
            try {
                if (getProxySettings(bstrProtocol[i]) != 0) {
                    _tprintf(_T("<Proxy>\n"));
                    _tprintf(_T("<Protocol>%s</Protocol>\n"), (const TCHAR*)bstrProtocol[i]); 
                    
                    _tprintf(_T("<ProxyName>%s</ProxyName>\n"),  
                            (const TCHAR*) getProxyName(bstrProtocol[i]) );
                    _tprintf(_T("<ProxyPort>%d</ProxyPort>\n"), 
                            (const TCHAR*)getProxyPort(bstrProtocol[i]) );
                    _tprintf(_T("<ProxyException>%s</ProxyException>\n"), 
                            (const TCHAR*)getProxyExceptionList(bstrProtocol[i]) );
                    _tprintf(_T("<ProxyBypassForLocal>%s</ProxyBypassForLocal>\n"), 
                            (const TCHAR*)getProxyBypassFlagForLocal(bstrProtocol[i]) );
                    _tprintf(_T("</Proxy>\n"));

                } else {
                    //_tprintf(_T("No proxySettings for %s\n"), (const TCHAR*)bstrProtocol[i]);
                }
            } catch (...) {
            }
        }
        try {
            _tprintf(_T("<MaxBandWidth>%ld</MaxBandWidth>\n"), getmaxBandwidth() );
        } catch (...) {
        }
        try {
            _tprintf(_T("<DownloadProgress>%ld</DownloadProgress>\n"), getDownloadProgress() );
        } catch (...) {
        }
        try {
            _tprintf(_T("<EncodedFrameRate>%ld</EncodedFrameRate>\n"), getEncodedFrameRate() );
        } catch (...) {
        }
        try {
            _tprintf(_T("<FrameSkipped>%ld</FrameSkipped>\n"), getFramesSkipped() );
        } catch (...) {
        }
        _tprintf(_T("</WMPNetwork>\n"));
    }

public:
    virtual void writeProperties(Writer& writer)
    {
        writer.writeln(L"<WMPNetwork>");
        writer.writeln(L"<BandWidth>%ld</BandWidth>",  getBandWidth() );
        writer.writeln(L"<ReceivedPackets>%ld</ReceivedPackets>", getRecoveredPackets() );
        writer.writeln(L"<LostPackets>%ld</LostPackets>", getLostPackets() );
        writer.writeln(L"<ReceptionQuality>%ld</ReceptionQuality>", getReceptionQuality() );
        writer.writeln(L"<BufferingCount>%ld</BufferingCount>", getBufferingCount() );
        writer.writeln(L"<BufferingProgress>%ld</BufferingProgress>", getBufferingProgress() );
        writer.writeln(L"<BufferingTime>%ld</BufferingTime>", getBufferingTime() );

        try {
            writer.writeln(L"<FrameRate>%ld</FrameRate>", getFrameRate() );
        } catch (...) {
        }
        try {
            writer.writeln(L"<MaxBitRate>%ld</MaxBitRate>", getMaxBitRate() );
        } catch (...) {
        }
        try {
            writer.writeln(L"<BitRate>%ld</BitRate>", getBitRate() );
        } catch (...) {
        }

        _bstr_t bstrProtocol[2] = {_bstr_t("HTTP"), _bstr_t("MMS") };
        for (int i = 0; i< SizeOf(bstrProtocol); i++) {
            try {
                if (getProxySettings(bstrProtocol[i]) != 0) {
                    writer.writeln(L"<Proxy>");
                    writer.writeln(L"<Protocol>%s</Protocol>", (const wchar_t*)bstrProtocol[i]); 
                    
                    writer.writeln(L"<ProxyName>%s</ProxyName>",  
                            (const wchar_t*) getProxyName(bstrProtocol[i]) );
                    writer.writeln(L"<ProxyPort>%d</ProxyPort>", 
                            (const wchar_t*)getProxyPort(bstrProtocol[i]) );
                    writer.writeln(L"<ProxyException>%s</ProxyException>", 
                            (const wchar_t*)getProxyExceptionList(bstrProtocol[i]) );
                    writer.writeln(L"<ProxyBypassForLocal>%s</ProxyBypassForLocal>", 
                            (const wchar_t*)getProxyBypassFlagForLocal(bstrProtocol[i]) );
                    writer.writeln(L"</Proxy>");
                } else {
                    //_tprintf(_T("No proxySettings for %s\n"), (const TCHAR*)bstrProtocol[i]);
                }
            } catch (...) {
            }
        }
        try {
            writer.writeln(L"<MaxBandWidth>%ld</MaxBandWidth>", getmaxBandwidth() );
        } catch (...) {
        }
        try {
            writer.writeln(L"<DownloadProgress>%ld</DownloadProgress>", getDownloadProgress() );
        } catch (...) {
        }
        try {
            writer.writeln(L"<EncodedFrameRate>%ld</EncodedFrameRate>", getEncodedFrameRate() );
        } catch (...) {
        }
        try {
            writer.writeln(L"<FrameSkipped>%ld</FrameSkipped>", getFramesSkipped() );
        } catch (...) {
        }
        writer.writeln(L"</WMPNetwork>");
    }

};

}