/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_slideshow.hxx"

// must be first
#include <canvas/debug.hxx>
#include <tools/diagnose_ex.h>
#include <canvas/verbosetrace.hxx>

#include <math.h>

#include <comphelper/anytostring.hxx>
#include <cppuhelper/exc_hlp.hxx>

#include <vcl/window.hxx>
#include <vcl/syschild.hxx>
#include <vcl/salbtype.hxx>

#include <basegfx/tools/canvastools.hxx>
#include <basegfx/numeric/ftools.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <basegfx/point/b2dpoint.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/range/b2irange.hxx>
#include <canvas/canvastools.hxx>
#include <cppcanvas/vclfactory.hxx>
#include <cppcanvas/basegfxfactory.hxx>
#include <cppcanvas/basegfxfactory.hxx>
#include <avmedia/mediawindow.hxx>

#include <com/sun/star/media/XManager.hpp>
#include <com/sun/star/media/XPlayer.hpp>
#include <com/sun/star/media/XPlayerWindow.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/lang/XMultiComponentFactory.hpp>
#include <com/sun/star/lang/NoSupportException.hpp>
#include <com/sun/star/awt/XWindow.hpp>
#include <com/sun/star/rendering/XCanvas.hpp>
#include <com/sun/star/lang/XComponent.hdl>

#include "viewmediashape.hxx"
#include "mediashape.hxx"
#include "tools.hxx"
#include "unoview.hxx"

using namespace ::com::sun::star;

namespace slideshow
{
    namespace internal
    {
        ViewMediaShape::ViewMediaShape( const ViewLayerSharedPtr&                       rViewLayer,
										const uno::Reference< drawing::XShape >&        rxShape,
                                        const uno::Reference< uno::XComponentContext >& rxContext ) :
			mpViewLayer( rViewLayer ),
			mpMediaWindow(),
			maWindowOffset( 0, 0 ),
            maBounds(),
			mxShape( rxShape ),
			mxPlayer(),
			mxPlayerWindow(),
            mxComponentContext( rxContext ),
            mbIsSoundEnabled(true)
        {
            ENSURE_OR_THROW( mxShape.is(), "ViewMediaShape::ViewMediaShape(): Invalid Shape" );
            ENSURE_OR_THROW( mpViewLayer, "ViewMediaShape::ViewMediaShape(): Invalid View" );
            ENSURE_OR_THROW( mpViewLayer->getCanvas(), "ViewMediaShape::ViewMediaShape(): Invalid ViewLayer canvas" );
            ENSURE_OR_THROW( mxComponentContext.is(), "ViewMediaShape::ViewMediaShape(): Invalid component context" );

            UnoViewSharedPtr pUnoView (::boost::dynamic_pointer_cast<UnoView>(rViewLayer));
            if (pUnoView)
            {
                mbIsSoundEnabled = pUnoView->isSoundEnabled();
            }
        }

		// ---------------------------------------------------------------------
				
		ViewMediaShape::~ViewMediaShape()
		{		
            try
            {
                endMedia();
            }
            catch (uno::Exception &) 
            {
                OSL_ENSURE( false, rtl::OUStringToOString(
                                comphelper::anyToString(
                                    cppu::getCaughtException() ),
                                RTL_TEXTENCODING_UTF8 ).getStr() );
            }
		}

		// ---------------------------------------------------------------------

        ViewLayerSharedPtr ViewMediaShape::getViewLayer() const
        {
            return mpViewLayer;
        }

		// ---------------------------------------------------------------------
		
        bool ViewMediaShape::startMedia()
        {
            if( !mxPlayer.is() )
			    implInitialize( maBounds );

            if( mxPlayer.is() && ( mxPlayer->getDuration() > 0.0 ) )
				mxPlayer->start();
			
			return true;
        }

		// ---------------------------------------------------------------------
		
        void ViewMediaShape::endMedia()
        {
			// shutdown player window
			if( mxPlayerWindow.is() )
			{
				uno::Reference< lang::XComponent > xComponent( mxPlayerWindow, uno::UNO_QUERY );
		
				if( xComponent.is() )
					xComponent->dispose();
			
				mxPlayerWindow.clear();
			}

            mpMediaWindow = ::std::auto_ptr< SystemChildWindow >();
            			
			// shutdown player
			if( mxPlayer.is() )
			{
				mxPlayer->stop();

				uno::Reference< lang::XComponent > xComponent( mxPlayer, uno::UNO_QUERY );
		
				if( xComponent.is() )
					xComponent->dispose();
			
				mxPlayer.clear();
			}
		}

		// ---------------------------------------------------------------------
		
        void ViewMediaShape::pauseMedia()
        {
            if( mxPlayer.is() && ( mxPlayer->getDuration() > 0.0 ) )
				mxPlayer->stop();
		}

		// ---------------------------------------------------------------------

        void ViewMediaShape::setMediaTime(double fTime)
        {
            if( mxPlayer.is() && ( mxPlayer->getDuration() > 0.0 ) )
				mxPlayer->setMediaTime(fTime);
        }

		// ---------------------------------------------------------------------
		
        bool ViewMediaShape::render( const ::basegfx::B2DRectangle&	rBounds ) const
        {
            ::cppcanvas::CanvasSharedPtr pCanvas = mpViewLayer->getCanvas();;

            if( !pCanvas )
                return false;

			if( !mpMediaWindow.get() && !mxPlayerWindow.is() )
			{
                // fill the shape background with black
                fillRect( pCanvas,
                          rBounds,
                          0x000000FFU );
			}

            return true;
        }

        bool ViewMediaShape::resize( const ::basegfx::B2DRectangle&	rNewBounds ) const
        {
            maBounds = rNewBounds;

            ::cppcanvas::CanvasSharedPtr pCanvas = mpViewLayer->getCanvas();;

            if( !pCanvas )
                return false;

			if( !mxPlayerWindow.is() )
                return true;

            uno::Reference< beans::XPropertySet > xPropSet( pCanvas->getUNOCanvas()->getDevice(),
                                                            uno::UNO_QUERY );
            
            uno::Reference< awt::XWindow > xParentWindow;
            if( xPropSet.is() &&
                getPropertyValue( xParentWindow,
                                  xPropSet,
                                  ::rtl::OUString::createFromAscii( "Window" )) )
            {
                const awt::Rectangle aRect( xParentWindow->getPosSize() );
                
                maWindowOffset.X = aRect.X;
                maWindowOffset.Y = aRect.Y;
            }

            ::basegfx::B2DRange aTmpRange;
            ::canvas::tools::calcTransformedRectBounds( aTmpRange, 
                                                        rNewBounds, 
                                                        mpViewLayer->getTransformation() );
            const ::basegfx::B2IRange& rRangePix(
                ::basegfx::unotools::b2ISurroundingRangeFromB2DRange( aTmpRange ));
				
            mxPlayerWindow->setEnable( !rRangePix.isEmpty() );
    														
            if( rRangePix.isEmpty() )
                return true;				    
					
            const Point aPosPixel( rRangePix.getMinX() + maWindowOffset.X,
                                   rRangePix.getMinY() + maWindowOffset.Y );
            const Size	aSizePixel( rRangePix.getMaxX() - rRangePix.getMinX(),
                                    rRangePix.getMaxY() - rRangePix.getMinY() );
            
            if( mpMediaWindow.get() )
            {
                mpMediaWindow->SetPosSizePixel( aPosPixel, aSizePixel );
                mxPlayerWindow->setPosSize( 0, 0, 
                                            aSizePixel.Width(), aSizePixel.Height(), 
                                            0 );
            }
            else
            {
                mxPlayerWindow->setPosSize( aPosPixel.X(), aPosPixel.Y(), 
                                            aSizePixel.Width(), aSizePixel.Height(), 
                                            0 );
            }

			return true;
        }
		
		// ---------------------------------------------------------------------
				
		bool ViewMediaShape::implInitialize( const ::basegfx::B2DRectangle& rBounds )
		{
			if( !mxPlayer.is() && mxShape.is() )
			{
				ENSURE_OR_RETURN_FALSE( mpViewLayer->getCanvas(), 
                                   "ViewMediaShape::update(): Invalid layer canvas" );

				uno::Reference< rendering::XCanvas > xCanvas( mpViewLayer->getCanvas()->getUNOCanvas() );

				if( xCanvas.is() )
				{
					uno::Reference< beans::XPropertySet >	xPropSet;
					::rtl::OUString 						aURL;
					
					try
					{
						xPropSet.set( mxShape, uno::UNO_QUERY );

						// create Player
						if( xPropSet.is() && 
							( xPropSet->getPropertyValue( 
                                  ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaURL" ) ) ) >>=aURL ) )
						{
							implInitializeMediaPlayer( aURL );
						}
						
						// create visible object
						uno::Sequence< uno::Any > aDeviceParams;
						
						if( ::canvas::tools::getDeviceInfo( xCanvas, aDeviceParams ).getLength() > 1 )
						{
							::rtl::OUString aImplName;
							
							aDeviceParams[ 0 ] >>= aImplName;
						
							if( aImplName.endsWithIgnoreAsciiCaseAsciiL( 
                                    RTL_CONSTASCII_STRINGPARAM("VCL") ))
                            {
								implInitializeVCLBasedPlayerWindow( rBounds, aDeviceParams );
                            }
							else if( aImplName.endsWithIgnoreAsciiCaseAsciiL( 
                                         RTL_CONSTASCII_STRINGPARAM("DX")) ||
									 aImplName.endsWithIgnoreAsciiCaseAsciiL( 
                                         RTL_CONSTASCII_STRINGPARAM("DX9")))
                            {
								implInitializeDXBasedPlayerWindow( rBounds, aDeviceParams );
                            }
						}
						
						// set player properties
						implSetMediaProperties( xPropSet );
					}
                    catch( uno::RuntimeException& )
                    {
                        throw;
                    }
					catch( uno::Exception& )
					{
                        OSL_ENSURE( false,
                                    rtl::OUStringToOString(
                                        comphelper::anyToString( cppu::getCaughtException() ),
                                        RTL_TEXTENCODING_UTF8 ).getStr() ); 
					}
				}
			}
			
			return mxPlayer.is() || mxPlayerWindow.is();
	    }

		// ---------------------------------------------------------------------
		
		void ViewMediaShape::implSetMediaProperties( const uno::Reference< beans::XPropertySet >& rxProps )
		{
			if( mxPlayer.is() )
			{
				mxPlayer->setMediaTime( 0.0 );
			
                if( rxProps.is() )
                {
					sal_Bool bLoop( false );
					getPropertyValue( bLoop,
                                      rxProps,
                                      ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Loop" )));
					mxPlayer->setPlaybackLoop( bLoop );

					sal_Bool bMute( false );
					getPropertyValue( bMute,
                                      rxProps,
                                      ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Mute" )));
					mxPlayer->setMute( bMute || !mbIsSoundEnabled);

					sal_Int16 nVolumeDB(0);
					getPropertyValue( nVolumeDB,
                                      rxProps,
                                      ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "VolumeDB" )));
					mxPlayer->setVolumeDB( nVolumeDB );
				
                    if( mxPlayerWindow.is() )
                    {
						media::ZoomLevel eZoom(media::ZoomLevel_FIT_TO_WINDOW);
						getPropertyValue( eZoom,
                                          rxProps,
                                          ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Zoom" )));
						mxPlayerWindow->setZoomLevel( eZoom );
					}
				}
			}
		}
		
		// ---------------------------------------------------------------------
				
		void ViewMediaShape::implInitializeMediaPlayer( const ::rtl::OUString& rMediaURL )
		{
			if( !mxPlayer.is() )
			{
				try
				{
					if( rMediaURL.getLength() )
					{
						mxPlayer.set( avmedia::MediaWindow::createPlayer( rMediaURL ), 
                            uno::UNO_QUERY );
					}
				}
                catch( uno::RuntimeException& )
                {
                    throw;
                }
				catch( const uno::Exception& )
				{
                    throw lang::NoSupportException(
                        rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
                                           "No video support for ") ) + rMediaURL,
                        uno::Reference<uno::XInterface>() );
				}
			}
		}

		// ---------------------------------------------------------------------
					
		bool ViewMediaShape::implInitializeVCLBasedPlayerWindow( const ::basegfx::B2DRectangle&   rBounds,
																 const uno::Sequence< uno::Any >& rVCLDeviceParams)
		{
			if( !mpMediaWindow.get() && !rBounds.isEmpty() )
			{
				try
				{
					sal_Int64 aVal=0;
					
					rVCLDeviceParams[ 1 ] >>= aVal;
					
					Window* pWindow = reinterpret_cast< Window* >( aVal );
					
					if( pWindow )
					{
						::basegfx::B2DRange aTmpRange;
						::canvas::tools::calcTransformedRectBounds( aTmpRange, 
                                                                    rBounds, 
																	mpViewLayer->getTransformation() );
                        const ::basegfx::B2IRange& rRangePix(
                            ::basegfx::unotools::b2ISurroundingRangeFromB2DRange( aTmpRange ));
																	
						if( !rRangePix.isEmpty() )
						{
							uno::Sequence< uno::Any > 	aArgs( 3 );
							awt::Rectangle				aAWTRect( rRangePix.getMinX(),
																  rRangePix.getMinY(),
														  		  rRangePix.getMaxX() - rRangePix.getMinX(),
														  		  rRangePix.getMaxY() - rRangePix.getMinY() );

							mpMediaWindow = ::std::auto_ptr< SystemChildWindow >( new
                                                SystemChildWindow( pWindow, WB_CLIPCHILDREN ) );
							mpMediaWindow->SetBackground( Color( COL_BLACK ) );
							mpMediaWindow->SetPosSizePixel( Point( aAWTRect.X, aAWTRect.Y ),
                                                           Size( aAWTRect.Width, aAWTRect.Height ) );
							mpMediaWindow->Show();
							
							if( mxPlayer.is() )
							{
								aArgs[ 0 ] = uno::makeAny( 
                                    sal::static_int_cast< sal_IntPtr >( mpMediaWindow->GetParentWindowHandle() ) );
								
								aAWTRect.X = aAWTRect.Y = 0;
								aArgs[ 1 ] = uno::makeAny( aAWTRect );

                                aArgs[ 2 ] = uno::makeAny( reinterpret_cast< sal_IntPtr >( mpMediaWindow.get() ) );
								
								mxPlayerWindow.set( mxPlayer->createPlayerWindow( aArgs ) );
								
								if( mxPlayerWindow.is() )
								{
									mxPlayerWindow->setVisible( true );
									mxPlayerWindow->setEnable( true );
								}
							}
						}
					}
				}
                catch( uno::RuntimeException& )
                {
                    throw;
                }
				catch( uno::Exception& )
				{
                    OSL_ENSURE( false,
                                rtl::OUStringToOString(
                                    comphelper::anyToString( cppu::getCaughtException() ),
                                    RTL_TEXTENCODING_UTF8 ).getStr() ); 
				}
			}
			
			return mxPlayerWindow.is();
		}
		
		// ---------------------------------------------------------------------
	
		bool ViewMediaShape::implInitializeDXBasedPlayerWindow( const ::basegfx::B2DRectangle&   rBounds,
																const uno::Sequence< uno::Any >& rDXDeviceParams )
		{
            if( !mxPlayerWindow.is() )
	    	{
        		try
		        {
				    if( rDXDeviceParams.getLength() == 2 )
				    {
					    sal_Int64 aWNDVal=0;
    					
					    rDXDeviceParams[ 1 ] >>= aWNDVal;
   					
					    if( aWNDVal )
					    {
						    ::basegfx::B2DRange aTmpRange;
						    ::canvas::tools::calcTransformedRectBounds( aTmpRange, 
                                                                        rBounds, 
																	    mpViewLayer->getTransformation() );
                            const ::basegfx::B2IRange& rRangePix(
                                ::basegfx::unotools::b2ISurroundingRangeFromB2DRange( aTmpRange ));
    																	
						    if( !rRangePix.isEmpty() )
						    {
							    uno::Sequence< uno::Any > 	aArgs( 2 );
							    awt::Rectangle				aAWTRect( rRangePix.getMinX() + maWindowOffset.X,
                                                                      rRangePix.getMinY() + maWindowOffset.Y,
                                                                      rRangePix.getMaxX() - rRangePix.getMinX(),
                                                                      rRangePix.getMaxY() - rRangePix.getMinY() );

							    if( mxPlayer.is() )
							    {
								    aArgs[ 0 ] = uno::makeAny( sal::static_int_cast< sal_Int32 >( aWNDVal) );
								    aArgs[ 1 ] = uno::makeAny( aAWTRect );

								    mxPlayerWindow.set( mxPlayer->createPlayerWindow( aArgs ) );
							    }
						    }
					    }
				    }
    			}
                catch( uno::RuntimeException& )
                {
                    throw;
                }
	    	    catch( uno::Exception& )
		        {
                    OSL_ENSURE( false,
                                rtl::OUStringToOString(
                                    comphelper::anyToString( cppu::getCaughtException() ),
                                    RTL_TEXTENCODING_UTF8 ).getStr() ); 
		        }
		    }
			
			return mxPlayerWindow.is();
		}
	}
}