/* -*- 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 <com/sun/star/container/XIndexReplace.hpp>
#include "impastpl.hxx"
#include <xmloff/xmlaustp.hxx>
#include <xmloff/families.hxx>
#include <xmloff/xmlnamespace.hxx>
#include <xmloff/xmltoken.hxx>
#include <xmloff/xmlexp.hxx>
#include <xmloff/xmlprhdl.hxx>
#include <xmloff/xmlprmap.hxx>
#include <xmloff/XMLTextListAutoStylePool.hxx>

#include <PageMasterStyleMap.hxx>
#include <osl/diagnose.h>


using namespace ::com::sun::star;
using namespace ::xmloff::token;


namespace
{
    void lcl_exportDataStyle( SvXMLExport& _rExport, const rtl::Reference< XMLPropertySetMapper >& _rxMapper,
        const XMLPropertyState& _rProperty )
    {
        assert(_rxMapper.is());
        // obtain the data style name
        OUString sDataStyleName;
        _rProperty.maValue >>= sDataStyleName;
        assert(!sDataStyleName.isEmpty() && "xmloff::lcl_exportDataStyle: invalid property value for the data style name!");

        // add the attribute
        _rExport.AddAttribute(
            _rxMapper->GetEntryNameSpace( _rProperty.mnIndex ),
            _rxMapper->GetEntryXMLName( _rProperty.mnIndex ),
            sDataStyleName );
    }
}

void SvXMLAutoStylePoolP::exportStyleAttributes(
        comphelper::AttributeList&,
        XmlStyleFamily nFamily,
        const std::vector< XMLPropertyState >& rProperties,
        const SvXMLExportPropertyMapper& rPropExp,
        const SvXMLUnitConverter&,
        const SvXMLNamespaceMap&
        ) const
{
    if ( XmlStyleFamily::CONTROL_ID == nFamily )
    {   // it's a control-related style
        const rtl::Reference< XMLPropertySetMapper >& aPropertyMapper = rPropExp.getPropertySetMapper();

        for (const auto& rProp : rProperties)
        {
            if  (   ( rProp.mnIndex > -1 )
                &&  ( CTF_FORMS_DATA_STYLE == aPropertyMapper->GetEntryContextId( rProp.mnIndex ) )
                )
            {   // it's the data-style for a grid column
                lcl_exportDataStyle( GetExport(), aPropertyMapper, rProp );
            }
        }
    }

    if( (XmlStyleFamily::SD_GRAPHICS_ID == nFamily) || (XmlStyleFamily::SD_PRESENTATION_ID == nFamily) )
    {   // it's a graphics style
        const rtl::Reference< XMLPropertySetMapper >& aPropertyMapper = rPropExp.getPropertySetMapper();
        assert(aPropertyMapper.is());

        bool bFoundControlShapeDataStyle = false;
        bool bFoundNumberingRulesName = false;

        for (const auto& rProp : rProperties)
        {
            if (rProp.mnIndex > -1)
            {   // it's a valid property
                switch( aPropertyMapper->GetEntryContextId(rProp.mnIndex) )
                {
                case CTF_SD_CONTROL_SHAPE_DATA_STYLE:
                    {   // it's the control shape data style property

                        if (bFoundControlShapeDataStyle)
                        {
                            OSL_FAIL("SvXMLAutoStylePoolP::exportStyleAttributes: found two properties with the ControlShapeDataStyle context id!");
                            // already added the attribute for the first occurrence
                            break;
                        }

                        lcl_exportDataStyle( GetExport(), aPropertyMapper, rProp );

                        // check if there is another property with the special context id we're handling here
                        bFoundControlShapeDataStyle = true;
                        break;
                    }
                case CTF_SD_NUMBERINGRULES_NAME:
                    {
                        if (bFoundNumberingRulesName)
                        {
                            OSL_FAIL("SvXMLAutoStylePoolP::exportStyleAttributes: found two properties with the numbering rules name context id!");
                            // already added the attribute for the first occurrence
                            break;
                        }

                        uno::Reference< container::XIndexReplace > xNumRule;
                        rProp.maValue >>= xNumRule;
                        if( xNumRule.is() && (xNumRule->getCount() > 0 ) )
                        {
                            const OUString sName(const_cast<XMLTextListAutoStylePool*>(&GetExport().GetTextParagraphExport()->GetListAutoStylePool())->Add( xNumRule ));

                            GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_LIST_STYLE_NAME, GetExport().EncodeStyleName( sName ) );
                        }

                        bFoundNumberingRulesName = true;
                        break;
                    }
                }
            }
        }
    }

    if( nFamily != XmlStyleFamily::PAGE_MASTER )
        return;

    for( const auto& rProp : rProperties )
    {
        if (rProp.mnIndex > -1)
        {
            const rtl::Reference< XMLPropertySetMapper >& aPropMapper = rPropExp.getPropertySetMapper();
            sal_Int32 nIndex = rProp.mnIndex;
            sal_Int16 nContextID = aPropMapper->GetEntryContextId( nIndex );
            switch( nContextID )
            {
                case CTF_PM_PAGEUSAGE:
                {
                    OUString sValue;
                    const XMLPropertyHandler* pPropHdl = aPropMapper->GetPropertyHandler( nIndex );
                    if( pPropHdl &&
                        pPropHdl->exportXML( sValue, rProp.maValue,
                                             GetExport().GetMM100UnitConverter() ) &&
                        ( ! IsXMLToken( sValue, XML_ALL ) ) )
                    {
                        GetExport().AddAttribute( aPropMapper->GetEntryNameSpace( nIndex ), aPropMapper->GetEntryXMLName( nIndex ), sValue );
                    }
                }
                break;
            }
        }
    }
}

void SvXMLAutoStylePoolP::exportStyleContent(
        const css::uno::Reference< css::xml::sax::XDocumentHandler > &,
        XmlStyleFamily nFamily,
        const std::vector< XMLPropertyState >& rProperties,
        const SvXMLExportPropertyMapper& rPropExp,
        const SvXMLUnitConverter&,
        const SvXMLNamespaceMap&
        ) const
{
    if( nFamily != XmlStyleFamily::PAGE_MASTER )
        return;

    sal_Int32       nHeaderStartIndex(-1);
    sal_Int32       nHeaderEndIndex(-1);
    sal_Int32       nFooterStartIndex(-1);
    sal_Int32       nFooterEndIndex(-1);
    bool        bHeaderStartIndex(false);
    bool        bHeaderEndIndex(false);
    bool        bFooterStartIndex(false);
    bool        bFooterEndIndex(false);

    const rtl::Reference< XMLPropertySetMapper >& aPropMapper = rPropExp.getPropertySetMapper();

    sal_Int32 nIndex(0);
    while(nIndex < aPropMapper->GetEntryCount())
    {
        switch( aPropMapper->GetEntryContextId( nIndex ) & CTF_PM_FLAGMASK )
        {
            case CTF_PM_HEADERFLAG:
            {
                if (!bHeaderStartIndex)
                {
                    nHeaderStartIndex = nIndex;
                    bHeaderStartIndex = true;
                }
                if (bFooterStartIndex && !bFooterEndIndex)
                {
                    nFooterEndIndex = nIndex;
                    bFooterEndIndex = true;
                }
            }
            break;
            case CTF_PM_FOOTERFLAG:
            {
                if (!bFooterStartIndex)
                {
                    nFooterStartIndex = nIndex;
                    bFooterStartIndex = true;
                }
                if (bHeaderStartIndex && !bHeaderEndIndex)
                {
                    nHeaderEndIndex = nIndex;
                    bHeaderEndIndex = true;
                }
            }
            break;
        }
        nIndex++;
    }
    if (!bHeaderEndIndex)
        nHeaderEndIndex = nIndex;
    if (!bFooterEndIndex)
        nFooterEndIndex = nIndex;

    // export header style element
    {
        SvXMLElementExport aElem(
            GetExport(), XML_NAMESPACE_STYLE, XML_HEADER_STYLE,
            true, true );

        rPropExp.exportXML(
            GetExport(), rProperties,
            nHeaderStartIndex, nHeaderEndIndex, SvXmlExportFlags::IGN_WS);
    }

    // export footer style
    {
        SvXMLElementExport aElem(
            GetExport(), XML_NAMESPACE_STYLE, XML_FOOTER_STYLE,
            true, true );

        rPropExp.exportXML(
            GetExport(), rProperties,
            nFooterStartIndex, nFooterEndIndex, SvXmlExportFlags::IGN_WS);
    }

}

SvXMLAutoStylePoolP::SvXMLAutoStylePoolP( SvXMLExport& rExport )
    : m_pImpl( new SvXMLAutoStylePoolP_Impl( rExport ) )
{
}

SvXMLAutoStylePoolP::~SvXMLAutoStylePoolP()
{
}

SvXMLExport& SvXMLAutoStylePoolP::GetExport() const
{
    return m_pImpl->GetExport();
}

// TODO: remove this
void SvXMLAutoStylePoolP::AddFamily(
        XmlStyleFamily nFamily,
        const OUString& rStrName,
        SvXMLExportPropertyMapper* pMapper,
        const OUString& aStrPrefix )
{
    rtl::Reference <SvXMLExportPropertyMapper> xTmp = pMapper;
    AddFamily( nFamily, rStrName, xTmp, aStrPrefix );
}

void SvXMLAutoStylePoolP::AddFamily(
        XmlStyleFamily nFamily,
        const OUString& rStrName,
        const rtl::Reference < SvXMLExportPropertyMapper > & rMapper,
        const OUString& rStrPrefix,
        bool bAsFamily )
{
    m_pImpl->AddFamily( nFamily, rStrName, rMapper, rStrPrefix, bAsFamily );
}

void  SvXMLAutoStylePoolP::SetFamilyPropSetMapper(
        XmlStyleFamily nFamily,
        const rtl::Reference < SvXMLExportPropertyMapper > & rMapper )
{
    m_pImpl->SetFamilyPropSetMapper( nFamily, rMapper );
}

void SvXMLAutoStylePoolP::RegisterName( XmlStyleFamily nFamily,
                                         const OUString& rName )
{
    m_pImpl->RegisterName( nFamily, rName );
}

void SvXMLAutoStylePoolP::RegisterDefinedName( XmlStyleFamily nFamily,
                                         const OUString& rName )
{
    m_pImpl->RegisterDefinedName( nFamily, rName );
}

void SvXMLAutoStylePoolP::GetRegisteredNames(
    uno::Sequence<sal_Int32>& rFamilies,
    uno::Sequence<OUString>& rNames )
{
    m_pImpl->GetRegisteredNames( rFamilies, rNames );
}

void SvXMLAutoStylePoolP::RegisterNames(
    uno::Sequence<sal_Int32> const & aFamilies,
    uno::Sequence<OUString> const & aNames )
{
    assert(aFamilies.getLength() == aNames.getLength());

    // iterate over sequence(s) and call RegisterName(..) for each pair
    const sal_Int32* pFamilies = aFamilies.getConstArray();
    const OUString* pNames = aNames.getConstArray();
    sal_Int32 nCount = std::min( aFamilies.getLength(), aNames.getLength() );
    for( sal_Int32 n = 0; n < nCount; n++ )
        RegisterName( static_cast<XmlStyleFamily>(pFamilies[n]), pNames[n] );
}

OUString SvXMLAutoStylePoolP::Add( XmlStyleFamily nFamily,
                                   std::vector< XMLPropertyState >&& rProperties )
{
    OUString sName;
    m_pImpl->Add(sName, nFamily, u""_ustr, std::move(rProperties) );
    return sName;
}

OUString SvXMLAutoStylePoolP::Add( XmlStyleFamily nFamily,
                                  const OUString& rParent,
                                  std::vector< XMLPropertyState >&& rProperties, bool bDontSeek )
{
    OUString sName;
    m_pImpl->Add(sName, nFamily, rParent, std::move(rProperties), bDontSeek);
    return sName;
}

bool SvXMLAutoStylePoolP::Add(OUString& rName, XmlStyleFamily nFamily, const OUString& rParent, ::std::vector< XMLPropertyState >&& rProperties )
{
    return m_pImpl->Add(rName, nFamily, rParent, std::move(rProperties));
}

bool SvXMLAutoStylePoolP::AddNamed( const OUString& rName, XmlStyleFamily nFamily, const OUString& rParent,
                                    std::vector< XMLPropertyState > rProperties )

{
    return m_pImpl->AddNamed(rName, nFamily, rParent, std::move(rProperties));
}

OUString SvXMLAutoStylePoolP::Find( XmlStyleFamily nFamily,
                                   const OUString& rParent,
                                   const std::vector< XMLPropertyState >& rProperties ) const
{
    return m_pImpl->Find( nFamily, rParent, rProperties );
}

void SvXMLAutoStylePoolP::exportXML( XmlStyleFamily nFamily ) const
{
    m_pImpl->exportXML( nFamily, this );
}

void SvXMLAutoStylePoolP::ClearEntries()
{
    m_pImpl->ClearEntries();
}

std::vector<xmloff::AutoStyleEntry> SvXMLAutoStylePoolP::GetAutoStyleEntries() const
{
    return m_pImpl->GetAutoStyleEntries();
}

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