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

#include <drawingml/chart/geographycontext.hxx>
#include <drawingml/chart/geographymodel.hxx>
#include <oox/helper/attributelist.hxx>
#include <oox/token/namespaces.hxx>
#include <oox/token/tokens.hxx>

namespace oox::drawingml::chart
{
using ::oox::core::ContextHandlerRef;

GeographyContext::GeographyContext(::oox::core::ContextHandler2Helper& rParent,
                                   GeographyModel& rModel)
    : ContextHandler2(rParent)
    , mrModel(rModel)
{
}

// Handle the CT_Geography complex type in the chartex schema
ContextHandlerRef GeographyContext::onCreateContext(sal_Int32 nElement,
                                                    const AttributeList& rAttribs)
{
    switch (getCurrentElement())
    {
        case CX_TOKEN(geography):
            switch (nElement)
            {
                case CX_TOKEN(geoCache):
                    mrModel.mxGeoCache.emplace();
                    mrModel.mxGeoCache->mosProvider = rAttribs.getString(XML_provider);
                    return this;
            }
            break;

        case CX_TOKEN(geoCache):
            switch (nElement)
            {
                case CX_TOKEN(binary):
                    return this;
                case CX_TOKEN(clear):
                    mrModel.mxGeoCache->mxClear.emplace();
                    return this;
            }
            break;

        case CX_TOKEN(clear):
            switch (nElement)
            {
                case CX_TOKEN(geoLocationQueryResults):
                case CX_TOKEN(geoDataEntityQueryResults):
                case CX_TOKEN(geoDataPointToEntityQueryResults):
                case CX_TOKEN(geoChildEntitiesQueryResults):
                case CX_TOKEN(geoParentEntitiesQueryResults):
                    return this;
            }
            break;

        case CX_TOKEN(geoLocationQueryResults):
            if (nElement == CX_TOKEN(geoLocationQueryResult))
            {
                auto& rClear = *mrModel.mxGeoCache->mxClear;
                rClear.maLocResults.emplace_back();
                mpCurLocResult = &rClear.maLocResults.back();
                return this;
            }
            break;

        case CX_TOKEN(geoLocationQueryResult):
            switch (nElement)
            {
                case CX_TOKEN(geoLocationQuery):
                {
                    mpCurLocResult->mxQuery.emplace();
                    auto& q = *mpCurLocResult->mxQuery;
                    q.mosCountryRegion = rAttribs.getString(XML_countryRegion);
                    q.mosAdminDistrict1 = rAttribs.getString(XML_adminDistrict1);
                    q.mosAdminDistrict2 = rAttribs.getString(XML_adminDistrict2);
                    q.mosPostalCode = rAttribs.getString(XML_postalCode);
                    q.mosEntityType = rAttribs.getString(XML_entityType);
                    return nullptr;
                }
                case CX_TOKEN(geoLocations):
                    return this;
            }
            break;

        case CX_TOKEN(geoLocations):
            if (nElement == CX_TOKEN(geoLocation))
            {
                mpCurLocResult->maLocations.emplace_back();
                auto& loc = mpCurLocResult->maLocations.back();
                loc.mosLatitude = rAttribs.getString(XML_latitude);
                loc.mosLongitude = rAttribs.getString(XML_longitude);
                loc.mosEntityName = rAttribs.getString(XML_entityName);
                loc.mosEntityType = rAttribs.getString(XML_entityType);
                return this;
            }
            break;

        case CX_TOKEN(geoLocation):
            if (nElement == CX_TOKEN(address))
            {
                auto& loc = mpCurLocResult->maLocations.back();
                loc.mxAddress.emplace();
                auto& a = *loc.mxAddress;
                a.mosAddress1 = rAttribs.getString(XML_address1);
                a.mosCountryRegion = rAttribs.getString(XML_countryRegion);
                a.mosAdminDistrict1 = rAttribs.getString(XML_adminDistrict1);
                a.mosAdminDistrict2 = rAttribs.getString(XML_adminDistrict2);
                a.mosPostalCode = rAttribs.getString(XML_postalCode);
                a.mosLocality = rAttribs.getString(XML_locality);
                a.mosIsoCountryCode = rAttribs.getString(XML_isoCountryCode);
                return nullptr;
            }
            break;

        case CX_TOKEN(geoDataEntityQueryResults):
            if (nElement == CX_TOKEN(geoDataEntityQueryResult))
            {
                auto& rClear = *mrModel.mxGeoCache->mxClear;
                rClear.maDataResults.emplace_back();
                mpCurDataResult = &rClear.maDataResults.back();
                return this;
            }
            break;

        case CX_TOKEN(geoDataEntityQueryResult):
            switch (nElement)
            {
                case CX_TOKEN(geoDataEntityQuery):
                {
                    mpCurDataResult->mxQuery.emplace();
                    auto& q = *mpCurDataResult->mxQuery;
                    q.mosEntityType = rAttribs.getString(XML_entityType);
                    q.mosEntityId = rAttribs.getString(XML_entityId);
                    return nullptr;
                }
                case CX_TOKEN(geoData):
                {
                    mpCurDataResult->mxData.emplace();
                    auto& d = *mpCurDataResult->mxData;
                    d.mosEntityName = rAttribs.getString(XML_entityName);
                    d.mosEntityId = rAttribs.getString(XML_entityId);
                    d.mosEast = rAttribs.getString(XML_east);
                    d.mosWest = rAttribs.getString(XML_west);
                    d.mosNorth = rAttribs.getString(XML_north);
                    d.mosSouth = rAttribs.getString(XML_south);
                    return this;
                }
            }
            break;

        case CX_TOKEN(geoData):
            switch (nElement)
            {
                case CX_TOKEN(geoPolygons):
                    return this;
                case CX_TOKEN(copyrights):
                    return this;
            }
            break;

        case CX_TOKEN(geoPolygons):
            if (nElement == CX_TOKEN(geoPolygon))
            {
                auto& d = *mpCurDataResult->mxData;
                d.maPolygons.emplace_back();
                auto& p = d.maPolygons.back();
                p.mosPolygonId = rAttribs.getString(XML_polygonId);
                p.mosNumPoints = rAttribs.getString(XML_numPoints);
                p.mosPcaRings = rAttribs.getString(XML_pcaRings);
                return nullptr;
            }
            break;

        case CX_TOKEN(copyrights):
            if (nElement == CX_TOKEN(copyright))
                return this;
            break;

        case CX_TOKEN(geoDataPointToEntityQueryResults):
            if (nElement == CX_TOKEN(geoDataPointToEntityQueryResult))
            {
                auto& rClear = *mrModel.mxGeoCache->mxClear;
                rClear.maPtResults.emplace_back();
                mpCurPtResult = &rClear.maPtResults.back();
                return this;
            }
            break;

        case CX_TOKEN(geoDataPointToEntityQueryResult):
            switch (nElement)
            {
                case CX_TOKEN(geoDataPointQuery):
                {
                    mpCurPtResult->mxPointQuery.emplace();
                    auto& q = *mpCurPtResult->mxPointQuery;
                    q.mosEntityType = rAttribs.getString(XML_entityType);
                    q.mosLatitude = rAttribs.getString(XML_latitude);
                    q.mosLongitude = rAttribs.getString(XML_longitude);
                    return nullptr;
                }
                case CX_TOKEN(geoDataPointToEntityQuery):
                {
                    mpCurPtResult->mxEntityQuery.emplace();
                    auto& q = *mpCurPtResult->mxEntityQuery;
                    q.mosEntityType = rAttribs.getString(XML_entityType);
                    q.mosEntityId = rAttribs.getString(XML_entityId);
                    return nullptr;
                }
            }
            break;

        case CX_TOKEN(geoChildEntitiesQueryResults):
            if (nElement == CX_TOKEN(geoChildEntitiesQueryResult))
            {
                auto& rClear = *mrModel.mxGeoCache->mxClear;
                rClear.maChildResults.emplace_back();
                mpCurChildResult = &rClear.maChildResults.back();
                return this;
            }
            break;

        case CX_TOKEN(geoChildEntitiesQueryResult):
            switch (nElement)
            {
                case CX_TOKEN(geoChildEntitiesQuery):
                {
                    mpCurChildResult->mxQuery.emplace();
                    mpCurChildResult->mxQuery->mosEntityId = rAttribs.getString(XML_entityId);
                    return this;
                }
                case CX_TOKEN(geoChildEntities):
                    return this;
            }
            break;

        case CX_TOKEN(geoChildEntitiesQuery):
            if (nElement == CX_TOKEN(geoChildTypes))
                return this;
            break;

        case CX_TOKEN(geoChildTypes):
            if (nElement == CX_TOKEN(entityType))
                return this;
            break;

        case CX_TOKEN(geoChildEntities):
            if (nElement == CX_TOKEN(geoHierarchyEntity))
            {
                mpCurChildResult->maEntities.emplace_back();
                auto& e = mpCurChildResult->maEntities.back();
                e.mosEntityName = rAttribs.getString(XML_entityName);
                e.mosEntityId = rAttribs.getString(XML_entityId);
                e.mosEntityType = rAttribs.getString(XML_entityType);
                return nullptr;
            }
            break;

        case CX_TOKEN(geoParentEntitiesQueryResults):
            if (nElement == CX_TOKEN(geoParentEntitiesQueryResult))
            {
                auto& rClear = *mrModel.mxGeoCache->mxClear;
                rClear.maParentResults.emplace_back();
                mpCurParentResult = &rClear.maParentResults.back();
                return this;
            }
            break;

        case CX_TOKEN(geoParentEntitiesQueryResult):
            switch (nElement)
            {
                case CX_TOKEN(geoParentEntitiesQuery):
                    mpCurParentResult->mxQuery.emplace();
                    mpCurParentResult->mxQuery->mosEntityId = rAttribs.getString(XML_entityId);
                    return nullptr;
                case CX_TOKEN(geoEntity):
                    mpCurParentResult->mxEntity.emplace();
                    mpCurParentResult->mxEntity->mosEntityName = rAttribs.getString(XML_entityName);
                    mpCurParentResult->mxEntity->mosEntityType = rAttribs.getString(XML_entityType);
                    return nullptr;
                case CX_TOKEN(geoParentEntity):
                    mpCurParentResult->mxParentEntity.emplace();
                    mpCurParentResult->mxParentEntity->mosEntityId
                        = rAttribs.getString(XML_entityId);
                    return nullptr;
            }
            break;
    }
    return nullptr;
}

// Handle character data
void GeographyContext::onCharacters(const OUString& rChars)
{
    switch (getCurrentElement())
    {
        case CX_TOKEN(binary):
            if (mrModel.mxGeoCache.has_value())
                mrModel.mxGeoCache->mosBinary = rChars;
            break;
        case CX_TOKEN(copyright):
            if (mpCurDataResult && mpCurDataResult->mxData.has_value())
                mpCurDataResult->mxData->maCopyrights.push_back({ rChars });
            break;
        case CX_TOKEN(entityType):
            if (mpCurChildResult && mpCurChildResult->mxQuery.has_value())
                mpCurChildResult->mxQuery->maEntityTypes.push_back(rChars);
            break;
    }
}

} // namespace oox::drawingml::chart

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