/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   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 .

 */

#include <CommonConverters.hxx>

#include <com/sun/star/awt/Rectangle.hpp>

#include <com/sun/star/drawing/DoubleSequence.hpp>

#include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>

#include <com/sun/star/chart2/data/XDataSequence.hpp>

#include <com/sun/star/chart2/data/XNumericalDataSequence.hpp>

#include <com/sun/star/chart2/data/XTextualDataSequence.hpp>

#include <o3tl/safeint.hxx>

#include <osl/diagnose.h>

#include <basegfx/matrix/b3dhommatrix.hxx>

#include <basegfx/polygon/b2dpolygontools.hxx>

#include <cstddef>

#include <limits>

namespace chart

{

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

//  diverse methods for class conversions; e.g. ::basegfx::B3DHomMatrix to HomogenMatrix

drawing::HomogenMatrix B3DHomMatrixToHomogenMatrix( const ::basegfx::B3DHomMatrix& rM )

{

    drawing::HomogenMatrix aHM;

    aHM.Line1.Column1 = rM.get(0, 0);

    aHM.Line1.Column2 = rM.get(0, 1);

    aHM.Line1.Column3 = rM.get(0, 2);

    aHM.Line1.Column4 = rM.get(0, 3);

    aHM.Line2.Column1 = rM.get(1, 0);

    aHM.Line2.Column2 = rM.get(1, 1);

    aHM.Line2.Column3 = rM.get(1, 2);

    aHM.Line2.Column4 = rM.get(1, 3);

    aHM.Line3.Column1 = rM.get(2, 0);

    aHM.Line3.Column2 = rM.get(2, 1);

    aHM.Line3.Column3 = rM.get(2, 2);

    aHM.Line3.Column4 = rM.get(2, 3);

    aHM.Line4.Column1 = rM.get(3, 0);

    aHM.Line4.Column2 = rM.get(3, 1);

    aHM.Line4.Column3 = rM.get(3, 2);

    aHM.Line4.Column4 = rM.get(3, 3);

    return aHM;

}

::basegfx::B3DHomMatrix HomogenMatrixToB3DHomMatrix( const drawing::HomogenMatrix& rHM )

{

    ::basegfx::B3DHomMatrix aM;

    aM.set(0, 0, rHM.Line1.Column1);

    aM.set(0, 1, rHM.Line1.Column2);

    aM.set(0, 2, rHM.Line1.Column3);

    aM.set(0, 3, rHM.Line1.Column4);

    aM.set(1, 0, rHM.Line2.Column1);

    aM.set(1, 1, rHM.Line2.Column2);

    aM.set(1, 2, rHM.Line2.Column3);

    aM.set(1, 3, rHM.Line2.Column4);

    aM.set(2, 0, rHM.Line3.Column1);

    aM.set(2, 1, rHM.Line3.Column2);

    aM.set(2, 2, rHM.Line3.Column3);

    aM.set(2, 3, rHM.Line3.Column4);

    aM.set(3, 0, rHM.Line4.Column1);

    aM.set(3, 1, rHM.Line4.Column2);

    aM.set(3, 2, rHM.Line4.Column3);

    aM.set(3, 3, rHM.Line4.Column4);

    return aM;

}

::basegfx::B2DHomMatrix IgnoreZ( const ::basegfx::B3DHomMatrix& rM )

{

    ::basegfx::B2DHomMatrix aM;

    aM.set(0, 0, rM.get(0, 0));

    aM.set(0, 1, rM.get(0, 1));

    aM.set(0, 2, rM.get(0, 3));

    aM.set(1, 0, rM.get(1, 0));

    aM.set(1, 1, rM.get(1, 1));

    aM.set(1, 2, rM.get(1, 3));

    // For this to be a valid 2D transform matrix, the last row must be [0,0,1]

    assert( rM.get(3, 0) == 0 );

    assert( rM.get(3, 1) == 0 );

    assert( rM.get(3, 3) == 1 );

    return aM;

}

drawing::HomogenMatrix3 B2DHomMatrixToHomogenMatrix3( const ::basegfx::B2DHomMatrix& rM )

{

    drawing::HomogenMatrix3 aHM;

    aHM.Line1.Column1 = rM.get(0, 0);

    aHM.Line1.Column2 = rM.get(0, 1);

    aHM.Line1.Column3 = rM.get(0, 2);

    aHM.Line2.Column1 = rM.get(1, 0);

    aHM.Line2.Column2 = rM.get(1, 1);

    aHM.Line2.Column3 = rM.get(1, 2);

    aHM.Line3.Column1 = 0;

    aHM.Line3.Column2 = 0;

    aHM.Line3.Column3 = 1;

    return aHM;

}

::basegfx::B3DPoint Position3DToB3DPoint( const drawing::Position3D& rPosition )

{

    return ::basegfx::B3DPoint(

        rPosition.PositionX ,

        rPosition.PositionY ,

        rPosition.PositionZ );

}

drawing::Direction3D B3DVectorToDirection3D( const ::basegfx::B3DVector& rVector)

{

    return drawing::Direction3D(

          rVector.getX()

        , rVector.getY()

        , rVector.getZ()

        );

}

drawing::Position3D B3DPointToPosition3D( const ::basegfx::B3DPoint& rPoint)

{

        return drawing::Position3D(

          rPoint.getX()

        , rPoint.getY()

        , rPoint.getZ()

        );

}

::basegfx::B3DVector Direction3DToB3DVector( const drawing::Direction3D& rDirection)

{

    return ::basegfx::B3DVector(

          rDirection.DirectionX

        , rDirection.DirectionY

        , rDirection.DirectionZ

        );

}

void AddPointToPoly( drawing::PolyPolygonShape3D& rPoly, const drawing::Position3D& rPos, sal_Int32 nPolygonIndex )

{

    if(nPolygonIndex<0)

    {

        OSL_FAIL( "The polygon index needs to be > 0");

        nPolygonIndex=0;

    }

    //make sure that we have enough polygons

    if(nPolygonIndex >= rPoly.SequenceX.getLength() )

    {

        rPoly.SequenceX.realloc(nPolygonIndex+1);

        rPoly.SequenceY.realloc(nPolygonIndex+1);

        rPoly.SequenceZ.realloc(nPolygonIndex+1);

    }

    drawing::DoubleSequence* pOuterSequenceX = &rPoly.SequenceX.getArray()[nPolygonIndex];

    drawing::DoubleSequence* pOuterSequenceY = &rPoly.SequenceY.getArray()[nPolygonIndex];

    drawing::DoubleSequence* pOuterSequenceZ = &rPoly.SequenceZ.getArray()[nPolygonIndex];

    sal_Int32 nOldPointCount = pOuterSequenceX->getLength();

    pOuterSequenceX->realloc(nOldPointCount+1);

    pOuterSequenceY->realloc(nOldPointCount+1);

    pOuterSequenceZ->realloc(nOldPointCount+1);

    double* pInnerSequenceX = pOuterSequenceX->getArray();

    double* pInnerSequenceY = pOuterSequenceY->getArray();

    double* pInnerSequenceZ = pOuterSequenceZ->getArray();

    pInnerSequenceX[nOldPointCount] = rPos.PositionX;

    pInnerSequenceY[nOldPointCount] = rPos.PositionY;

    pInnerSequenceZ[nOldPointCount] = rPos.PositionZ;

}

void AddPointToPoly( std::vector<std::vector<css::drawing::Position3D>>& rPoly, const drawing::Position3D& rPos, sal_Int32 nPolygonIndex )

{

    if(nPolygonIndex<0)

    {

        OSL_FAIL( "The polygon index needs to be > 0");

        nPolygonIndex=0;

    }

    //make sure that we have enough polygons

    if(o3tl::make_unsigned(nPolygonIndex) >= rPoly.size() )

    {

        rPoly.resize(nPolygonIndex+1);

    }

    std::vector<css::drawing::Position3D>* pOuterSequence = &rPoly[nPolygonIndex];

    pOuterSequence->push_back(rPos);

}

drawing::Position3D getPointFromPoly( const drawing::PolyPolygonShape3D& rPolygon, sal_Int32 nPointIndex, sal_Int32 nPolyIndex )

{

    drawing::Position3D aRet(0.0,0.0,0.0);

    if( nPolyIndex>=0 && nPolyIndex<rPolygon.SequenceX.getLength())

    {

        if(nPointIndex<rPolygon.SequenceX[nPolyIndex].getLength())

        {

            aRet.PositionX = rPolygon.SequenceX[nPolyIndex][nPointIndex];

            aRet.PositionY = rPolygon.SequenceY[nPolyIndex][nPointIndex];

            aRet.PositionZ = rPolygon.SequenceZ[nPolyIndex][nPointIndex];

        }

        else

        {

            OSL_FAIL("polygon was accessed with a wrong index");

        }

    }

    else

    {

        OSL_FAIL("polygon was accessed with a wrong index");

    }

    return aRet;

}

drawing::Position3D getPointFromPoly( const std::vector<std::vector<css::drawing::Position3D>>& rPolygon, sal_Int32 nPointIndex, sal_Int32 nPolyIndex )

{

    drawing::Position3D aRet(0.0,0.0,0.0);

    if( nPolyIndex>=0 && o3tl::make_unsigned(nPolyIndex)<rPolygon.size())

    {

        if(nPointIndex<static_cast<sal_Int32>(rPolygon[nPolyIndex].size()))

        {

            aRet = rPolygon[nPolyIndex][nPointIndex];

        }

        else

        {

            OSL_FAIL("polygon was accessed with a wrong index");

        }

    }

    else

    {

        OSL_FAIL("polygon was accessed with a wrong index");

    }

    return aRet;

}

void addPolygon( std::vector<std::vector<css::drawing::Position3D>>& rRet, const std::vector<std::vector<css::drawing::Position3D>>& rAdd )

{

    sal_Int32 nAddOuterCount = rAdd.size();

    sal_Int32 nOuterCount = rRet.size() + nAddOuterCount;

    rRet.resize( nOuterCount );

    auto pSequence = rRet.data();

    sal_Int32 nIndex = 0;

    sal_Int32 nOuter = nOuterCount - nAddOuterCount;

    for( ; nOuter < nOuterCount; nOuter++ )

    {

        if( nIndex >= nAddOuterCount )

            break;

        pSequence[nOuter] = rAdd[nIndex];

        nIndex++;

    }

}

void appendPoly( std::vector<std::vector<css::drawing::Position3D>>& rRet, const std::vector<std::vector<css::drawing::Position3D>>& rAdd )

{

    std::size_t nOuterCount = std::max( rRet.size(), rAdd.size() );

    rRet.resize(nOuterCount);

    auto pSequence = rRet.data();

    for( std::size_t nOuter=0;nOuter<nOuterCount;nOuter++ )

    {

        sal_Int32 nOldPointCount = rRet[nOuter].size();

        sal_Int32 nAddPointCount = 0;

        if(nOuter<rAdd.size())

            nAddPointCount = rAdd[nOuter].size();

        if(!nAddPointCount)

            continue;

        sal_Int32 nNewPointCount = nOldPointCount + nAddPointCount;

        pSequence[nOuter].resize(nNewPointCount);

        auto pSequence_nOuter = pSequence[nOuter].data();

        sal_Int32 nPointTarget=nOldPointCount;

        sal_Int32 nPointSource=nAddPointCount;

        for( ; nPointSource-- ; nPointTarget++ )

        {

            pSequence_nOuter[nPointTarget] = rAdd[nOuter][nPointSource];

        }

    }

}

drawing::PolyPolygonShape3D BezierToPoly(

    const drawing::PolyPolygonBezierCoords& rBezier )

{

    const drawing::PointSequenceSequence& rPointSequence = rBezier.Coordinates;

    drawing::PolyPolygonShape3D aRet;

    aRet.SequenceX.realloc( rPointSequence.getLength() );

    auto pSequenceX = aRet.SequenceX.getArray();

    aRet.SequenceY.realloc( rPointSequence.getLength() );

    auto pSequenceY = aRet.SequenceY.getArray();

    aRet.SequenceZ.realloc( rPointSequence.getLength() );

    auto pSequenceZ = aRet.SequenceZ.getArray();

    sal_Int32 nRealOuter = 0;

    for(sal_Int32 nN = 0; nN < rPointSequence.getLength(); nN++)

    {

        sal_Int32 nInnerLength = rPointSequence[nN].getLength();

        pSequenceX[nRealOuter].realloc( nInnerLength );

        auto pSequenceX_nRealOuter = pSequenceX[nRealOuter].getArray();

        pSequenceY[nRealOuter].realloc( nInnerLength );

        auto pSequenceY_nRealOuter = pSequenceY[nRealOuter].getArray();

        pSequenceZ[nRealOuter].realloc( nInnerLength );

        auto pSequenceZ_nRealOuter = pSequenceZ[nRealOuter].getArray();

        bool bHasOuterFlags = nN < rBezier.Flags.getLength();

        sal_Int32 nRealInner = 0;

        for( sal_Int32 nM = 0; nM < nInnerLength; nM++)

        {

            bool bHasInnerFlags = bHasOuterFlags && (nM < rBezier.Flags[nN].getLength());

            if( !bHasInnerFlags || (rBezier.Flags[nN][nM] == drawing::PolygonFlags_NORMAL) )

            {

                pSequenceX_nRealOuter[nRealInner] = rPointSequence[nN][nM].X;

                pSequenceY_nRealOuter[nRealInner] = rPointSequence[nN][nM].Y;

                pSequenceZ_nRealOuter[nRealInner] = 0.0;

                nRealInner++;

            }

        }

        pSequenceX[nRealOuter].realloc( nRealInner );

        pSequenceY[nRealOuter].realloc( nRealInner );

        pSequenceZ[nRealOuter].realloc( nRealInner );

        if( nRealInner>0 )

            nRealOuter++;

    }

    aRet.SequenceX.realloc( nRealOuter );

    aRet.SequenceY.realloc( nRealOuter );

    aRet.SequenceZ.realloc( nRealOuter );

    return aRet;

}

drawing::PointSequenceSequence PolyToPointSequence(

                const drawing::PolyPolygonShape3D& rPolyPolygon )

{

    drawing::PointSequenceSequence aRet;

    aRet.realloc( rPolyPolygon.SequenceX.getLength() );

    auto pRet = aRet.getArray();

    for(sal_Int32 nN = 0; nN < rPolyPolygon.SequenceX.getLength(); nN++)

    {

        sal_Int32 nInnerLength = rPolyPolygon.SequenceX[nN].getLength();

        pRet[nN].realloc( nInnerLength );

        auto pRet_nN = pRet[nN].getArray();

        for( sal_Int32 nM = 0; nM < nInnerLength; nM++)

        {

            pRet_nN[nM].X = static_cast<sal_Int32>(rPolyPolygon.SequenceX[nN][nM]);

            pRet_nN[nM].Y = static_cast<sal_Int32>(rPolyPolygon.SequenceY[nN][nM]);

        }

    }

    return aRet;

}

drawing::PointSequenceSequence PolyToPointSequence(

                const std::vector<std::vector<css::drawing::Position3D>>& rPolyPolygon )

{

    drawing::PointSequenceSequence aRet;

    aRet.realloc( rPolyPolygon.size() );

    auto pRet = aRet.getArray();

    for(std::size_t nN = 0; nN < rPolyPolygon.size(); nN++)

    {

        sal_Int32 nInnerLength = rPolyPolygon[nN].size();

        pRet[nN].realloc( nInnerLength );

        auto pRet_nN = pRet[nN].getArray();

        for( sal_Int32 nM = 0; nM < nInnerLength; nM++)

        {

            pRet_nN[nM].X = static_cast<sal_Int32>(rPolyPolygon[nN][nM].PositionX);

            pRet_nN[nM].Y = static_cast<sal_Int32>(rPolyPolygon[nN][nM].PositionY);

        }

    }

    return aRet;

}

basegfx::B2DPolyPolygon PolyToB2DPolyPolygon(

                const std::vector<std::vector<css::drawing::Position3D>>& rPolyPolygon )

{

    basegfx::B2DPolyPolygon aRetval;

    for(auto const & nN: rPolyPolygon)

    {

        basegfx::B2DPolygon aNewPolygon;

        sal_Int32 nInnerLength = nN.size();

        if(nInnerLength)

        {

            aNewPolygon.reserve(nInnerLength);

            for( sal_Int32 nM = 0; nM < nInnerLength; nM++)

            {

                auto X = static_cast<sal_Int32>(nN[nM].PositionX);

                auto Y = static_cast<sal_Int32>(nN[nM].PositionY);

                aNewPolygon.append(basegfx::B2DPoint(X, Y));

            }

            // check for closed state flag

            basegfx::utils::checkClosed(aNewPolygon);

        }

        aRetval.append(std::move(aNewPolygon));

    }

    return aRetval;

}

void appendPointSequence( drawing::PointSequenceSequence& rTarget

                        , const drawing::PointSequenceSequence& rAdd )

{

    sal_Int32 nAddCount = rAdd.getLength();

    if(!nAddCount)

        return;

    sal_Int32 nOldCount = rTarget.getLength();

    rTarget.realloc(nOldCount+nAddCount);

    auto pTarget = rTarget.getArray();

    for(sal_Int32 nS=0; nS<nAddCount; nS++ )

        pTarget[nOldCount+nS]=rAdd[nS];

}

drawing::Position3D  operator+( const drawing::Position3D& rPos

                           , const drawing::Direction3D& rDirection)

{

    return drawing::Position3D(

          rPos.PositionX + rDirection.DirectionX

        , rPos.PositionY + rDirection.DirectionY

        , rPos.PositionZ + rDirection.DirectionZ

        );

}

drawing::Direction3D  operator-( const drawing::Position3D& rPos1

                           , const drawing::Position3D& rPos2)

{

    return drawing::Direction3D(

          rPos1.PositionX - rPos2.PositionX

        , rPos1.PositionY - rPos2.PositionY

        , rPos1.PositionZ - rPos2.PositionZ

        );

}

awt::Point Position3DToAWTPoint( const drawing::Position3D& rPos )

{

    awt::Point aRet;

    aRet.X = static_cast<sal_Int32>(rPos.PositionX);

    aRet.Y = static_cast<sal_Int32>(rPos.PositionY);

    return aRet;

}

awt::Point ToPoint( const awt::Rectangle& rRectangle )

{

    return awt::Point( rRectangle.X, rRectangle.Y );

}

awt::Size ToSize( const awt::Rectangle& rRectangle )

{

    return awt::Size( rRectangle.Width, rRectangle.Height );

}

awt::Size Direction3DToAWTSize( const drawing::Direction3D& rDirection )

{

    awt::Size aRet;

    aRet.Width = static_cast<sal_Int32>(rDirection.DirectionX);

    aRet.Height = static_cast<sal_Int32>(rDirection.DirectionY);

    return aRet;

}

drawing::Position3D SequenceToPosition3D( const uno::Sequence< double >& rSeq )

{

    OSL_ENSURE(rSeq.getLength()==3,"The sequence needs to have length 3 for conversion into vector");

    drawing::Position3D aRet;

    aRet.PositionX = rSeq.getLength()>0?rSeq[0]:0.0;

    aRet.PositionY = rSeq.getLength()>1?rSeq[1]:0.0;

    aRet.PositionZ = rSeq.getLength()>2?rSeq[2]:0.0;

    return aRet;

}

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

uno::Sequence< double > DataSequenceToDoubleSequence(

    const uno::Reference< data::XDataSequence >& xDataSequence )

{

    uno::Sequence< double > aResult;

    OSL_ASSERT( xDataSequence.is());

    if(!xDataSequence.is())

        return aResult;

    uno::Reference< data::XNumericalDataSequence > xNumericalDataSequence( xDataSequence, uno::UNO_QUERY );

    if( xNumericalDataSequence.is() )

    {

        aResult = xNumericalDataSequence->getNumericalData();

    }

    else

    {

        uno::Sequence< uno::Any > aValues = xDataSequence->getData();

        aResult.realloc(aValues.getLength());

        auto pResult = aResult.getArray();

        for(sal_Int32 nN=aValues.getLength();nN--;)

        {

            if( !(aValues[nN] >>= pResult[nN]) )

                pResult[nN] = std::numeric_limits<double>::quiet_NaN();

        }

    }

    return aResult;

}

uno::Sequence< OUString > DataSequenceToStringSequence(

    const uno::Reference< data::XDataSequence >& xDataSequence )

{

    uno::Sequence< OUString > aResult;

    if(!xDataSequence.is())

        return aResult;

    uno::Reference< data::XTextualDataSequence > xTextualDataSequence( xDataSequence, uno::UNO_QUERY );

    if( xTextualDataSequence.is() )

    {

        aResult = xTextualDataSequence->getTextualData();

    }

    else

    {

        uno::Sequence< uno::Any > aValues = xDataSequence->getData();

        aResult.realloc(aValues.getLength());

        auto pResult = aResult.getArray();

        for(sal_Int32 nN=aValues.getLength();nN--;)

            aValues[nN] >>= pResult[nN];

    }

    return aResult;

}

bool hasDoubleValue( const uno::Any& rAny )

{

    bool bRet = false;

    double fValue = 0.0;

    if( rAny >>= fValue )

        bRet = true;

    return bRet;

}

bool hasLongOrShortValue( const uno::Any& rAny )

{

    bool bRet = false;

    sal_Int32 n32 = 0;

    if( rAny >>= n32 )

        bRet = true;

    else

    {

        sal_Int16 n16 = 0;

        if( rAny >>= n16 )

            bRet = true;

    }

    return bRet;

}

sal_Int16 getShortForLongAlso( const uno::Any& rAny )

{

    sal_Int16 nRet = 0;

    if( !(rAny >>= nRet) )

    {

        sal_Int32 n32 = 0;

        if( rAny >>= n32 )

            nRet = static_cast<sal_Int16>(n32);

    }

    return nRet;

}

bool replaceParamterInString( OUString & rInOutResourceString,

                            std::u16string_view rParamToReplace,

                            std::u16string_view rReplaceWith )

{

    sal_Int32 nPos = rInOutResourceString.indexOf( rParamToReplace );

    if( nPos == -1 )

        return false;

    rInOutResourceString = rInOutResourceString.replaceAt( nPos

                        , rParamToReplace.size(), rReplaceWith );

    return true;

}

} //namespace chart

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */