/* -*- 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 <TitleHelper.hxx>

#include <Title.hxx>

#include <ChartModel.hxx>

#include <Axis.hxx>

#include <AxisHelper.hxx>

#include <Diagram.hxx>

#include <ReferenceSizeProvider.hxx>

#include <com/sun/star/chart2/FormattedString.hpp>

#include <rtl/ustrbuf.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <sal/log.hxx>

namespace chart

{

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

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

using ::com::sun::star::uno::Reference;

namespace {

uno::Reference< XTitled > lcl_getTitleParentFromDiagram(

      TitleHelper::eTitleType nTitleIndex

    , const rtl::Reference< Diagram >& xDiagram )

{

    uno::Reference< XTitled > xResult;

    if( nTitleIndex == TitleHelper::TITLE_AT_STANDARD_X_AXIS_POSITION ||

        nTitleIndex == TitleHelper::TITLE_AT_STANDARD_Y_AXIS_POSITION )

    {

        bool bDummy = false;

        bool bIsVertical = xDiagram && xDiagram->getVertical( bDummy, bDummy );

        if( nTitleIndex == TitleHelper::TITLE_AT_STANDARD_Y_AXIS_POSITION )

            nTitleIndex = bIsVertical ? TitleHelper::X_AXIS_TITLE : TitleHelper::Y_AXIS_TITLE;

        else

            nTitleIndex = bIsVertical ? TitleHelper::Y_AXIS_TITLE : TitleHelper::X_AXIS_TITLE;

    }

    switch( nTitleIndex )

    {

        case TitleHelper::SUB_TITLE:

            if( xDiagram.is())

                xResult = xDiagram;

            break;

        case TitleHelper::X_AXIS_TITLE:

            if( xDiagram.is())

                xResult = AxisHelper::getAxis( 0, true, xDiagram );

            break;

        case TitleHelper::Y_AXIS_TITLE:

            if( xDiagram.is())

                xResult = AxisHelper::getAxis( 1, true, xDiagram );

            break;

        case TitleHelper::Z_AXIS_TITLE:

            if( xDiagram.is())

                xResult = AxisHelper::getAxis( 2, true, xDiagram );

            break;

        case TitleHelper::SECONDARY_X_AXIS_TITLE:

            if( xDiagram.is())

                xResult = AxisHelper::getAxis( 0, false, xDiagram );

            break;

        case TitleHelper::SECONDARY_Y_AXIS_TITLE:

            if( xDiagram.is())

                xResult = AxisHelper::getAxis( 1, false, xDiagram );

            break;

        case TitleHelper::MAIN_TITLE:

        default:

            OSL_FAIL( "Unsupported Title-Type requested" );

            break;

    }

    return xResult;

}

uno::Reference< XTitled > lcl_getTitleParent( TitleHelper::eTitleType nTitleIndex

                                              , const rtl::Reference< Diagram >& xDiagram )

{

    uno::Reference< XTitled > xResult;

    switch( nTitleIndex )

    {

        case TitleHelper::MAIN_TITLE:

            SAL_WARN("chart2", "should not be reached");

            break;

        case TitleHelper::SUB_TITLE:

        case TitleHelper::X_AXIS_TITLE:

        case TitleHelper::Y_AXIS_TITLE:

        case TitleHelper::Z_AXIS_TITLE:

        case TitleHelper::TITLE_AT_STANDARD_X_AXIS_POSITION:

        case TitleHelper::TITLE_AT_STANDARD_Y_AXIS_POSITION:

        case TitleHelper::SECONDARY_X_AXIS_TITLE:

        case TitleHelper::SECONDARY_Y_AXIS_TITLE:

            xResult.set( lcl_getTitleParentFromDiagram( nTitleIndex, xDiagram ));

            break;

        default:

            OSL_FAIL( "Unsupported Title-Type requested" );

            break;

    }

    return xResult;

}

uno::Reference< XTitled > lcl_getTitleParent( TitleHelper::eTitleType nTitleIndex

                                              , const rtl::Reference<::chart::ChartModel>& xModel )

{

    if(nTitleIndex == TitleHelper::MAIN_TITLE)

    {

        return xModel;

    }

    rtl::Reference< Diagram > xDiagram;

    if( xModel.is())

        xDiagram = xModel->getFirstChartDiagram();

    return lcl_getTitleParent( nTitleIndex, xDiagram );

}

}

rtl::Reference< Title > TitleHelper::getTitle( TitleHelper::eTitleType nTitleIndex

                            , ChartModel& rModel )

{

    if(nTitleIndex == TitleHelper::MAIN_TITLE)

        return rModel.getTitleObject2();

    rtl::Reference< Diagram > xDiagram = rModel.getFirstChartDiagram();

    uno::Reference< XTitled > xTitled( lcl_getTitleParent( nTitleIndex, xDiagram ) );

    if( !xTitled )

        return nullptr;

    uno::Reference<XTitle> xTitle = xTitled->getTitleObject();

    auto pTitle = dynamic_cast<Title*>(xTitle.get());

    assert(!xTitle || pTitle);

    return pTitle;

}

rtl::Reference< Title > TitleHelper::getTitle( TitleHelper::eTitleType nTitleIndex

                            , const rtl::Reference<ChartModel>& xModel )

{

    uno::Reference< XTitled > xTitled;

    if(nTitleIndex == TitleHelper::MAIN_TITLE)

    {

        xTitled = xModel;

    }

    else

    {

        rtl::Reference< Diagram > xDiagram;

        if( xModel.is())

            xDiagram = xModel->getFirstChartDiagram();

        xTitled = lcl_getTitleParent( nTitleIndex, xDiagram );

    }

    if( !xTitled )

        return nullptr;

    uno::Reference<XTitle> xTitle = xTitled->getTitleObject();

    Title* pTitle = dynamic_cast<Title*>(xTitle.get());

    assert(!xTitle || pTitle);

    return pTitle;

}

rtl::Reference< Title > TitleHelper::createOrShowTitle(

      TitleHelper::eTitleType eTitleType

    , const OUString& rTitleText

    , const rtl::Reference<ChartModel>& xModel

    , const uno::Reference< uno::XComponentContext > & xContext )

{

    rtl::Reference< Title > xTitled( TitleHelper::getTitle( eTitleType, xModel ) );

    if( xTitled.is())

    {

        xTitled->setPropertyValue(u"Visible"_ustr,css::uno::Any(true));

        return xTitled;

    }

    else

    {

        return createTitle(eTitleType, rTitleText, xModel, xContext, nullptr/*pRefSizeProvider*/);

    }

}

rtl::Reference< Title > TitleHelper::createTitle(

      TitleHelper::eTitleType eTitleType

    , const OUString& rTitleText

    , const rtl::Reference<ChartModel>& xModel

    , const uno::Reference< uno::XComponentContext > & xContext

    , ReferenceSizeProvider * pRefSizeProvider )

{

    rtl::Reference< ::chart::Title > xTitle;

    uno::Reference< XTitled > xTitled( lcl_getTitleParent( eTitleType, xModel ) );

    if( !xTitled.is() )

    {

        rtl::Reference< Diagram > xDiagram( xModel->getFirstChartDiagram() );

        rtl::Reference< Axis > xAxis;

        switch( eTitleType )

        {

            case TitleHelper::SECONDARY_X_AXIS_TITLE:

                xAxis = AxisHelper::createAxis( 0, false, xDiagram, xContext );

                break;

            case TitleHelper::SECONDARY_Y_AXIS_TITLE:

                xAxis = AxisHelper::createAxis( 1, false, xDiagram, xContext );

               break;

            default:

               break;

        }

        if( xAxis.is() )

        {

            xAxis->setPropertyValue( u"Show"_ustr, uno::Any( false ) );

            xTitled = lcl_getTitleParent( eTitleType, xModel );

        }

    }

    if(xTitled.is())

    {

        rtl::Reference< Diagram > xDiagram( xModel->getFirstChartDiagram() );

        xTitle = new ::chart::Title();

        // default char height (main: 13.0 == default)

        float fDefaultCharHeightSub = 11.0;

        float fDefaultCharHeightAxis = 9.0;

        switch( eTitleType )

        {

            case TitleHelper::SUB_TITLE:

                TitleHelper::setCompleteString(

                    rTitleText, xTitle, xContext, & fDefaultCharHeightSub );

                break;

            case TitleHelper::X_AXIS_TITLE:

            case TitleHelper::Y_AXIS_TITLE:

            case TitleHelper::Z_AXIS_TITLE:

            case TitleHelper::TITLE_AT_STANDARD_X_AXIS_POSITION:

            case TitleHelper::TITLE_AT_STANDARD_Y_AXIS_POSITION:

            case TitleHelper::SECONDARY_X_AXIS_TITLE:

            case TitleHelper::SECONDARY_Y_AXIS_TITLE:

                TitleHelper::setCompleteString(

                    rTitleText, xTitle, xContext, & fDefaultCharHeightAxis );

                break;

            default:

                TitleHelper::setCompleteString( rTitleText, xTitle, xContext );

                break;

        }

        // set/clear autoscale

        if( pRefSizeProvider )

            pRefSizeProvider->setValuesAtTitle( xTitle );

        xTitled->setTitleObject( xTitle );

        //default rotation 90 degree for y axis title in normal coordinatesystems or for x axis title for swapped coordinatesystems

        if( eTitleType == TitleHelper::X_AXIS_TITLE ||

            eTitleType == TitleHelper::Y_AXIS_TITLE ||

            eTitleType == TitleHelper::SECONDARY_X_AXIS_TITLE ||

            eTitleType == TitleHelper::SECONDARY_Y_AXIS_TITLE )

        {

            try

            {

                bool bDummy = false;

                bool bIsVertical = xDiagram->getVertical( bDummy, bDummy );

                if( (!bIsVertical && eTitleType == TitleHelper::Y_AXIS_TITLE)

                    || (bIsVertical && eTitleType == TitleHelper::X_AXIS_TITLE)

                    || (!bIsVertical && eTitleType == TitleHelper::SECONDARY_Y_AXIS_TITLE)

                    || (bIsVertical && eTitleType == TitleHelper::SECONDARY_X_AXIS_TITLE) )

                {

                    xTitle->setPropertyValue( u"TextRotation"_ustr, uno::Any( 90.0 ));

                }

            }

            catch( const uno::Exception & )

            {

                DBG_UNHANDLED_EXCEPTION("chart2");

            }

        }

    }

    return xTitle;

}

OUString TitleHelper::getCompleteString( const rtl::Reference< Title >& xTitle )

{

    if(!xTitle.is())

        return OUString();

    OUStringBuffer aRet;

    const uno::Sequence< uno::Reference< XFormattedString > > aStringList = xTitle->getText();

    for( uno::Reference< XFormattedString > const & formattedStr : aStringList )

        aRet.append( formattedStr->getString() );

    return aRet.makeStringAndClear();

}

OUString TitleHelper::getUnstackedStr(const OUString& rNewText)

{

    //#i99841# remove linebreaks that were added for vertical stacking

    OUStringBuffer aUnstackedStr;

    OUStringBuffer aSource(rNewText);

    bool bBreakIgnored = false;

    sal_Int32 nLen = rNewText.getLength();

    for (sal_Int32 nPos = 0; nPos < nLen; ++nPos)

    {

        sal_Unicode aChar = aSource[nPos];

        if (aChar != '\n')

        {

            aUnstackedStr.append(aChar);

            bBreakIgnored = false;

        }

        else if (aChar == '\n' && bBreakIgnored)

            aUnstackedStr.append(aChar);

        else

            bBreakIgnored = true;

    }

    return aUnstackedStr.makeStringAndClear();

}

void TitleHelper::setFormattedString( const rtl::Reference< Title >& xTitle,

    const css::uno::Sequence< css::uno::Reference< css::chart2::XFormattedString > >& aNewFormattedTitle )

{

    if (!xTitle.is() || !aNewFormattedTitle.hasElements())

        return;

    bool bStacked = false;

    xTitle->getPropertyValue(u"StackCharacters"_ustr) >>= bStacked;

    if (bStacked)

    {

        for (uno::Reference< chart2::XFormattedString >const& formattedStr : aNewFormattedTitle)

        {

            formattedStr->setString(TitleHelper::getUnstackedStr(formattedStr->getString()));

        }

    }

    xTitle->setText(aNewFormattedTitle);

}

void TitleHelper::setCompleteString( const OUString& rNewText

                    , const rtl::Reference< Title >& xTitle

                    , const uno::Reference< uno::XComponentContext > & xContext

                    , const float * pDefaultCharHeight /* = 0 */

                    , bool bDialogTitle /*= false*/ )

{

    if (!xTitle.is())

        return;

    bool bStacked = false;

    if( xTitle.is() )

        xTitle->getPropertyValue( u"StackCharacters"_ustr ) >>= bStacked;

    OUString aNewText = rNewText;

    if( bStacked )

    {

        aNewText = getUnstackedStr(rNewText);

    }

    uno::Sequence< uno::Reference< XFormattedString > > aNewStringList;

    uno::Sequence< uno::Reference< XFormattedString > > aOldStringList = xTitle->getText();

    if( aOldStringList.hasElements())

    {

        const OUString aFullString = getCompleteString(xTitle);

        if (bDialogTitle && aNewText.equals(getUnstackedStr(aFullString)))

        {

            // If the new title setted from a dialog window to a new string

            // the first old text portion will be maintained if it's a new string,

            // otherwise we use the original one.

            aNewStringList = std::move(aOldStringList);

        }

        else

        {

            // If the new title setted from a dialog to a new string the first

            // old text portion will be maintained if there was any. Also in case of ODF

            // import which still not support non-uniform formatted titles

            aNewStringList = { aOldStringList[0] };

            aNewStringList[0]->setString(aNewText);

        }

    }

    else

    {

        uno::Reference< chart2::XFormattedString2 > xFormattedString =

            chart2::FormattedString::create( xContext );

        xFormattedString->setString( aNewText );

        aNewStringList = { xFormattedString };

        if( pDefaultCharHeight != nullptr )

        {

            try

            {

                uno::Any aFontSize( *pDefaultCharHeight );

                xFormattedString->setPropertyValue( u"CharHeight"_ustr, aFontSize );

                xFormattedString->setPropertyValue( u"CharHeightAsian"_ustr, aFontSize );

                xFormattedString->setPropertyValue( u"CharHeightComplex"_ustr, aFontSize );

            }

            catch( const uno::Exception & )

            {

                DBG_UNHANDLED_EXCEPTION("chart2");

            }

        }

    }

    xTitle->setText( aNewStringList );

}

void TitleHelper::removeTitle( TitleHelper::eTitleType nTitleIndex

                    , const rtl::Reference<ChartModel>& xModel )

{

    uno::Reference< XTitled > xTitled( lcl_getTitleParent( nTitleIndex, xModel ) );

    if( xTitled.is())

    {

        xTitled->setTitleObject(nullptr);

    }

}

bool TitleHelper::getTitleType( eTitleType& rType

                    , const rtl::Reference< Title >& xTitle

                    , const rtl::Reference<ChartModel>& xModel )

{

    if( !xTitle.is() || !xModel.is() )

        return false;

    rtl::Reference< Title > xCurrentTitle;

    for( sal_Int32 nTitleType = TITLE_BEGIN; nTitleType < NORMAL_TITLE_END; nTitleType++ )

    {

        xCurrentTitle = TitleHelper::getTitle( static_cast<eTitleType>(nTitleType), xModel );

        if( xCurrentTitle == xTitle )

        {

            rType = static_cast<eTitleType>(nTitleType);

            return true;

        }

    }

    return false;

}

void TitleHelper::hideTitle( TitleHelper::eTitleType nTitleIndex

        , const rtl::Reference<ChartModel>& xModel)

{

    rtl::Reference< Title > xTitled( TitleHelper::getTitle( nTitleIndex, xModel ) );

    if( xTitled.is())

        xTitled->setPropertyValue(u"Visible"_ustr,css::uno::Any(false));

}

} //namespace chart

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