/******************************************************************************
 * Project:  PROJ.4
 * Purpose:  This is primarily material originating from pj_obs_api.c
 *           (now proj_4D_api.c), that does not fit into the API
 *           category. Hence this pile of tubings and fittings for
 *           PROJ.4 internal plumbing.
 *
 * Author:   Thomas Knudsen,  thokn@sdfe.dk,  2017-07-05
 *
 ******************************************************************************
 * Copyright (c) 2016, 2017, 2018, Thomas Knudsen/SDFE
 *
 * 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.
 *****************************************************************************/

#define FROM_PROJ_CPP

#include <ctype.h>
#include <errno.h>
#include <math.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>

#include "geodesic.h"
#include "proj_internal.h"

#include "proj/internal/internal.hpp"

using namespace NS_PROJ::internal;

enum pj_io_units pj_left (PJ *P) {
    enum pj_io_units u = P->inverted? P->right: P->left;
    if (u==PJ_IO_UNITS_CLASSIC)
        return PJ_IO_UNITS_PROJECTED;
    return u;
}

enum pj_io_units pj_right (PJ *P) {
    enum pj_io_units u = P->inverted? P->left: P->right;
    if (u==PJ_IO_UNITS_CLASSIC)
        return PJ_IO_UNITS_PROJECTED;
    return u;
}


/* Work around non-constness of MSVC HUGE_VAL by providing functions rather than constants */
PJ_COORD proj_coord_error (void) {
    PJ_COORD c;
    c.v[0] = c.v[1] = c.v[2] = c.v[3] = HUGE_VAL;
    return c;
}



/**************************************************************************************/
PJ_COORD pj_approx_2D_trans (PJ *P, PJ_DIRECTION direction, PJ_COORD coo) {
/***************************************************************************************
Behave mostly as proj_trans, but attempt to use 2D interfaces only.
Used in gie.c, to enforce testing 2D code, and by PJ_pipeline.c to implement
chained calls starting out with a call to its 2D interface.
***************************************************************************************/
    if (nullptr==P)
        return coo;
    if (P->inverted)
        direction = static_cast<PJ_DIRECTION>(-direction);
    switch (direction) {
        case PJ_FWD:
        {
            const auto xy = pj_fwd (coo.lp, P);
            coo.xy = xy;
            return coo;
        }
        case PJ_INV:
        {
            const auto lp = pj_inv (coo.xy, P);
            coo.lp = lp;
            return coo;
        }
        case PJ_IDENT:
            break;
    }
    return coo;
}


/**************************************************************************************/
PJ_COORD pj_approx_3D_trans (PJ *P, PJ_DIRECTION direction, PJ_COORD coo) {
/***************************************************************************************
Companion to pj_approx_2D_trans.

Behave mostly as proj_trans, but attempt to use 3D interfaces only.
Used in gie.c, to enforce testing 3D code, and by PJ_pipeline.c to implement
chained calls starting out with a call to its 3D interface.
***************************************************************************************/
    if (nullptr==P)
        return coo;
    if (P->inverted)
        direction = static_cast<PJ_DIRECTION>(-direction);
    switch (direction) {
        case PJ_FWD:
        {
            const auto xyz = pj_fwd3d (coo.lpz, P);
            coo.xyz = xyz;
            return coo;
        }
        case PJ_INV:
        {
            const auto lpz = pj_inv3d (coo.xyz, P);
            coo.lpz = lpz;
            return coo;
        }
        case PJ_IDENT:
            break;
    }
    return coo;
}

/**************************************************************************************/
int pj_has_inverse(PJ *P) {
/***************************************************************************************
Check if a a PJ has an inverse.
***************************************************************************************/
    return ( (P->inverted && (P->fwd || P->fwd3d || P->fwd4d) ) ||
             ( P->inv || P->inv3d || P->inv4d) );
}


/* Move P to a new context - or to the default context if 0 is specified */
void proj_context_set (PJ *P, PJ_CONTEXT *ctx) {
    if (nullptr==ctx)
        ctx = pj_get_default_ctx ();
    proj_assign_context (P, ctx);
}


void proj_context_inherit (PJ *parent, PJ *child) {
    if (nullptr==parent)
        proj_assign_context (child, pj_get_default_ctx());
    else
        proj_assign_context (child, pj_get_ctx(parent));
}



/*****************************************************************************/
char *pj_chomp (char *c) {
/******************************************************************************
Strip pre- and postfix whitespace. Inline comments (indicated by '#') are
considered whitespace.
******************************************************************************/
    size_t i, n;
    char *comment;
    char *start = c;

    if (nullptr==c)
        return nullptr;

    comment = strchr (c, '#');
    if (comment)
        *comment = 0;

    n = strlen (c);
    if (0==n)
        return c;

    /* Eliminate postfix whitespace */
    for (i = n - 1;  (i > 0) && (isspace (c[i]) || ';'==c[i]);  i--)
        c[i] = 0;

    /* Find start of non-whitespace */
    while (0 != *start  &&  (';'==*start  ||  isspace (*start)))
        start++;

    n = strlen (start);
    if (0==n) {
        c[0] = 0;
        return c;
    }

    memmove (c, start, n + 1);
    return c;
}



/*****************************************************************************/
char *pj_shrink (char *c) {
/******************************************************************************
Collapse repeated whitespace. Remove '+' and ';'. Make ',' and '=' greedy,
consuming their surrounding whitespace.
******************************************************************************/
    size_t i, j, n;

    /* Flag showing that a whitespace (ws) has been written after last non-ws */
    bool ws = false;

    if (nullptr==c)
       return nullptr;

    pj_chomp (c);
    n = strlen (c);
    if (n==0)
        return c;

    /* First collapse repeated whitespace (including +/;) */
    i = 0;
    bool in_string = false;
    for (j = 0;  j < n;  j++) {

        if( in_string ) {
            if( c[j] == '"' && c[j+1] == '"' ) {
                c[i++] = c[j];
                j++;
            } else if( c[j] == '"' ) {
                in_string = false;
            }
            c[i++] = c[j];
            continue;
        }

        /* Eliminate prefix '+', only if preceded by whitespace */
        /* (i.e. keep it in 1.23e+08) */
        if ((i > 0) && ('+'==c[j]) && ws)
            c[j] = ' ';
        if ((i==0) && ('+'==c[j]))
            c[j] = ' ';

        // Detect a string beginning after '='
        if( c[j] == '"' && i > 0 && c[i-1] == '=' ) {
            in_string = true;
            ws = false;
            c[i++] = c[j];
            continue;
        }

        if (isspace (c[j]) || ';'==c[j]) {
            if (false==ws && (i > 0))
                c[i++] = ' ';
            ws = true;
            continue;
        }
        else {
            ws = false;
            c[i++] = c[j];
        }
    }
    c[i] = 0;
    n = strlen(c);

    /* Then make ',' and '=' greedy */
    i = 0;
    for (j = 0;  j < n;  j++) {
        if (i==0) {
            c[i++] = c[j];
            continue;
        }

        /* Skip space before '='/',' */
        if ('='==c[j] || ','==c[j]) {
            if (c[i - 1]==' ')
               c[i - 1] = c[j];
            else
                c[i++] = c[j];
            continue;
        }

        if (' '==c[j] && ('='==c[i - 1] || ','==c[i - 1]) )
            continue;

        c[i++] = c[j];
    }
    c[i] = 0;
    return c;
}



/*****************************************************************************/
size_t pj_trim_argc (char *args) {
/******************************************************************************
Trim all unnecessary whitespace (and non-essential syntactic tokens) from the
argument string, args, and count its number of elements.
******************************************************************************/
    size_t i, m, n;
    pj_shrink (args);
    n = strlen (args);
    if (n==0)
        return 0;
    bool in_string = false;
    for (i = m = 0;  i < n;  i++) {
        if (in_string ) {
            if( args[i] == '"' && args[i+1] == '"' ) {
                i++;
            } else if( args[i] == '"' ) {
                in_string = false;
            }
        }
        else if (args[i] == '=' && args[i+1] == '"' ) {
            i++;
            in_string = true;
        }
        else if (' '==args[i]) {
            args[i] = 0;
            m++;
        }
    }
    return m + 1;
}


static void unquote_string(char* param_str) {

    size_t len = strlen(param_str);
    // Remove leading and terminating spaces after equal sign
    const char* equal = strstr(param_str, "=\"");
    if( equal && equal - param_str + 1 >= 2 && param_str[len-1] == '"' ) {
        size_t dst = equal + 1 - param_str;
        size_t src = dst + 1;
        for( ; param_str[src]; dst++, src++)
        {
            if( param_str[src] == '"' ) {
                if( param_str[src+1] == '"' ) {
                    src++;
                } else {
                    break;
                }
            }
            param_str[dst] = param_str[src];
        }
        param_str[dst] = '\0';
    }

}



/*****************************************************************************/
char **pj_trim_argv (size_t argc, char *args) {
/******************************************************************************
Create an argv-style array from elements placed in the argument string, args.

args is a trimmed string as returned by pj_trim_argc(), and argc is the number
of trimmed strings found (i.e. the return value of pj_trim_args()). Hence,
    int argc    = pj_trim_argc (args);
    char **argv = pj_trim_argv (argc, args);
will produce a classic style (argc, argv) pair from a string of whitespace
separated args. No new memory is allocated for storing the individual args
(they stay in the args string), but for the pointers to the args a new array
is allocated and returned.

It is the duty of the caller to free this array.
******************************************************************************/

    if (nullptr==args)
        return nullptr;
    if (0==argc)
        return nullptr;

    /* turn the input string into an array of strings */
    char** argv = (char **) calloc (argc, sizeof (char *));
    if (nullptr==argv)
        return nullptr;
    for(size_t i = 0, j = 0; j < argc; j++) {
        argv[j] = args + i;
        char* str = argv[j];
        size_t nLen = strlen(str);
        i += nLen + 1;
        unquote_string(str);
    }
    return argv;
}


/*****************************************************************************/
std::string pj_double_quote_string_param_if_needed(const std::string& str) {
/*****************************************************************************/
    if( str.find(' ') == std::string::npos ) {
        return str;
    }
    std::string ret;
    ret += '"';
    ret += replaceAll(str, "\"", "\"\"");
    ret += '"';
    return ret;
}

/*****************************************************************************/
char *pj_make_args (size_t argc, char **argv) {
/******************************************************************************
pj_make_args is the inverse of the pj_trim_argc/pj_trim_argv combo: It
converts free format command line input to something proj_create can consume.

Allocates, and returns, an array of char, large enough to hold a whitespace
separated copy of the args in argv. It is the duty of the caller to free this
array.
******************************************************************************/
    try
    {
        std::string s;
        for( size_t i = 0; i < argc; i++ )
        {
            const char* equal = strchr(argv[i], '=');
            if( equal ) {
                s += std::string(argv[i], equal - argv[i] + 1);
                s += pj_double_quote_string_param_if_needed(equal + 1);
            } else {
                s += argv[i];
            }
            s += ' ';
        }

        char* p = pj_strdup(s.c_str());
        return pj_shrink (p);
    }
    catch( const std::exception& ) {
        return nullptr;
    }
}



/*****************************************************************************/
void proj_context_errno_set (PJ_CONTEXT *ctx, int err) {
/******************************************************************************
Raise an error directly on a context, without going through a PJ belonging
to that context.
******************************************************************************/
    if (nullptr==ctx)
        ctx = pj_get_default_ctx();
    ctx->last_errno = err;
    if( err == 0 )
        return;
    errno = err;
}
