/**
 * This file has no copyright assigned and is placed in the Public Domain.
 * This file has been copied from the mingw-w64 runtime package.
 */
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <stdlib.h>
#include "libgen.h"
#include <windows.h>

/* A 'directory separator' is a byte that equals 0x2F ('solidus' or more
 * commonly 'forward slash') or 0x5C ('reverse solidus' or more commonly
 * 'backward slash'). The byte 0x5C may look different from a backward slash
 * in some locales; for example, it looks the same as a Yen sign in Japanese
 * locales and a Won sign in Korean locales. Despite its appearance, it still
 * functions as a directory separator.
 *
 * A 'path' comprises an optional DOS drive letter with a colon, and then an
 * arbitrary number of possibily empty components, separated by non-empty
 * sequences of directory separators (in other words, consecutive directory
 * separators are treated as a single one). A path that comprises an empty
 * component denotes the current working directory.
 *
 * An 'absolute path' comprises at least two components, the first of which
 * is empty.
 *
 * A 'relative path' is a path that is not an absolute path. In other words,
 * it either comprises an empty component, or begins with a non-empty
 * component.
 *
 * POSIX doesn't have a concept about DOS drives. A path that does not have a
 * drive letter starts from the same drive as the current working directory.
 *
 * For example:
 * (Examples without drive letters match POSIX.)
 *
 *   Argument                 dirname() returns        basename() returns
 *   --------                 -----------------        ------------------
 *   `` or NULL               `.`                      `.`
 *   `usr`                    `.`                      `usr`
 *   `usr\`                   `.`                      `usr`
 *   `\`                      `\`                      `\`
 *   `\usr`                   `\`                      `usr`
 *   `\usr\lib`               `\usr`                   `lib`
 *   `\home\\dwc\\test`       `\home\\dwc`             `test`
 *   `\\host\usr`             `\\host\.`               `usr`
 *   `\\host\usr\lib`         `\\host\usr`             `lib`
 *   `\\host\\usr`            `\\host\\`               `usr`
 *   `\\host\\usr\lib`        `\\host\\usr`            `lib`
 *   `C:`                     `C:.`                    `.`
 *   `C:usr`                  `C:.`                    `usr`
 *   `C:usr\`                 `C:.`                    `usr`
 *   `C:\`                    `C:\`                    `\`
 *   `C:\\`                   `C:\`                    `\`
 *   `C:\\\`                  `C:\`                    `\`
 *   `C:\usr`                 `C:\`                    `usr`
 *   `C:\usr\lib`             `C:\usr`                 `lib`
 *   `C:\\usr\\lib\\`         `C:\\usr`                `lib`
 *   `C:\home\\dwc\\test`     `C:\home\\dwc`           `test`
 */

static
void
do_get_path_info(struct path_info* info, char* path)
{
    char* pos = path;
    int unc_ncoms = 0;
    DWORD cp;
    int dbcs_tb, prev_dir_sep, dir_sep;

    /* Get the code page for paths in the same way as `fopen()`.  */
    cp = AreFileApisANSI() ? CP_ACP : CP_OEMCP;

    /* Set the structure to 'no data'.  */
    info->prefix_end = NULL;
    info->base_sep_begin = NULL;
    // info->base_sep_end = NULL;
    info->term_sep_begin = NULL;

    if(IS_DIR_SEP(pos[0]) && IS_DIR_SEP(pos[1])) {
        /* The path is UNC.  */
        pos += 2;

        /* Seek to the end of the share/device name.  */
        dbcs_tb = 0;
        prev_dir_sep = 0;

        while(*pos != 0) {
            dir_sep = 0;

            if(dbcs_tb)
                dbcs_tb = 0;
            else if(IsDBCSLeadByteEx(cp, *pos))
                dbcs_tb = 1;
            else
                dir_sep = IS_DIR_SEP(*pos);

            /* If a separator has been encountered and the previous character
             * was not, mark this as the end of the current component.  */
            if(dir_sep && !prev_dir_sep) {
                unc_ncoms ++;

                /* The first component is the host name, and the second is the
                 * share name. So  we stop at the end of the second component.  */
                if(unc_ncoms == 2)
                    break;
            }

            prev_dir_sep = dir_sep;
            pos ++;
        }

        /* The UNC prefix terminates here. The terminating directory separator
         * is not part of the prefix, and initiates a new absolute path.  */
        info->prefix_end = pos;
    }
    else if((pos[0] >= 'A' && pos[0] <= 'Z' && pos[1] == ':')
        || (pos[0] >= 'a' && pos[0] <= 'z' && pos[1] == ':')) {
        /* The path contains a DOS drive letter in the beginning.  */
        pos += 2;

    /* The DOS drive prefix terminates here. Unlike UNC paths, the remaing
     * part can be relative. For example, `C:foo` denotes `foo` in the
     * working directory of drive `C:`.  */
    info->prefix_end = pos;
        }

        /* The remaining part of the path is almost the same as POSIX.  */
        dbcs_tb = 0;
        prev_dir_sep = 0;

        while(*pos != 0) {
            dir_sep = 0;

            if(dbcs_tb)
                dbcs_tb = 0;
            else if(IsDBCSLeadByteEx(cp, *pos))
                dbcs_tb = 1;
            else
                dir_sep = IS_DIR_SEP(*pos);

            /* If a separator has been encountered and the previous character
             * was not, mark this as the beginning of the terminating separator
             * sequence.  */
            if(dir_sep && !prev_dir_sep)
                info->term_sep_begin = pos;

            /* If a non-separator character has been encountered and a previous
             * terminating separator sequence exists, start a new component.  */
            if(!dir_sep && prev_dir_sep) {
                info->base_sep_begin = info->term_sep_begin;
                info->base_sep_end = pos;
                info->term_sep_begin = NULL;
            }

            prev_dir_sep = dir_sep;
            pos ++;
        }

        /* Store the end of the path for convenience.  */
        info->path_end = pos;
}

char*
dirname(char* path)
{
    struct path_info info;
    char* upath;
    const char* top;
    static char* static_path_copy;

    if(path == NULL || path[0] == 0)
        return (char*) ".";

    do_get_path_info(&info, path);
    upath = info.prefix_end ? info.prefix_end : path;
    top = (IS_DIR_SEP(path[0]) || IS_DIR_SEP(upath[0])) ? "\\" : ".";

    /* If a non-terminating directory separator exists, it terminates the
     * dirname. Truncate the path there.  */
    if(info.base_sep_begin) {
        info.base_sep_begin[0] = 0;

        /* If the unprefixed path has not been truncated to empty, it is now
         * the dirname, so return it.  */
        if(upath[0])
            return path;
    }

    /* The dirname is empty. In principle we return `<prefix>.` if the
     * path is relative and `<prefix>\` if it is absolute. This can be
     * optimized if there is no prefix.  */
    if(upath == path)
        return (char*) top;

    /* When there is a prefix, we must append a character to the prefix.
     * If there is enough room in the original path, we just reuse its
     * storage.  */
    if(upath != info.path_end) {
        upath[0] = *top;
        upath[1] = 0;
        return path;
    }

    /* This is only the last resort. If there is no room, we have to copy
     * the prefix elsewhere.  */
    upath = realloc(static_path_copy, info.prefix_end - path + 2);
    if(!upath)
        return (char*) top;

    static_path_copy = upath;
    memcpy(upath, path, info.prefix_end - path);
    upath += info.prefix_end - path;
    upath[0] = *top;
    upath[1] = 0;
    return static_path_copy;
}

char*
basename(char* path)
{
    struct path_info info;
    char* upath;

    if(path == NULL || path[0] == 0)
        return (char*) ".";

    do_get_path_info(&info, path);
    upath = info.prefix_end ? info.prefix_end : path;

    /* If the path is non-UNC and empty, then it's relative. POSIX says '.'
     * shall be returned.  */
    if(IS_DIR_SEP(path[0]) == 0 && upath[0] == 0)
        return (char*) ".";

    /* If a terminating separator sequence exists, it is not part of the
     * name and shall be truncated.  */
    if(info.term_sep_begin)
        info.term_sep_begin[0] = 0;

    /* If some other separator sequence has been found, the basename
     * immediately follows it.  */
    if(info.base_sep_end)
        return info.base_sep_end;

    /* If removal of the terminating separator sequence has caused the
     * unprefixed path to become empty, it must have comprised only
     * separators. POSIX says `/` shall be returned, but on Windows, we
     * return `\` instead.  */
    if(upath[0] == 0)
        return (char*) "\\";

    /* Return the unprefixed path.  */
    return upath;
}
