/**************************************************************
 * 
 * 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_sc.hxx"
#include "XMLTableShapeResizer.hxx"
#include "unonames.hxx"
#include "document.hxx"
#include "xmlimprt.hxx"
#include "chartlis.hxx"
#include "XMLConverter.hxx"
#include "rangeutl.hxx"
#include "reftokenhelper.hxx"
#include <tools/debug.hxx>
#include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
#include <com/sun/star/table/XColumnRowRange.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>

#include <memory>
#include <vector>

using namespace ::com::sun::star;
using ::std::auto_ptr;
using ::std::vector;
using ::rtl::OUString;

ScMyShapeResizer::ScMyShapeResizer(ScXMLImport& rTempImport)
    : rImport(rTempImport),
    aShapes(),
	pCollection(NULL)
{
}

ScMyShapeResizer::~ScMyShapeResizer()
{
}

sal_Bool ScMyShapeResizer::IsOLE(uno::Reference< drawing::XShape >& rShape) const
{
	return rShape->getShapeType().equals(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.OLE2Shape")));
}

void ScMyShapeResizer::CreateChartListener(ScDocument* pDoc,
	const rtl::OUString& rName,
	const rtl::OUString* pRangeList)
{
    if (!pDoc || !pRangeList)
        // These are minimum required.
        return;

    if (!pRangeList->getLength())
    {
        pDoc->AddOLEObjectToCollection(rName);
        return;
    }

    OUString aRangeStr;
    ScRangeStringConverter::GetStringFromXMLRangeString(aRangeStr, *pRangeList, pDoc);
    if (!aRangeStr.getLength())
    {
        pDoc->AddOLEObjectToCollection(rName);
        return;
    }

    if (!pCollection)
        pCollection = pDoc->GetChartListenerCollection();

    if (!pCollection)
        return;

    auto_ptr< vector<ScSharedTokenRef> > pRefTokens(new vector<ScSharedTokenRef>);
    ScRefTokenHelper::compileRangeRepresentation(*pRefTokens, aRangeStr, pDoc);
    if (!pRefTokens->empty())
    {
        ScChartListener* pCL(new ScChartListener(rName, pDoc, pRefTokens.release()));

        //for loading binary files e.g.
        //if we have the flat filter we need to set the dirty flag thus the visible charts get repainted
        //otherwise the charts keep their first visual representation which was created at a moment where the calc itself was not loaded completly and is incorect therefor
        if( (rImport.getImportFlags() & IMPORT_ALL) == IMPORT_ALL )
            pCL->SetDirty( sal_True );
        else
        {
            // #i104899# If a formula cell is already dirty, further changes aren't propagated.
            // This can happen easily now that row heights aren't updated for all sheets.
            pDoc->InterpretDirtyCells( *pCL->GetRangeList() );
        }

        pCollection->Insert( pCL );
        pCL->StartListeningTo();
    }
}

void ScMyShapeResizer::AddShape(uno::Reference <drawing::XShape>& rShape,
	rtl::OUString* pRangeList,
	table::CellAddress& rStartAddress, table::CellAddress& rEndAddress,
	sal_Int32 nEndX, sal_Int32 nEndY)
{
	ScMyToResizeShape aShape;
	aShape.xShape.set(rShape);
	aShape.pRangeList = pRangeList;
	aShape.aEndCell = rEndAddress;
	aShape.aStartCell = rStartAddress;
	aShape.nEndY = nEndY;
	aShape.nEndX = nEndX;
	aShapes.push_back(aShape);
}

void ScMyShapeResizer::GetNewShapeSizePos(ScDocument* pDoc, const Rectangle& rStartRect,
                                          const table::CellAddress& rEndCell,
                                          awt::Point& rPoint, awt::Size& rSize,
                                          sal_Int32& rEndX, sal_Int32& rEndY) const
{
	awt::Point aRefPoint;
    sal_Bool bNegativePage(pDoc->IsNegativePage(rEndCell.Sheet));
    if (bNegativePage)
        aRefPoint.X = rStartRect.Right();
    else
	    aRefPoint.X = rStartRect.Left();
	aRefPoint.Y = rStartRect.Top();
	Rectangle aRect(pDoc->GetMMRect(
		static_cast<SCCOL>(rEndCell.Column), static_cast<SCROW>(rEndCell.Row),
		static_cast<SCCOL>(rEndCell.Column), static_cast<SCROW>(rEndCell.Row), rEndCell.Sheet ));
    if (bNegativePage)
        rEndX = -rEndX + aRect.Right();
    else
	    rEndX += aRect.Left();
	rEndY += aRect.Top();
	rPoint.X += aRefPoint.X;
    if (bNegativePage)
    {
	    if (rPoint.X < rStartRect.Left())
		    rPoint.X = rStartRect.Left() + 2; // increment by 2 100th_mm because the cellwidth is internal in twips
    }
    else
    {
	    if (rPoint.X > rStartRect.Right())
		    rPoint.X = rStartRect.Right() - 2; // decrement by 2 100th_mm because the cellwidth is internal in twips
    }
	rPoint.Y += aRefPoint.Y;
	if (rPoint.Y > rStartRect.Bottom())
		rPoint.Y = rStartRect.Bottom() - 2; // decrement by 2 100th_mm because the cellheight is internal in twips
    if (bNegativePage)
    {
        rSize.Width = -(rEndX - rPoint.X);
    }
    else
	    rSize.Width = rEndX - rPoint.X;
	rSize.Height = rEndY - rPoint.Y;
}

void ScMyShapeResizer::ResizeShapes()
{
	if (!aShapes.empty() && rImport.GetModel().is())
	{
		rtl::OUString sRowHeight(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_CELLHGT));
		rtl::OUString sPersistName (RTL_CONSTASCII_USTRINGPARAM("PersistName"));
		rtl::OUString sCaptionPoint( RTL_CONSTASCII_USTRINGPARAM( "CaptionPoint" ));
        rtl::OUString sConnectorShape( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.ConnectorShape") );
        rtl::OUString sCaptionShape( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.CaptionShape") );
        rtl::OUString sStartShape(RTL_CONSTASCII_USTRINGPARAM("StartShape"));
        rtl::OUString sEndShape(RTL_CONSTASCII_USTRINGPARAM("EndShape"));
        rtl::OUString sStartPosition(RTL_CONSTASCII_USTRINGPARAM("StartPosition"));
        rtl::OUString sEndPosition(RTL_CONSTASCII_USTRINGPARAM("EndPosition"));
		uno::Reference<table::XCellRange> xTableRow;
		uno::Reference<sheet::XSpreadsheet> xSheet;
		uno::Reference<table::XTableRows> xTableRows;
		sal_Int32 nOldRow(-1);
		sal_Int32 nOldSheet(-1);
		ScMyToResizeShapes::iterator aItr(aShapes.begin());
		ScMyToResizeShapes::iterator aEndItr(aShapes.end());
		uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( rImport.GetModel(), uno::UNO_QUERY );
		if ( xSpreadDoc.is() )
		{
			uno::Reference<container::XIndexAccess> xIndex( xSpreadDoc->getSheets(), uno::UNO_QUERY );
			ScDocument* pDoc(rImport.GetDocument());
			if ( pDoc && xIndex.is() )
			{
				rImport.LockSolarMutex();
				while (aItr != aEndItr)
				{
                    // #i78086# invalid cell position is used to call CreateChartListener only
                    if ( aItr->aEndCell.Sheet >= 0 )
                    {
    					if ((nOldSheet != aItr->aEndCell.Sheet) || !xSheet.is())
    					{
    						nOldSheet = aItr->aEndCell.Sheet;
                            xSheet.set(xIndex->getByIndex(nOldSheet), uno::UNO_QUERY);
    						if (xSheet.is())
    						{
    							uno::Reference<table::XColumnRowRange> xColumnRowRange (xSheet, uno::UNO_QUERY);
    							if (xColumnRowRange.is())
    								xTableRows = xColumnRowRange->getRows();
    						}
    					}
    					if (xTableRows.is())
    					{
    						if (nOldRow != aItr->aEndCell.Row || !xTableRow.is())
    						{
    							nOldRow = aItr->aEndCell.Row;
    							xTableRows->getByIndex(nOldRow) >>= xTableRow;
    						}
    						if (xTableRow.is())
    						{
    							uno::Reference <beans::XPropertySet> xRowProperties(xTableRow, uno::UNO_QUERY);
    							if (xRowProperties.is())
    							{
    								sal_Int32 nHeight;
    								if (xRowProperties->getPropertyValue(sRowHeight) >>= nHeight)
    								{
    									Rectangle aRec = pDoc->GetMMRect(static_cast<SCCOL>(aItr->aStartCell.Column), static_cast<SCROW>(aItr->aStartCell.Row),
    										static_cast<SCCOL>(aItr->aStartCell.Column), static_cast<SCROW>(aItr->aStartCell.Row), aItr->aStartCell.Sheet);
    									awt::Point aPoint(aItr->xShape->getPosition());
    									awt::Size aSize(aItr->xShape->getSize());
                                        if (pDoc->IsNegativePage(static_cast<SCTAB>(nOldSheet)))
                                            aPoint.X += aSize.Width;
    									if (aItr->nEndY >= 0 && aItr->nEndX >= 0)
    									{
                                            if (aItr->xShape->getShapeType().equals(sConnectorShape))
                                            {
                                                //#103122#; handle connected Connectorshapes
                                                uno::Reference<beans::XPropertySet> xShapeProps (aItr->xShape, uno::UNO_QUERY);
                                                if(xShapeProps.is())
                                                {
                                                    uno::Reference<drawing::XShape> xStartShape(xShapeProps->getPropertyValue(	sStartShape ), uno::UNO_QUERY);
                                                    uno::Reference<drawing::XShape> xEndShape(xShapeProps->getPropertyValue( sEndShape ), uno::UNO_QUERY);
                                                    if (!xStartShape.is() && !xEndShape.is())
                                                    {
    										            awt::Size aOldSize(aSize);
                                                        GetNewShapeSizePos(pDoc, aRec, aItr->aEndCell, aPoint, aSize, aItr->nEndX, aItr->nEndY);
    	                                                aItr->xShape->setPosition(aPoint);
    	                                                if( (aSize.Width != aOldSize.Width) ||
    		                                                (aSize.Height != aOldSize.Height) )
    		                                                aItr->xShape->setSize(aSize);
                                                    }
                                                    else if (xStartShape.is() && xEndShape.is())
                                                    {
                                                        // do nothing, because they are connected
                                                    }
                                                    else
                                                    {
                                                        // only one point is connected, the other should be moved

                                                        rtl::OUString sProperty;
                                                        if (xStartShape.is())
                                                        {
                                                            awt::Point aEndPoint;
                                                            xShapeProps->getPropertyValue(sEndPosition) >>= aEndPoint;
                                                            aPoint.X = aRec.Left() + aEndPoint.X;
                                                            aPoint.Y = aRec.Top() + aEndPoint.Y;
                                                            sProperty = sEndPosition;
                                                        }
                                                        else
                                                        {
                                                            awt::Point aStartPoint;
                                                            xShapeProps->getPropertyValue(sStartPosition) >>= aStartPoint;
                                                            aPoint.X = aRec.Left() + aStartPoint.X;
                                                            aPoint.Y = aRec.Top() + aStartPoint.Y;
                                                            sProperty = sStartPosition;
                                                        }
                                                        xShapeProps->setPropertyValue(sProperty, uno::makeAny(aPoint));
                                                    }
                                                }
                                            }
                                            else
                                            {
    										    awt::Size aOldSize(aSize);
                                                GetNewShapeSizePos(pDoc, aRec, aItr->aEndCell, aPoint, aSize, aItr->nEndX, aItr->nEndY);
                                                if (pDoc->IsNegativePage(static_cast<SCTAB>(nOldSheet)))
                                                    aPoint.X -= aSize.Width;
    	                                        aItr->xShape->setPosition(aPoint);
    	                                        if( (aSize.Width != aOldSize.Width) ||
    		                                        (aSize.Height != aOldSize.Height) )
    		                                        aItr->xShape->setSize(aSize);
                                            }
    									}
    									else
    									{
    										if (aItr->xShape->getShapeType().equals(sCaptionShape))
    										{
    											Rectangle aRectangle(aPoint.X, aPoint.Y, aPoint.X + aSize.Width, aPoint.Y + aSize.Height);

    											awt::Point aCaptionPoint;
    											uno::Reference< beans::XPropertySet > xShapeProps(aItr->xShape, uno::UNO_QUERY);
    											if (xShapeProps.is())
    											{
    												try
    												{
    													xShapeProps->getPropertyValue( sCaptionPoint ) >>= aCaptionPoint;
    												}
    												catch ( uno::Exception& )
    												{
    													DBG_ERROR("This Captionshape has no CaptionPoint property.");
    												}
    											}
    											Point aCorePoint(aPoint.X, aPoint.Y);
    											Point aCoreCaptionPoint(aCaptionPoint.X, aCaptionPoint.Y);
    											aCoreCaptionPoint += aCorePoint;
    											aRectangle.Union(Rectangle(aCoreCaptionPoint, aCoreCaptionPoint));

    											Point aBeforeRightBottomPoint(aRectangle.BottomRight());

    											aRectangle += aRec.TopLeft();
    											if (aRectangle.Left() > aRec.Right())
    												aRectangle -= (Point(aRectangle.Left() - aRec.Right() + 2, 0));
    											if (aRectangle.Top() > aRec.Bottom())
    												aRectangle -= (Point(0, aRectangle.Top() - aRec.Bottom() + 2));

    											Point aDifferencePoint(aRectangle.BottomRight() - aBeforeRightBottomPoint);
    											aPoint.X += aDifferencePoint.X();
    											aPoint.Y += aDifferencePoint.Y();

    											aItr->xShape->setPosition(aPoint);
    										}
    										else
    										{
    											// #96159# it is possible, that shapes have a negative position
    											// this is now handled here
    											DBG_ERROR("no or negative end address of this shape");
    											awt::Point aRefPoint;
    											aRefPoint.X = aRec.Left();
    											aRefPoint.Y = aRec.Top();
    											aPoint.X += aRefPoint.X;
    											if (aPoint.X > aRec.Right())
    												aPoint.X = aRec.Right() - 2; // decrement by 2 100th_mm because the cellheight is internal in twips
    											aPoint.Y += aRefPoint.Y;
    											if (aPoint.Y > aRec.Bottom())
    												aPoint.Y = aRec.Bottom() - 2; // decrement by 2 100th_mm because the cellheight is internal in twips
    											aItr->xShape->setPosition(aPoint);
    										}
    									}
    								}
    							}
    						}
    					}
    					else
					{
    						DBG_ERROR("something wents wrong");
					}
                    }
                    // #i78086# call CreateChartListener also for invalid position (anchored to sheet)
					if (IsOLE(aItr->xShape))
					{
						uno::Reference < beans::XPropertySet > xShapeProps ( aItr->xShape, uno::UNO_QUERY );
						uno::Reference < beans::XPropertySetInfo > xShapeInfo(xShapeProps->getPropertySetInfo());
                        rtl::OUString sName;
						if (xShapeProps.is() && xShapeInfo.is() && xShapeInfo->hasPropertyByName(sPersistName) &&
                            (xShapeProps->getPropertyValue(sPersistName) >>= sName))
							CreateChartListener(pDoc, sName, aItr->pRangeList);
					}
					if (aItr->pRangeList)
						delete aItr->pRangeList;
					aItr = aShapes.erase(aItr);
				}
				rImport.UnlockSolarMutex();
//				if (pCollection)
//					pDoc->SetChartListenerCollection(pCollection);
			}
		}
	}
}