/* -*- 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/table/CellAddress.hpp>
#include <com/sun/star/table/CellRangeAddress.hpp>
#include <cppuhelper/supportsservice.hxx>

#include <svl/itemprop.hxx>
#include <vcl/svapp.hxx>

#include <docsh.hxx>
#include <unonames.hxx>
#include <miscuno.hxx>
#include <convuno.hxx>
#include <addruno.hxx>

using namespace com::sun::star;

ScAddressConversionObj::ScAddressConversionObj(ScDocShell* pDocSh, bool _bIsRange) :
    pDocShell( pDocSh ),
    nRefSheet( 0 ),
    bIsRange( _bIsRange )
{
    pDocShell->GetDocument().AddUnoObject(*this);
}

ScAddressConversionObj::~ScAddressConversionObj()
{
    SolarMutexGuard g;

    if (pDocShell)
        pDocShell->GetDocument().RemoveUnoObject(*this);
}

void ScAddressConversionObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
{
    if ( rHint.GetId() == SfxHintId::Dying )
    {
        pDocShell = nullptr;       // invalid
    }
}

bool ScAddressConversionObj::ParseUIString( const OUString& rUIString, ::formula::FormulaGrammar::AddressConvention eConv )
{
    if (!pDocShell)
        return false;

    ScDocument& rDoc = pDocShell->GetDocument();
    bool bSuccess = false;
    if ( bIsRange )
    {
        ScRefFlags nResult = aRange.ParseAny( rUIString, rDoc, eConv );
        if ( nResult & ScRefFlags::VALID )
        {
            if ( ( nResult & ScRefFlags::TAB_3D ) == ScRefFlags::ZERO )
                aRange.aStart.SetTab( static_cast<SCTAB>(nRefSheet) );
            if ( ( nResult & ScRefFlags::TAB2_3D ) == ScRefFlags::ZERO )
                aRange.aEnd.SetTab( aRange.aStart.Tab() );
            // different sheets are not supported in CellRangeAddress
            if ( aRange.aStart.Tab() == aRange.aEnd.Tab() )
                bSuccess = true;
        }
    }
    else
    {
        ScRefFlags nResult = aRange.aStart.Parse( rUIString, rDoc, eConv );
        if ( nResult & ScRefFlags::VALID )
        {
            if ( ( nResult & ScRefFlags::TAB_3D ) == ScRefFlags::ZERO )
                aRange.aStart.SetTab( static_cast<SCTAB>(nRefSheet) );
            bSuccess = true;
        }
    }
    return bSuccess;
}

// XPropertySet

uno::Reference<beans::XPropertySetInfo> SAL_CALL ScAddressConversionObj::getPropertySetInfo()
{
    SolarMutexGuard aGuard;

    if ( bIsRange )
    {
        static const SfxItemPropertyMapEntry aPropertyMap[] =
        {
            { SC_UNONAME_ADDRESS,  0,  cppu::UnoType<table::CellRangeAddress>::get(), 0, 0 },
            { SC_UNONAME_PERSREPR, 0,  cppu::UnoType<OUString>::get(),    0, 0 },
            { SC_UNONAME_XLA1REPR, 0,  cppu::UnoType<OUString>::get(),    0, 0 },
            { SC_UNONAME_REFSHEET, 0,  cppu::UnoType<sal_Int32>::get(),        0, 0 },
            { SC_UNONAME_UIREPR,   0,  cppu::UnoType<OUString>::get(),    0, 0 },
            { SC_UNONAME_XLA1REPR, 0,  cppu::UnoType<OUString>::get(),    0, 0 },
        };
        static uno::Reference<beans::XPropertySetInfo> aRef(new SfxItemPropertySetInfo( aPropertyMap ));
        return aRef;
    }
    else
    {
        static const SfxItemPropertyMapEntry aPropertyMap[] =
        {
            { SC_UNONAME_ADDRESS,  0,  cppu::UnoType<table::CellAddress>::get(), 0, 0 },
            { SC_UNONAME_PERSREPR, 0,  cppu::UnoType<OUString>::get(),    0, 0 },
            { SC_UNONAME_XLA1REPR, 0,  cppu::UnoType<OUString>::get(),    0, 0 },
            { SC_UNONAME_REFSHEET, 0,  cppu::UnoType<sal_Int32>::get(),        0, 0 },
            { SC_UNONAME_UIREPR,   0,  cppu::UnoType<OUString>::get(),    0, 0 },
            { SC_UNONAME_XLA1REPR, 0,  cppu::UnoType<OUString>::get(),    0, 0 },
        };
        static uno::Reference<beans::XPropertySetInfo> aRef(new SfxItemPropertySetInfo( aPropertyMap ));
        return aRef;
    }
}

void SAL_CALL ScAddressConversionObj::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
{
    if ( !pDocShell )
        throw uno::RuntimeException();

    bool bSuccess = false;
    if ( aPropertyName == SC_UNONAME_ADDRESS )
    {
        //  read the cell/range address from API struct
        if ( bIsRange )
        {
            table::CellRangeAddress aRangeAddress;
            if ( aValue >>= aRangeAddress )
            {
                ScUnoConversion::FillScRange( aRange, aRangeAddress );
                bSuccess = true;
            }
        }
        else
        {
            table::CellAddress aCellAddress;
            if ( aValue >>= aCellAddress )
            {
                ScUnoConversion::FillScAddress( aRange.aStart, aCellAddress );
                bSuccess = true;
            }
        }
    }
    else if ( aPropertyName == SC_UNONAME_REFSHEET )
    {
        //  set the reference sheet
        sal_Int32 nIntVal = 0;
        if ( aValue >>= nIntVal )
        {
            nRefSheet = nIntVal;
            bSuccess = true;
        }
    }
    else if ( aPropertyName == SC_UNONAME_UIREPR )
    {
        //  parse the UI representation string
        OUString sRepresentation;
        if (aValue >>= sRepresentation)
        {
            bSuccess = ParseUIString( sRepresentation );
        }
    }
    else if ( aPropertyName == SC_UNONAME_PERSREPR || aPropertyName == SC_UNONAME_XLA1REPR )
    {
        ::formula::FormulaGrammar::AddressConvention eConv = aPropertyName == SC_UNONAME_XLA1REPR ?
            ::formula::FormulaGrammar::CONV_XL_A1 : ::formula::FormulaGrammar::CONV_OOO;

        //  parse the file format string
        OUString sRepresentation;
        if (aValue >>= sRepresentation)
        {
            OUString aUIString(sRepresentation);

            //  cell or range: strip a single "." at the start
            if ( aUIString[0]== '.' )
                aUIString = aUIString.copy( 1 );

            if ( bIsRange )
            {
                //  range: also strip a "." after the last colon
                sal_Int32 nColon = aUIString.lastIndexOf( ':' );
                if ( nColon >= 0 && nColon < aUIString.getLength() - 1 &&
                     aUIString[nColon+1] == '.' )
                    aUIString = aUIString.replaceAt( nColon+1, 1, u"" );
            }

            //  parse the rest like a UI string
            bSuccess = ParseUIString( aUIString, eConv );
        }
    }
    else
        throw beans::UnknownPropertyException(aPropertyName);

    if ( !bSuccess )
        throw lang::IllegalArgumentException();
}

uno::Any SAL_CALL ScAddressConversionObj::getPropertyValue( const OUString& aPropertyName )
{
    if ( !pDocShell )
        throw uno::RuntimeException();

    ScDocument& rDoc = pDocShell->GetDocument();
    uno::Any aRet;

    if ( aPropertyName == SC_UNONAME_ADDRESS )
    {
        if ( bIsRange )
        {
            table::CellRangeAddress aRangeAddress;
            ScUnoConversion::FillApiRange( aRangeAddress, aRange );
            aRet <<= aRangeAddress;
        }
        else
        {
            table::CellAddress aCellAddress;
            ScUnoConversion::FillApiAddress( aCellAddress, aRange.aStart );
            aRet <<= aCellAddress;
        }
    }
    else if ( aPropertyName == SC_UNONAME_REFSHEET )
    {
        aRet <<= nRefSheet;
    }
    else if ( aPropertyName == SC_UNONAME_UIREPR )
    {
        //  generate UI representation string - include sheet only if different from ref sheet
        OUString aFormatStr;
        ScRefFlags nFlags = ScRefFlags::VALID;
        if ( aRange.aStart.Tab() != nRefSheet )
            nFlags |= ScRefFlags::TAB_3D;
        if ( bIsRange )
            aFormatStr = aRange.Format(rDoc, nFlags);
        else
            aFormatStr = aRange.aStart.Format(nFlags, &rDoc);
        aRet <<= aFormatStr;
    }
    else if ( aPropertyName == SC_UNONAME_PERSREPR || aPropertyName == SC_UNONAME_XLA1REPR )
    {
        ::formula::FormulaGrammar::AddressConvention eConv = aPropertyName == SC_UNONAME_XLA1REPR ?
            ::formula::FormulaGrammar::CONV_XL_A1 : ::formula::FormulaGrammar::CONV_OOO;

        //  generate file format string - always include sheet
        OUString aFormatStr(aRange.aStart.Format(ScRefFlags::VALID | ScRefFlags::TAB_3D, &rDoc, eConv));
        if ( bIsRange )
        {
            //  manually concatenate range so both parts always have the sheet name
            aFormatStr += ":";
            ScRefFlags nFlags = ScRefFlags::VALID;
            if( eConv != ::formula::FormulaGrammar::CONV_XL_A1 )
                nFlags |= ScRefFlags::TAB_3D;
            OUString aSecond(aRange.aEnd.Format(nFlags, &rDoc, eConv));
            aFormatStr += aSecond ;
        }
        aRet <<= aFormatStr;
    }
    else
        throw beans::UnknownPropertyException(aPropertyName);

    return aRet;
}

SC_IMPL_DUMMY_PROPERTY_LISTENER( ScAddressConversionObj )

// lang::XServiceInfo

OUString SAL_CALL ScAddressConversionObj::getImplementationName()
{
    return u"ScAddressConversionObj"_ustr;
}

sal_Bool SAL_CALL ScAddressConversionObj::supportsService( const OUString& rServiceName )
{
    return cppu::supportsService(this, rServiceName);
}

uno::Sequence<OUString> SAL_CALL ScAddressConversionObj::getSupportedServiceNames()
{
    if (bIsRange)
        return {SC_SERVICENAME_RANGEADDRESS};
    else
        return {SC_SERVICENAME_CELLADDRESS};
}

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