/**********************************************************************
 *
 * Name:     mitab_utils.cpp
 * Project:  MapInfo TAB Read/Write library
 * Language: C++
 * Purpose:  Misc. util. functions for the library
 * Author:   Daniel Morissette, dmorissette@dmsolutions.ca
 *
 **********************************************************************
 * Copyright (c) 1999-2001, Daniel Morissette
 *
 * SPDX-License-Identifier: MIT
 **********************************************************************/

#include "cpl_port.h"
#include "mitab_utils.h"

#include <cctype>
#include <climits>
#include <cmath>
#include <cstring>
#include <limits>

#include "mitab.h"
#include "cpl_conv.h"
#include "cpl_error.h"
#include "cpl_string.h"
#include "cpl_vsi.h"

/**********************************************************************
 *                       TABGenerateArc()
 *
 * Generate the coordinates for an arc and ADD the coordinates to the
 * geometry object.  If the geometry already contains some points then
 * these won't be lost.
 *
 * poLine can be a OGRLineString or one of its derived classes, such as
 *        OGRLinearRing
 * numPoints is the number of points to generate.
 * Angles are specified in radians, valid values are in the range [0..2*PI]
 *
 * Arcs are always generated counterclockwise, even if StartAngle > EndAngle
 *
 * Returns 0 on success, -1 on error.
 **********************************************************************/
int TABGenerateArc(OGRLineString *poLine, int numPoints, double dCenterX,
                   double dCenterY, double dXRadius, double dYRadius,
                   double dStartAngle, double dEndAngle)
{
    // Adjust angles to go counterclockwise
    if (dEndAngle < dStartAngle)
        dEndAngle += 2.0 * M_PI;

    const double dAngleStep = (dEndAngle - dStartAngle) / (numPoints - 1.0);

    double dAngle = 0.0;
    for (int i = 0; i < numPoints; i++)
    {
        dAngle = dStartAngle + i * dAngleStep;
        const double dX = dCenterX + dXRadius * cos(dAngle);
        const double dY = dCenterY + dYRadius * sin(dAngle);
        poLine->addPoint(dX, dY);
    }

    // Complete the arc with the last EndAngle, to make sure that
    // the arc is correctly closed.
    const double dX = dCenterX + dXRadius * cos(dAngle);
    const double dY = dCenterY + dYRadius * sin(dAngle);
    poLine->addPoint(dX, dY);

    return 0;
}

/**********************************************************************
 *                       TABCloseRing()
 *
 * Check if a ring is closed, and add a point to close it if necessary.
 *
 * Returns 0 on success, -1 on error.
 **********************************************************************/
int TABCloseRing(OGRLineString *poRing)
{
    if (poRing->getNumPoints() > 0 && !poRing->get_IsClosed())
    {
        poRing->addPoint(poRing->getX(0), poRing->getY(0));
    }

    return 0;
}

/**********************************************************************
 *                     TABAdjustCaseSensitiveFilename()
 *
 * Scan a filename and its path, adjust uppercase/lowercases if
 * necessary.
 *
 * Returns TRUE if file found, or FALSE if it could not be located with
 * a case-insensitive search.
 *
 * This function works on the original buffer and returns a reference to it.
 * It does nothing on Windows systems where filenames are not case sensitive.
 **********************************************************************/
#ifdef _WIN32
static bool TABAdjustCaseSensitiveFilename(char * /* pszFname */)
{
    // Nothing to do on Windows.
    return true;
}
#else
// Unix case.
static bool TABAdjustCaseSensitiveFilename(char *pszFname)
{
    VSIStatBufL sStatBuf;

    // First check if the filename is OK as is.
    if (VSIStatL(pszFname, &sStatBuf) == 0)
    {
        return true;
    }

    // File either does not exist or has the wrong cases.
    // Go backwards until we find a portion of the path that is valid.
    char *pszTmpPath = CPLStrdup(pszFname);
    const int nTotalLen = static_cast<int>(strlen(pszTmpPath));
    int iTmpPtr = nTotalLen;
    bool bValidPath = false;

    while (iTmpPtr > 0 && !bValidPath)
    {
        // Move back to the previous '/' separator.
        pszTmpPath[--iTmpPtr] = '\0';
        while (iTmpPtr > 0 && pszTmpPath[iTmpPtr - 1] != '/')
        {
            pszTmpPath[--iTmpPtr] = '\0';
        }

        if (iTmpPtr > 0 && VSIStatL(pszTmpPath, &sStatBuf) == 0)
            bValidPath = true;
    }

    CPLAssert(iTmpPtr >= 0);

    // Assume that CWD is valid.  Therefore an empty path is a valid.
    if (iTmpPtr == 0)
        bValidPath = true;

    // Now that we have a valid base, reconstruct the whole path
    // by scanning all the sub-directories.
    // If we get to a point where a path component does not exist then
    // we simply return the rest of the path as is.
    while (bValidPath && static_cast<int>(strlen(pszTmpPath)) < nTotalLen)
    {
        int iLastPartStart = iTmpPtr;
        char **papszDir = VSIReadDir(pszTmpPath);

        // Add one component to the current path.
        pszTmpPath[iTmpPtr] = pszFname[iTmpPtr];
        iTmpPtr++;
        for (; pszFname[iTmpPtr] != '\0' && pszFname[iTmpPtr] != '/'; iTmpPtr++)
        {
            pszTmpPath[iTmpPtr] = pszFname[iTmpPtr];
        }

        while (iLastPartStart < iTmpPtr && pszTmpPath[iLastPartStart] == '/')
            iLastPartStart++;

        // And do a case insensitive search in the current dir.
        for (int iEntry = 0; papszDir && papszDir[iEntry]; iEntry++)
        {
            if (EQUAL(pszTmpPath + iLastPartStart, papszDir[iEntry]))
            {
                // Fount it.
                strcpy(pszTmpPath + iLastPartStart, papszDir[iEntry]);
                break;
            }
        }

        if (iTmpPtr > 0 && VSIStatL(pszTmpPath, &sStatBuf) != 0)
            bValidPath = false;

        CSLDestroy(papszDir);
    }

    // We reached the last valid path component... just copy the rest
    // of the path as is.
    if (iTmpPtr < nTotalLen - 1)
    {
        strncpy(pszTmpPath + iTmpPtr, pszFname + iTmpPtr, nTotalLen - iTmpPtr);
    }

    // Update the source buffer and return.
    strcpy(pszFname, pszTmpPath);
    CPLFree(pszTmpPath);

    return bValidPath;
}
#endif  // Not win32.

/**********************************************************************
 *                       TABAdjustFilenameExtension()
 *
 * Because Unix filenames are case sensitive and MapInfo datasets often have
 * mixed cases filenames, we use this function to find the right filename
 * to use to open a specific file.
 *
 * This function works directly on the source string, so the filename it
 * contains at the end of the call is the one that should be used.
 *
 * Returns TRUE if one of the extensions worked, and FALSE otherwise.
 * If none of the extensions worked then the original extension will NOT be
 * restored.
 **********************************************************************/
GBool TABAdjustFilenameExtension(char *pszFname)
{
    VSIStatBufL sStatBuf;

    // First try using filename as provided
    if (VSIStatL(pszFname, &sStatBuf) == 0)
    {
        return TRUE;
    }

    // Try using uppercase extension (we assume that fname contains a '.')
    for (int i = static_cast<int>(strlen(pszFname)) - 1;
         i >= 0 && pszFname[i] != '.'; i--)
    {
        pszFname[i] = static_cast<char>(
            CPLToupper(static_cast<unsigned char>(pszFname[i])));
    }

    if (VSIStatL(pszFname, &sStatBuf) == 0)
    {
        return TRUE;
    }

    // Try using lowercase extension.
    for (int i = static_cast<int>(strlen(pszFname)) - 1;
         i >= 0 && pszFname[i] != '.'; i--)
    {
        pszFname[i] = static_cast<char>(
            CPLTolower(static_cast<unsigned char>(pszFname[i])));
    }

    if (VSIStatL(pszFname, &sStatBuf) == 0)
    {
        return TRUE;
    }

    // None of the extensions worked.
    // Try adjusting cases in the whole path and filename.
    return TABAdjustCaseSensitiveFilename(pszFname);
}

/**********************************************************************
 *                       TABGetBasename()
 *
 * Extract the basename part of a complete file path.
 *
 * Returns a newly allocated string without the leading path (dirs) and
 * the extension.  The returned string should be freed using CPLFree().
 **********************************************************************/
char *TABGetBasename(const char *pszFname)
{
    // Skip leading path or use whole name if no path dividers are encountered.
    const char *pszTmp = pszFname + strlen(pszFname) - 1;
    while (pszTmp != pszFname && *pszTmp != '/' && *pszTmp != '\\')
        pszTmp--;

    if (pszTmp != pszFname)
        pszTmp++;

    // Now allocate our own copy and remove extension.
    char *pszBasename = CPLStrdup(pszTmp);
    for (int i = static_cast<int>(strlen(pszBasename)) - 1; i >= 0; i--)
    {
        if (pszBasename[i] == '.')
        {
            pszBasename[i] = '\0';
            break;
        }
    }

    return pszBasename;
}

/**********************************************************************
 *                       TAB_CSLLoad()
 *
 * Same as CSLLoad(), but does not produce an error if it fails... it
 * just returns NULL silently instead.
 *
 * Load a test file into a stringlist.
 *
 * Lines are limited in length by the size of the CPLReadLine() buffer.
 **********************************************************************/
char **TAB_CSLLoad(const char *pszFname)
{
    CPLStringList oList;

    VSILFILE *fp = VSIFOpenL(pszFname, "rt");

    if (fp)
    {
        while (const char *pszLine = CPLReadLineL(fp))
        {
            oList.AddString(pszLine);
        }

        VSIFCloseL(fp);
    }

    return oList.StealList();
}

/**********************************************************************
 *                       TABUnEscapeString()
 *
 * Convert a string that can possibly contain escaped "\n" chars in
 * into into a new one with binary newlines in it.
 *
 * Tries to work on the original buffer unless bSrcIsConst=TRUE, in
 * which case the original is always untouched and a copy is allocated
 * ONLY IF NECESSARY.  This means that the caller should compare the
 * return value and the source (pszString) to see if a copy was returned,
 * in which case the caller becomes responsible of freeing both the
 * source and the copy.
 **********************************************************************/
char *TABUnEscapeString(char *pszString, GBool bSrcIsConst)
{
    // First check if we need to do any replacement.
    if (pszString == nullptr || strstr(pszString, "\\n") == nullptr)
    {
        return pszString;
    }

    // Yes, we need to replace at least one "\n".
    // We try to work on the original buffer unless we have bSrcIsConst=TRUE.
    //
    // Note that we do not worry about freeing the source buffer when we
    // return a copy.  It is up to the caller to decide if the source needs
    // to be freed based on context and by comparing pszString with
    // the returned pointer (pszWorkString) to see if they are identical.
    char *pszWorkString = nullptr;
    if (bSrcIsConst)
    {
        // We have to create a copy to work on.
        pszWorkString = static_cast<char *>(
            CPLMalloc(sizeof(char) * (strlen(pszString) + 1)));
    }
    else
    {
        // Work on the original.
        pszWorkString = pszString;
    }

    int i = 0;
    int j = 0;
    while (pszString[i])
    {
        if (pszString[i] == '\\' && pszString[i + 1] == 'n')
        {
            pszWorkString[j++] = '\n';
            i += 2;
        }
        else if (pszString[i] == '\\' && pszString[i + 1] == '\\')
        {
            pszWorkString[j++] = '\\';
            i += 2;
        }
        else
        {
            pszWorkString[j++] = pszString[i++];
        }
    }
    pszWorkString[j++] = '\0';

    return pszWorkString;
}

/**********************************************************************
 *                       TABEscapeString()
 *
 * Convert a string that can possibly contain binary "\n" chars in
 * into into a new one with escaped newlines ("\\" + "n") in it.
 *
 * The function returns the original string pointer if it did not need to
 * be modified, or a copy that has to be freed by the caller if the
 * string had to be modified.
 *
 * It is up to the caller to decide if the returned string needs to be
 * freed by comparing the source (pszString) pointer with the returned
 * pointer (pszWorkString) to see if they are identical.
 **********************************************************************/
char *TABEscapeString(char *pszString)
{
    // First check if we need to do any replacement
    if (pszString == nullptr || strchr(pszString, '\n') == nullptr)
    {
        return pszString;
    }

    // Need to do some replacements.  Alloc a copy big enough
    // to hold the worst possible case.
    char *pszWorkString = static_cast<char *>(
        CPLMalloc(2 * sizeof(char) * (strlen(pszString) + 1)));

    int i = 0;
    int j = 0;

    while (pszString[i])
    {
        if (pszString[i] == '\n')
        {
            pszWorkString[j++] = '\\';
            pszWorkString[j++] = 'n';
            i++;
        }
        else if (pszString[i] == '\\')
        {
            pszWorkString[j++] = '\\';
            pszWorkString[j++] = '\\';
            i++;
        }
        else
        {
            pszWorkString[j++] = pszString[i++];
        }
    }
    pszWorkString[j++] = '\0';

    return pszWorkString;
}

/**********************************************************************
 *                       TABCleanFieldName()
 *
 * Return a copy of pszSrcName that contains only valid characters for a
 * TAB field name.  All invalid characters are replaced by '_'.
 *
 * The returned string should be freed by the caller.
 **********************************************************************/
char *TABCleanFieldName(const char *pszSrcName, const char *pszEncoding,
                        bool bStrictLaundering)
{
    char *pszNewName = CPLStrdup(pszSrcName);
    int numInvalidChars = 0;

    if (bStrictLaundering)
    {
        if (strlen(pszNewName) > 31)
        {
            pszNewName[31] = '\0';
            CPLError(CE_Warning,
                     static_cast<CPLErrorNum>(TAB_WarningInvalidFieldName),
                     "Field name '%s' is longer than the max of 31 characters. "
                     "'%s' will be used instead.",
                     pszSrcName, pszNewName);
        }

        // According to the MapInfo User's Guide (p. 240, v5.5).
        // New Table Command:
        //  Name:
        // Displays the field name in the name box. You can also enter new field
        // names here. Defaults are Field1, Field2, etc. A field name can contain
        // up to 31 alphanumeric characters. Use letters, numbers, and the
        // underscore. Do not use spaces; instead, use the underscore character
        // (_) to separate words in a field name. Use upper and lower case for
        // legibility, but MapInfo is not case-sensitive.
        //
        // It was also verified that extended chars with accents are also
        // accepted.
        bool bNeutralCharset =
            (pszEncoding == nullptr || strlen(pszEncoding) == 0);
        for (int i = 0; pszSrcName && pszSrcName[i] != '\0'; i++)
        {
            if (pszSrcName[i] == '#')
            {
                if (i == 0)
                {
                    pszNewName[i] = '_';
                    numInvalidChars++;
                }
            }
            else if (!(pszSrcName[i] == '_' ||
                       (i != 0 && pszSrcName[i] >= '0' &&
                        pszSrcName[i] <= '9') ||
                       (!bNeutralCharset ||
                        ((pszSrcName[i] >= 'a' && pszSrcName[i] <= 'z') ||
                         (pszSrcName[i] >= 'A' && pszSrcName[i] <= 'Z') ||
                         static_cast<GByte>(pszSrcName[i]) >= 192))))
            {
                pszNewName[i] = '_';
                numInvalidChars++;
            }
        }
    }
    else
    {
        // There is a note at mapinfo-pro-v2021-user-guide.pdf
        // (p. 1425, Columns section: "Field names cannot have spaces".
        // There seem to be no other constraints.
        for (int i = 0; pszSrcName && pszSrcName[i] != '\0'; i++)
        {
            if (pszSrcName[i] == ' ')
            {
                pszNewName[i] = '_';
                numInvalidChars++;
            }
        }
    }
    if (numInvalidChars > 0)
    {
        CPLError(CE_Warning,
                 static_cast<CPLErrorNum>(TAB_WarningInvalidFieldName),
                 "Field name '%s' contains invalid characters. "
                 "'%s' will be used instead.",
                 pszSrcName, pszNewName);
    }

    return pszNewName;
}

/**********************************************************************
 *                       TABSaturatedAdd()
 ***********************************************************************/

void TABSaturatedAdd(GInt32 &nVal, GInt32 nAdd)
{
    const GInt32 int_max = std::numeric_limits<GInt32>::max();
    const GInt32 int_min = std::numeric_limits<GInt32>::min();

    if (nAdd >= 0 && nVal > int_max - nAdd)
        nVal = int_max;
    else if (nAdd == int_min && nVal < 0)
        nVal = int_min;
    else if (nAdd != int_min && nAdd < 0 && nVal < int_min - nAdd)
        nVal = int_min;
    else
        nVal += nAdd;
}

/**********************************************************************
 *                           TABInt16Diff()
 **********************************************************************/

GInt16 TABInt16Diff(int a, int b)
{
    GIntBig nDiff = static_cast<GIntBig>(a) - b;
    // Maybe we should error out instead of saturating ???
    if (nDiff < -32768)
        return -32768;
    if (nDiff > 32767)
        return 32767;
    return static_cast<GInt16>(nDiff);
}
