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

 *

 * Name:     mitab_imapinfo

 * Project:  MapInfo mid/mif Tab Read/Write library

 * Language: C++

 * Purpose:  Implementation of the IMapInfoFile class, super class of

 *           of MIFFile and TABFile

 * Author:   Daniel Morissette, dmorissette@dmsolutions.ca

 *

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

 * Copyright (c) 1999-2008, Daniel Morissette

 * Copyright (c) 2014, Even Rouault <even.rouault at spatialys.com>

 *

 * SPDX-License-Identifier: MIT

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

#include "cpl_port.h"

#include "mitab.h"

#include <cassert>

#include <cctype>

#include <cstring>

#include <algorithm>

#include "cpl_conv.h"

#include "cpl_error.h"

#include "cpl_vsi.h"

#include "mitab_priv.h"

#include "mitab_utils.h"

#include "ogr_core.h"

#include "ogr_feature.h"

#include "ogr_geometry.h"

#ifdef __HP_aCC

#include <wchar.h> /* iswspace() */

#else

#include <wctype.h> /* iswspace() */

#endif

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

 *                   IMapInfoFile::IMapInfoFile()

 *

 * Constructor.

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

IMapInfoFile::IMapInfoFile(GDALDataset *poDS)

    : m_poDS(poDS), m_nCurFeatureId(0), m_poCurFeature(nullptr),

      m_bBoundsSet(FALSE), m_pszCharset(nullptr)

{

}

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

 *                   IMapInfoFile::~IMapInfoFile()

 *

 * Destructor.

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

IMapInfoFile::~IMapInfoFile()

{

    if (m_poCurFeature)

    {

        delete m_poCurFeature;

        m_poCurFeature = nullptr;

    }

    CPLFree(m_pszCharset);

    m_pszCharset = nullptr;

}

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

 *                   IMapInfoFile::Open()

 *

 * Compatibility layer with new interface.

 * Return 0 on success, -1 in case of failure.

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

int IMapInfoFile::Open(const char *pszFname, const char *pszAccess,

                       GBool bTestOpenNoError, const char *pszCharset)

{

    // cppcheck-suppress nullPointer

    if (STARTS_WITH_CI(pszAccess, "r"))

        return Open(pszFname, TABRead, bTestOpenNoError, pszCharset);

    else if (STARTS_WITH_CI(pszAccess, "w"))

        return Open(pszFname, TABWrite, bTestOpenNoError, pszCharset);

    else

    {

        CPLError(CE_Failure, CPLE_FileIO,

                 "Open() failed: access mode \"%s\" not supported", pszAccess);

        return -1;

    }

}

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

 *                   IMapInfoFile::SmartOpen()

 *

 * Use this static method to automatically open any flavor of MapInfo

 * dataset.  This method will detect the file type, create an object

 * of the right type, and open the file.

 *

 * Call GetFileClass() on the returned object if you need to find out

 * its exact type.  (To access format-specific methods for instance)

 *

 * Returns the new object ptr. , or NULL if the open failed.

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

IMapInfoFile *IMapInfoFile::SmartOpen(GDALDataset *poDS, const char *pszFname,

                                      GBool bUpdate,

                                      GBool bTestOpenNoError /*=FALSE*/)

{

    IMapInfoFile *poFile = nullptr;

    int nLen = 0;

    if (pszFname)

        nLen = static_cast<int>(strlen(pszFname));

    if (nLen > 4 && (EQUAL(pszFname + nLen - 4, ".MIF") ||

                     EQUAL(pszFname + nLen - 4, ".MID")))

    {

        /*-------------------------------------------------------------

         * MIF/MID file

         *------------------------------------------------------------*/

        poFile = new MIFFile(poDS);

    }

    else if (nLen > 4 && EQUAL(pszFname + nLen - 4, ".TAB"))

    {

        /*-------------------------------------------------------------

         * .TAB file ... is it a TABFileView or a TABFile?

         * We have to read the .tab header to find out.

         *------------------------------------------------------------*/

        char *pszAdjFname = CPLStrdup(pszFname);

        GBool bFoundFields = FALSE;

        GBool bFoundView = FALSE;

        GBool bFoundSeamless = FALSE;

        TABAdjustFilenameExtension(pszAdjFname);

        VSILFILE *fp = VSIFOpenL(pszAdjFname, "r");

        const char *pszLine = nullptr;

        while (fp && (pszLine = CPLReadLineL(fp)) != nullptr)

        {

            while (isspace(static_cast<unsigned char>(*pszLine)))

                pszLine++;

            if (STARTS_WITH_CI(pszLine, "Fields"))

                bFoundFields = TRUE;

            else if (STARTS_WITH_CI(pszLine, "create view"))

                bFoundView = TRUE;

            else if (STARTS_WITH_CI(pszLine, "\"\\IsSeamless\" = \"TRUE\""))

                bFoundSeamless = TRUE;

        }

        if (bFoundView)

            poFile = new TABView(poDS);

        else if (bFoundFields && bFoundSeamless)

            poFile = new TABSeamless(poDS);

        else if (bFoundFields)

            poFile = new TABFile(poDS);

        if (fp)

            VSIFCloseL(fp);

        CPLFree(pszAdjFname);

    }

    /*-----------------------------------------------------------------

     * Perform the open() call

     *----------------------------------------------------------------*/

    if (poFile && poFile->Open(pszFname, bUpdate ? TABReadWrite : TABRead,

                               bTestOpenNoError) != 0)

    {

        delete poFile;

        poFile = nullptr;

    }

    if (!bTestOpenNoError && poFile == nullptr)

    {

        CPLError(CE_Failure, CPLE_FileIO,

                 "%s could not be opened as a MapInfo dataset.", pszFname);

    }

    return poFile;

}

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

 *                   IMapInfoFile::GetNextFeature()

 *

 * Standard OGR GetNextFeature implementation.  This method is used

 * to retrieve the next OGRFeature.

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

OGRFeature *IMapInfoFile::GetNextFeature()

{

    GIntBig nFeatureId = 0;

    while ((nFeatureId = GetNextFeatureId(m_nCurFeatureId)) != -1)

    {

        OGRGeometry *poGeom = nullptr;

        OGRFeature *poFeatureRef = GetFeatureRef(nFeatureId);

        if (poFeatureRef == nullptr)

            return nullptr;

        else if ((m_poFilterGeom == nullptr ||

                  ((poGeom = poFeatureRef->GetGeometryRef()) != nullptr &&

                   FilterGeometry(poGeom))) &&

                 (m_poAttrQuery == nullptr ||

                  m_poAttrQuery->Evaluate(poFeatureRef)))

        {

            // Avoid cloning feature... return the copy owned by the class

            CPLAssert(poFeatureRef == m_poCurFeature);

            m_poCurFeature = nullptr;

            if (poFeatureRef->GetGeometryRef() != nullptr)

                poFeatureRef->GetGeometryRef()->assignSpatialReference(

                    GetSpatialRef());

            return poFeatureRef;

        }

    }

    return nullptr;

}

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

 *                   IMapInfoFile::CreateTABFeature()

 *

 * Instantiate a TABFeature* from a OGRFeature* (or NULL on error)

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

TABFeature *IMapInfoFile::CreateTABFeature(OGRFeature *poFeature)

{

    TABFeature *poTABFeature = nullptr;

    OGRwkbGeometryType eGType;

    TABPoint *poTABPointFeature = nullptr;

    TABRegion *poTABRegionFeature = nullptr;

    TABPolyline *poTABPolylineFeature = nullptr;

    /*-----------------------------------------------------------------

     * MITAB won't accept new features unless they are in a type derived

     * from TABFeature... so we have to do our best to map to the right

     * feature type based on the geometry type.

     *----------------------------------------------------------------*/

    OGRGeometry *poGeom = poFeature->GetGeometryRef();

    if (poGeom != nullptr)

        eGType = poGeom->getGeometryType();

    else

        eGType = wkbNone;

    switch (wkbFlatten(eGType))

    {

        /*-------------------------------------------------------------

         * POINT

         *------------------------------------------------------------*/

        case wkbPoint:

        {

            const char *pszStyleString = poFeature->GetStyleString();

            if (pszStyleString)

            {

                if (strstr(pszStyleString, "LABEL("))

                {

                    auto poText = new TABText(poFeature->GetDefnRef());

                    poText->SetLabelFromStyleString(pszStyleString);

                    poTABFeature = poText;

                    if (strstr(pszStyleString, "SYMBOL("))

                    {

                        CPLError(CE_Warning, CPLE_AppDefined,

                                 "OGR style string contains both "

                                 "Label and Symbol parts. "

                                 "Only Label taken into account due to "

                                 "MapInfo TAB/MIF format limitations.");

                    }

                }

                else

                {

                    TABFeatureClass featureClass =

                        ITABFeatureSymbol::GetSymbolFeatureClass(

                            pszStyleString);

                    if (featureClass == TABFCFontPoint)

                    {

                        poTABFeature =

                            new TABFontPoint(poFeature->GetDefnRef());

                    }

                    else if (featureClass == TABFCCustomPoint)

                    {

                        poTABFeature =

                            new TABCustomPoint(poFeature->GetDefnRef());

                    }

                    else

                    {

                        poTABFeature = new TABPoint(poFeature->GetDefnRef());

                    }

                    poTABPointFeature =

                        cpl::down_cast<TABPoint *>(poTABFeature);

                    poTABPointFeature->SetSymbolFromStyleString(

                        poFeature->GetStyleString());

                }

            }

            else

            {

                poTABFeature = new TABPoint(poFeature->GetDefnRef());

            }

            break;

        }

        /*-------------------------------------------------------------

         * REGION

         *------------------------------------------------------------*/

        case wkbPolygon:

        case wkbMultiPolygon:

        {

            poTABFeature = new TABRegion(poFeature->GetDefnRef());

            if (poFeature->GetStyleString())

            {

                poTABRegionFeature = cpl::down_cast<TABRegion *>(poTABFeature);

                poTABRegionFeature->SetPenFromStyleString(

                    poFeature->GetStyleString());

                poTABRegionFeature->SetBrushFromStyleString(

                    poFeature->GetStyleString());

            }

            break;

        }

        /*-------------------------------------------------------------

         * LINE/PLINE/MULTIPLINE

         *------------------------------------------------------------*/

        case wkbLineString:

        case wkbMultiLineString:

        {

            poTABFeature = new TABPolyline(poFeature->GetDefnRef());

            if (poFeature->GetStyleString())

            {

                poTABPolylineFeature =

                    cpl::down_cast<TABPolyline *>(poTABFeature);

                poTABPolylineFeature->SetPenFromStyleString(

                    poFeature->GetStyleString());

            }

            break;

        }

        /*-------------------------------------------------------------

         * Collection types that are not directly supported... convert

         * to multiple features in output file through recursive calls.

         *------------------------------------------------------------*/

        case wkbGeometryCollection:

        case wkbMultiPoint:

        {

            OGRErr eStatus = OGRERR_NONE;

            assert(poGeom);  // for clang static analyzer

            OGRGeometryCollection *poColl = poGeom->toGeometryCollection();

            auto poTmpFeature = std::unique_ptr<OGRFeature>(poFeature->Clone());

            for (int i = 0; eStatus == OGRERR_NONE && poColl != nullptr &&

                            i < poColl->getNumGeometries();

                 i++)

            {

                poTmpFeature->SetFID(OGRNullFID);

                poTmpFeature->SetGeometry(poColl->getGeometryRef(i));

                eStatus = ICreateFeature(poTmpFeature.get());

            }

            break;

        }

        /*-------------------------------------------------------------

         * Unsupported type.... convert to MapInfo geometry NONE

         *------------------------------------------------------------*/

        default:

        {

            poTABFeature = new TABFeature(poFeature->GetDefnRef());

            break;

        }

    }

    if (poTABFeature)

    {

        if (poGeom != nullptr)

            poTABFeature->SetGeometryDirectly(poGeom->clone());

        for (int i = 0; i < poFeature->GetDefnRef()->GetFieldCount(); i++)

        {

            poTABFeature->SetField(i, poFeature->GetRawFieldRef(i));

        }

        poTABFeature->SetFID(poFeature->GetFID());

    }

    return poTABFeature;

}

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

 *                   IMapInfoFile::ICreateFeature()

 *

 * Standard OGR CreateFeature implementation.  This method is used

 * to create a new feature in current dataset

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

OGRErr IMapInfoFile::ICreateFeature(OGRFeature *poFeature)

{

    TABFeature *poTABFeature = CreateTABFeature(poFeature);

    if (poTABFeature == nullptr) /* MultiGeometry */

        return OGRERR_NONE;

    OGRErr eErr = CreateFeature(poTABFeature);

    if (eErr == OGRERR_NONE)

        poFeature->SetFID(poTABFeature->GetFID());

    delete poTABFeature;

    return eErr;

}

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

 *                   IMapInfoFile::GetFeature()

 *

 * Standard OGR GetFeature implementation.  This method is used

 * to get the wanted (nFeatureId) feature, a NULL value will be

 * returned on error.

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

OGRFeature *IMapInfoFile::GetFeature(GIntBig nFeatureId)

{

    /*fprintf(stderr, "GetFeature(%ld)\n", nFeatureId);*/

    OGRFeature *poFeatureRef = GetFeatureRef(nFeatureId);

    if (poFeatureRef)

    {

        // Avoid cloning feature... return the copy owned by the class

        CPLAssert(poFeatureRef == m_poCurFeature);

        m_poCurFeature = nullptr;

        return poFeatureRef;

    }

    else

        return nullptr;

}

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

/*                            GetTABType()                              */

/*                                                                      */

/*      Create a native field based on a generic OGR definition.        */

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

int IMapInfoFile::GetTABType(const OGRFieldDefn *poField,

                             TABFieldType *peTABType, int *pnWidth,

                             int *pnPrecision)

{

    TABFieldType eTABType;

    int nWidth = poField->GetWidth();

    int nPrecision =

        poField->GetType() == OFTReal ? poField->GetPrecision() : 0;

    if (poField->GetType() == OFTInteger)

    {

        if (poField->GetSubType() == OFSTBoolean)

        {

            eTABType = TABFLogical;

            nWidth = 1;

        }

        else

        {

            eTABType = TABFInteger;

            if (nWidth == 0)

                nWidth = 12;

        }

    }

    else if (poField->GetType() == OFTInteger64)

    {

        eTABType = TABFLargeInt;

        if (nWidth == 0)

            nWidth = 20;

    }

    else if (poField->GetType() == OFTReal)

    {

        if (nWidth == 0 && poField->GetPrecision() == 0)

        {

            eTABType = TABFFloat;

            nWidth = 32;

        }

        else

        {

            eTABType = TABFDecimal;

            // Enforce Mapinfo limits, otherwise MapInfo will crash (#6392)

            if (nWidth > 20 || nWidth - nPrecision < 2 || nPrecision > 16)

            {

                if (nWidth > 20)

                    nWidth = 20;

                if (nWidth - nPrecision < 2)

                    nPrecision = nWidth - 2;

                if (nPrecision > 16)

                    nPrecision = 16;

                CPLDebug("MITAB",

                         "Adjusting initial width,precision of %s from %d,%d "

                         "to %d,%d",

                         poField->GetNameRef(), poField->GetWidth(),

                         poField->GetPrecision(), nWidth, nPrecision);

            }

        }

    }

    else if (poField->GetType() == OFTDate)

    {

        eTABType = TABFDate;

        if (nWidth == 0)

            nWidth = 10;

    }

    else if (poField->GetType() == OFTTime)

    {

        eTABType = TABFTime;

        if (nWidth == 0)

            nWidth = 9;

    }

    else if (poField->GetType() == OFTDateTime)

    {

        eTABType = TABFDateTime;

        if (nWidth == 0)

            nWidth = 19;

    }

    else if (poField->GetType() == OFTString)

    {

        eTABType = TABFChar;

        if (nWidth == 0)

            nWidth = 254;

        else

            nWidth = std::min(254, nWidth);

    }

    else

    {

        CPLError(CE_Failure, CPLE_AppDefined,

                 "IMapInfoFile::CreateField() called with unsupported field"

                 " type %d.\n"

                 "Note that Mapinfo files don't support list field types.\n",

                 poField->GetType());

        return -1;

    }

    if (peTABType)

        *peTABType = eTABType;

    if (pnWidth)

        *pnWidth = nWidth;

    if (pnPrecision)

        *pnPrecision = nPrecision;

    return 0;

}

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

/*                            CreateField()                             */

/*                                                                      */

/*      Create a native field based on a generic OGR definition.        */

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

OGRErr IMapInfoFile::CreateField(const OGRFieldDefn *poField, int bApproxOK)

{

    TABFieldType eTABType;

    int nWidth = 0;

    int nPrecision = 0;

    if (GetTABType(poField, &eTABType, &nWidth, &nPrecision) < 0)

        return OGRERR_FAILURE;

    if (AddFieldNative(poField->GetNameRef(), eTABType, nWidth, nPrecision,

                       FALSE, FALSE, bApproxOK) > -1)

        return OGRERR_NONE;

    return OGRERR_FAILURE;

}

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

 *                   IMapInfoFile::SetCharset()

 *

 * Set the charset for the tab header.

 *

 *

 * Returns 0 on success, -1 on error.

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

int IMapInfoFile::SetCharset(const char *pszCharset)

{

    if (pszCharset && strlen(pszCharset) > 0)

    {

        if (pszCharset == m_pszCharset)

        {

            return 0;

        }

        CPLFree(m_pszCharset);

        m_pszCharset = CPLStrdup(pszCharset);

        return 0;

    }

    return -1;

}

const char *IMapInfoFile::GetCharset() const

{

    return m_pszCharset;

}

// Table is adopted from

// http://www.i-signum.com/Formation/download/MB_ReferenceGuide.pdf pp. 127-128

// NOTE: if modifying this table, please keep doc/source/drivers/vector/mapinfo_encodings.csv in sync

static const char *const apszCharsets[][2] = {

    {"Neutral", ""},                 // No character conversions performed.

    {"ISO8859_1", "ISO-8859-1"},     // ISO 8859-1 (UNIX)

    {"ISO8859_2", "ISO-8859-2"},     // ISO 8859-2 (UNIX)

    {"ISO8859_3", "ISO-8859-3"},     // ISO 8859-3 (UNIX)

    {"ISO8859_4", "ISO-8859-4"},     // ISO 8859-4 (UNIX)

    {"ISO8859_5", "ISO-8859-5"},     // ISO 8859-5 (UNIX)

    {"ISO8859_6", "ISO-8859-6"},     // ISO 8859-6 (UNIX)

    {"ISO8859_7", "ISO-8859-7"},     // ISO 8859-7 (UNIX)

    {"ISO8859_8", "ISO-8859-8"},     // ISO 8859-8 (UNIX)

    {"ISO8859_9", "ISO-8859-9"},     // ISO 8859-9 (UNIX)

    {"PackedEUCJapaese", "EUC-JP"},  // UNIX, standard Japanese implementation.

    {"WindowsLatin1", "CP1252"},

    {"WindowsLatin2", "CP1250"},

    {"WindowsArabic", "CP1256"},

    {"WindowsCyrillic", "CP1251"},

    {"WindowsBalticRim", "CP1257"},

    {"WindowsGreek", "CP1253"},

    {"WindowsHebrew", "CP1255"},

    {"WindowsTurkish", "CP1254"},     // Windows Eastern Europe

    {"WindowsTradChinese", "CP950"},  // Windows Traditional Chinese

    {"WindowsSimpChinese", "CP936"},  // Windows Simplified Chinese

    {"WindowsJapanese", "CP932"},

    {"WindowsKorean", "CP949"},

    {"CodePage437", "CP437"},  // DOS Code Page 437 = IBM Extended ASCII

    {"CodePage850", "CP850"},  // DOS Code Page 850 = Multilingual

    {"CodePage852", "CP852"},  // DOS Code Page 852 = Eastern Europe

    {"CodePage855", "CP855"},  // DOS Code Page 855 = Cyrillic

    {"CodePage857", "CP857"},

    {"CodePage860", "CP860"},  // DOS Code Page 860 = Portuguese

    {"CodePage861", "CP861"},  // DOS Code Page 861 = Icelandic

    {"CodePage863", "CP863"},  // DOS Code Page 863 = French Canadian

    {"CodePage864", "CP864"},  // DOS Code Page 864 = Arabic

    {"CodePage865", "CP865"},  // DOS Code Page 865 = Nordic

    {"CodePage869", "CP869"},  // DOS Code Page 869 = Modern Greek

    {"LICS", ""},              // Lotus worksheet release 1,2 character set

    {"LMBCS", ""},             // Lotus worksheet release 3,4 character set

    {"UTF-8", "UTF-8"},

    {nullptr, nullptr}};

const char *IMapInfoFile::CharsetToEncoding(const char *pszCharset)

{

    if (pszCharset == nullptr)

    {

        return apszCharsets[0][1];

    }

    for (size_t i = 0; apszCharsets[i][0] != nullptr; ++i)

    {

        if (EQUAL(pszCharset, apszCharsets[i][0]))

        {

            return apszCharsets[i][1];

        }

    }

    CPLError(CE_Warning, CPLE_NotSupported,

             "Cannot find iconv encoding corresponding to MapInfo %s charset",

             pszCharset);

    return apszCharsets[0][1];

}

const char *IMapInfoFile::EncodingToCharset(const char *pszEncoding)

{

    if (pszEncoding == nullptr)

    {

        return apszCharsets[0][0];

    }

    for (size_t i = 0; apszCharsets[i][1] != nullptr; ++i)

    {

        if (EQUAL(pszEncoding, apszCharsets[i][1]))

        {

            return apszCharsets[i][0];

        }

    }

    CPLError(CE_Warning, CPLE_NotSupported,

             "Cannot find MapInfo charset corresponding to iconv %s encoding",

             pszEncoding);

    return apszCharsets[0][0];

}

const char *IMapInfoFile::GetEncoding() const

{

    return CharsetToEncoding(GetCharset());

}

void IMapInfoFile::SetEncoding(const char *pszEncoding)

{

    SetCharset(EncodingToCharset(pszEncoding));

}

void IMapInfoFile::SetStrictLaundering(bool bStrictLaundering)

{

    m_bStrictLaundering = bStrictLaundering;

}

int IMapInfoFile::TestUtf8Capability() const

{

    const char *pszEncoding(GetEncoding());

    if (strlen(pszEncoding) == 0)

    {

        return FALSE;

    }

    return CPLCanRecode("test", GetEncoding(), CPL_ENC_UTF8);

}

CPLString IMapInfoFile::NormalizeFieldName(const char *pszName) const

{

    CPLString osName(pszName);

    if (strlen(GetEncoding()) > 0)

        osName.Recode(CPL_ENC_UTF8, GetEncoding());

    char szNewFieldName[31 + 1]; /* 31 is the max characters for a field name*/

    unsigned int nRenameNum = 1;

    strncpy(szNewFieldName, osName.c_str(), sizeof(szNewFieldName) - 1);

    szNewFieldName[sizeof(szNewFieldName) - 1] = '\0';

    while (m_oSetFields.find(CPLString(szNewFieldName).toupper()) !=

               m_oSetFields.end() &&

           nRenameNum < 10)

    {

        CPLsnprintf(szNewFieldName, sizeof(szNewFieldName), "%.29s_%.1u",

                    osName.c_str(), nRenameNum);

        nRenameNum++;

    }

    while (m_oSetFields.find(CPLString(szNewFieldName).toupper()) !=

               m_oSetFields.end() &&

           nRenameNum < 100)

    {

        CPLsnprintf(szNewFieldName, sizeof(szNewFieldName), "%.29s%.2u",

                    osName.c_str(), nRenameNum);

        nRenameNum++;

    }

    if (m_oSetFields.find(CPLString(szNewFieldName).toupper()) !=

        m_oSetFields.end())

    {

        CPLError(CE_Failure, CPLE_NotSupported,

                 "Too many field names like '%s' when truncated to 31 letters "

                 "for MapInfo format.",

                 pszName);

    }

    CPLString osNewFieldName(szNewFieldName);

    if (strlen(GetEncoding()) > 0)

        osNewFieldName.Recode(GetEncoding(), CPL_ENC_UTF8);

    if (!EQUAL(pszName, osNewFieldName.c_str()))

    {

        CPLError(CE_Warning, CPLE_NotSupported,

                 "Normalized/laundered field name: '%s' to '%s'", pszName,

                 osNewFieldName.c_str());

    }

    return osNewFieldName;

}