/******************************************************************************

 *

 * Project:  GDAL/OGR Geography Network support (Geographic Network Model)

 * Purpose:  GNM db based generic driver.

 * Authors:  Mikhail Gusev (gusevmihs at gmail dot com)

 *           Dmitry Baryshnikov, polimax@mail.ru

 *

 ******************************************************************************

 * Copyright (c) 2014, Mikhail Gusev

 * Copyright (c) 2014-2015, NextGIS <info@nextgis.com>

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

 * DEALINGS IN THE SOFTWARE.

 ****************************************************************************/

#include "gnmdb.h"

#include "gnm_priv.h"

GNMDatabaseNetwork::GNMDatabaseNetwork() : GNMGenericNetwork()

{

    m_poDS = nullptr;

}

GNMDatabaseNetwork::~GNMDatabaseNetwork()

{

    FlushCache(true);

    GDALClose(m_poDS);

}

CPLErr GNMDatabaseNetwork::Open(GDALOpenInfo *poOpenInfo)

{

    FormName(poOpenInfo->pszFilename, poOpenInfo->papszOpenOptions);

    if (CSLFindName(poOpenInfo->papszOpenOptions, "LIST_ALL_TABLES") == -1)

        poOpenInfo->papszOpenOptions = CSLAddNameValue(

            poOpenInfo->papszOpenOptions, "LIST_ALL_TABLES", "YES");

    m_poDS = (GDALDataset *)GDALOpenEx(m_soNetworkFullName,

                                       GDAL_OF_VECTOR | GDAL_OF_UPDATE, nullptr,

                                       nullptr, poOpenInfo->papszOpenOptions);

    if (nullptr == m_poDS)

    {

        CPLError(CE_Failure, CPLE_OpenFailed, "Open '%s' failed",

                 m_soNetworkFullName.c_str());

        return CE_Failure;

    }

    // There should be only one schema so no schema name can be in table name

    if (LoadMetadataLayer(m_poDS) != CE_None)

    {

        return CE_Failure;

    }

    if (LoadGraphLayer(m_poDS) != CE_None)

    {

        return CE_Failure;

    }

    if (LoadFeaturesLayer(m_poDS) != CE_None)

    {

        return CE_Failure;

    }

    return CE_None;

}

CPLErr GNMDatabaseNetwork::Create(const char *pszFilename,

                                  CSLConstList papszOptions)

{

    FormName(pszFilename, papszOptions);

    if (m_soName.empty() || m_soNetworkFullName.empty())

    {

        CPLError(CE_Failure, CPLE_IllegalArg,

                 "The network name should be present");

        return CE_Failure;

    }

    if (nullptr == m_poDS)

    {

        m_poDS = (GDALDataset *)GDALOpenEx(m_soNetworkFullName,

                                           GDAL_OF_VECTOR | GDAL_OF_UPDATE,

                                           nullptr, nullptr, papszOptions);

    }

    if (nullptr == m_poDS)

    {

        CPLError(CE_Failure, CPLE_OpenFailed, "Open '%s' failed",

                 m_soNetworkFullName.c_str());

        return CE_Failure;

    }

    GDALDriver *l_poDriver = m_poDS->GetDriver();

    if (nullptr == l_poDriver)

    {

        CPLError(CE_Failure, CPLE_OpenFailed, "Get dataset driver failed");

        return CE_Failure;

    }

    if (!CheckStorageDriverSupport(l_poDriver->GetDescription()))

    {

        return CE_Failure;

    }

    // check required options

    const char *pszNetworkDescription =

        CSLFetchNameValue(papszOptions, GNM_MD_DESCR);

    if (nullptr != pszNetworkDescription)

        sDescription = pszNetworkDescription;

    // check Spatial reference

    const char *pszSRS = CSLFetchNameValue(papszOptions, GNM_MD_SRS);

    if (nullptr == pszSRS)

    {

        CPLError(CE_Failure, CPLE_IllegalArg,

                 "The network spatial reference should be present");

        return CE_Failure;

    }

    else

    {

        OGRSpatialReference spatialRef;

        spatialRef.SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);

        if (spatialRef.SetFromUserInput(pszSRS) != OGRERR_NONE)

        {

            CPLError(CE_Failure, CPLE_IllegalArg,

                     "The network spatial reference should be present");

            return CE_Failure;

        }

        m_oSRS = std::move(spatialRef);

    }

    int nResult = CheckNetworkExist(pszFilename, papszOptions);

    if (TRUE == nResult)

    {

        CPLError(CE_Failure, CPLE_IllegalArg, "The network already exist");

        return CE_Failure;

    }

    // Create the necessary system layers and fields

    // Create meta layer

    CPLErr eResult = CreateMetadataLayer(m_poDS, GNM_VERSION_NUM);

    if (CE_None != eResult)

    {

        // an error message should come from function

        return CE_Failure;

    }

    // Create graph layer

    eResult = CreateGraphLayer(m_poDS);

    if (CE_None != eResult)

    {

        DeleteMetadataLayer();

        return CE_Failure;

    }

    // Create features layer

    eResult = CreateFeaturesLayer(m_poDS);

    if (CE_None != eResult)

    {

        DeleteMetadataLayer();

        DeleteGraphLayer();

        return CE_Failure;

    }

    return CE_None;

}

int GNMDatabaseNetwork::CheckNetworkExist(const char *pszFilename,

                                          CSLConstList papszOptions)

{

    // check if path exist

    // if path exist check if network already present and OVERWRITE option

    // else create the path

    if (FormName(pszFilename, papszOptions) != CE_None)

    {

        return TRUE;

    }

    if (nullptr == m_poDS)

    {

        m_poDS = (GDALDataset *)GDALOpenEx(m_soNetworkFullName,

                                           GDAL_OF_VECTOR | GDAL_OF_UPDATE,

                                           nullptr, nullptr, papszOptions);

    }

    const bool bOverwrite = CPLFetchBool(papszOptions, "OVERWRITE", false);

    std::vector<int> anDeleteLayers;

    int i;

    for (i = 0; i < m_poDS->GetLayerCount(); ++i)

    {

        OGRLayer *poLayer = m_poDS->GetLayer(i);

        if (nullptr == poLayer)

            continue;

        if (EQUAL(poLayer->GetName(), GNM_SYSLAYER_META) ||

            EQUAL(poLayer->GetName(), GNM_SYSLAYER_GRAPH) ||

            EQUAL(poLayer->GetName(), GNM_SYSLAYER_FEATURES))

        {

            anDeleteLayers.push_back(i);

        }

    }

    if (anDeleteLayers.empty())

        return FALSE;

    if (bOverwrite)

    {

        for (i = (int)anDeleteLayers.size(); i > 0; i--)

        {

            CPLDebug("GNM", "Delete layer: %d", i);

            if (m_poDS->DeleteLayer(anDeleteLayers[i - 1]) != OGRERR_NONE)

                return TRUE;

        }

        return FALSE;

    }

    else

    {

        return TRUE;

    }

}

CPLErr GNMDatabaseNetwork::DeleteMetadataLayer()

{

    return DeleteLayerByName(GNM_SYSLAYER_META);

}

CPLErr GNMDatabaseNetwork::DeleteGraphLayer()

{

    return DeleteLayerByName(GNM_SYSLAYER_GRAPH);

}

CPLErr GNMDatabaseNetwork::DeleteFeaturesLayer()

{

    return DeleteLayerByName(GNM_SYSLAYER_FEATURES);

}

CPLErr GNMDatabaseNetwork::DeleteLayerByName(const char *pszLayerName)

{

    if (nullptr == m_poDS)

        return CE_Failure;

    for (int i = 0; i < m_poDS->GetLayerCount(); ++i)

    {

        OGRLayer *poLayer = m_poDS->GetLayer(i);

        if (nullptr == poLayer)

            continue;

        if (EQUAL(poLayer->GetName(), pszLayerName))

            return m_poDS->DeleteLayer(i) == OGRERR_NONE ? CE_None : CE_Failure;

    }

    CPLError(CE_Failure, CPLE_IllegalArg, "The layer %s not exist",

             pszLayerName);

    return CE_Failure;

}

CPLErr GNMDatabaseNetwork::DeleteNetworkLayers()

{

    while (GetLayerCount() > 0)

    {

        OGRErr eErr = DeleteLayer(0);

        if (eErr != OGRERR_NONE)

            return CE_Failure;

    }

    return CE_None;

}

CPLErr GNMDatabaseNetwork::LoadNetworkLayer(const char *pszLayername)

{

    // check if not loaded

    for (size_t i = 0; i < m_apoLayers.size(); ++i)

    {

        if (EQUAL(m_apoLayers[i]->GetName(), pszLayername))

            return CE_None;

    }

    OGRLayer *poLayer = m_poDS->GetLayerByName(pszLayername);

    if (nullptr == poLayer)

    {

        CPLError(CE_Failure, CPLE_OpenFailed, "Layer '%s' is not exist",

                 pszLayername);

        return CE_Failure;

    }

    CPLDebug("GNM", "Layer '%s' loaded", poLayer->GetName());

    GNMGenericLayer *pGNMLayer = new GNMGenericLayer(poLayer, this);

    m_apoLayers.push_back(pGNMLayer);

    return CE_None;

}

bool GNMDatabaseNetwork::CheckStorageDriverSupport(const char *pszDriverName)

{

    if (EQUAL(pszDriverName, "PostgreSQL"))

        return true;

    // TODO: expand this list with supported OGR direvers

    return false;

}

CPLErr GNMDatabaseNetwork::FormName(const char *pszFilename,

                                    CSLConstList papszOptions)

{

    if (m_soNetworkFullName.empty())

        m_soNetworkFullName = pszFilename;

    if (m_soName.empty())

    {

        const char *pszNetworkName =

            CSLFetchNameValue(papszOptions, GNM_MD_NAME);

        if (nullptr != pszNetworkName)

        {

            m_soName = pszNetworkName;

        }

        char *pszActiveSchemaStart;

        pszActiveSchemaStart = (char *)strstr(pszFilename, "active_schema=");

        if (pszActiveSchemaStart == nullptr)

            pszActiveSchemaStart =

                (char *)strstr(pszFilename, "ACTIVE_SCHEMA=");

        if (pszActiveSchemaStart != nullptr)

        {

            char *pszActiveSchema;

            pszActiveSchema =

                CPLStrdup(pszActiveSchemaStart + strlen("active_schema="));

            const char *pszEnd = strchr(pszActiveSchemaStart, ' ');

            if (pszEnd == nullptr)

                pszEnd = pszFilename + strlen(pszFilename);

            pszActiveSchema[pszEnd - pszActiveSchemaStart -

                            strlen("active_schema=")] = '\0';

            m_soName = pszActiveSchema;

            CPLFree(pszActiveSchema);

        }

        else

        {

            if (!m_soName.empty())

            {

                // add active schema

                m_soNetworkFullName += "ACTIVE_SCHEMA=" + m_soName;

            }

            else

            {

                m_soName = "public";

            }

        }

        CPLDebug("GNM", "Network name: %s", m_soName.c_str());

    }

    return CE_None;

}

OGRErr GNMDatabaseNetwork::DeleteLayer(int nIndex)

{

    if (nullptr == m_poDS)

    {

        CPLError(CE_Failure, CPLE_FileIO, "Network not opened.");

        return OGRERR_FAILURE;

    }

    OGRLayer *poNetworkLayer = GetLayer(nIndex);

    CPLDebug("GNM", "Delete network layer '%s'", poNetworkLayer->GetName());

    int nDeleteIndex = -1;

    for (int i = 0; i < m_poDS->GetLayerCount(); ++i)

    {

        OGRLayer *poLayer = m_poDS->GetLayer(i);

        if (EQUAL(poNetworkLayer->GetName(), poLayer->GetName()))

        {

            nDeleteIndex = i;

            break;

        }

    }

    if (m_poDS->DeleteLayer(nDeleteIndex) != OGRERR_NONE)

    {

        return OGRERR_FAILURE;

    }

    return GNMGenericNetwork::DeleteLayer(nIndex);

}

OGRLayer *

GNMDatabaseNetwork::ICreateLayer(const char *pszName,

                                 const OGRGeomFieldDefn *poGeomFieldDefn,

                                 CSLConstList papszOptions)

{

    // check if layer with such name exist

    for (int i = 0; i < GetLayerCount(); ++i)

    {

        OGRLayer *pLayer = GetLayer(i);

        if (nullptr == pLayer)

            continue;

        if (EQUAL(pLayer->GetName(), pszName))

        {

            CPLError(CE_Failure, CPLE_IllegalArg,

                     "The network layer '%s' already exist.", pszName);

            return nullptr;

        }

    }

    OGRSpatialReference oSpaRef(m_oSRS);

    const auto eGType = poGeomFieldDefn ? poGeomFieldDefn->GetType() : wkbNone;

    OGRLayer *poLayer =

        m_poDS->CreateLayer(pszName, &oSpaRef, eGType, papszOptions);

    if (poLayer == nullptr)

    {

        CPLError(CE_Failure, CPLE_FileIO, "Layer creation failed.");

        return nullptr;

    }

    OGRFieldDefn oField(GNM_SYSFIELD_GFID, GNMGFIDInt);

    if (poLayer->CreateField(&oField) != OGRERR_NONE)

    {

        CPLError(CE_Failure, CPLE_FileIO,

                 "Creating global identificator field failed.");

        return nullptr;

    }

    OGRFieldDefn oFieldBlock(GNM_SYSFIELD_BLOCKED, OFTInteger);

    if (poLayer->CreateField(&oFieldBlock) != OGRERR_NONE)

    {

        CPLError(CE_Failure, CPLE_FileIO, "Creating is blocking field failed.");

        return nullptr;

    }

    GNMGenericLayer *pGNMLayer = new GNMGenericLayer(poLayer, this);

    m_apoLayers.push_back(pGNMLayer);

    return pGNMLayer;

}