//========================================================================
//
// UnicodeMap.cc
//
// Copyright 2001-2003 Glyph & Cog, LLC
//
//========================================================================

//========================================================================
//
// Modified under the Poppler project - http://poppler.freedesktop.org
//
// All changes made under the Poppler project to this file are licensed
// under GPL version 2 or later
//
// Copyright (C) 2010 Jakub Wilk <jwilk@jwilk.net>
// Copyright (C) 2017-2020 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2017 Adrian Johnson <ajohnson@redneon.com>
// Copyright (C) 2017 Jean Ghali <jghali@libertysurf.fr>
// Copyright (C) 2018 Adam Reichold <adam.reichold@t-online.de>
// Copyright (C) 2019 Oliver Sander <oliver.sander@tu-dresden.de>
// Copyright (C) 2019 Volker Krause <vkrause@kde.org>
//
// To see a description of the changes please see the Changelog file that
// came with your tarball or type make ChangeLog if you are building from git
//
//========================================================================

#include <config.h>

#include <cstdio>
#include <cstring>
#include "goo/glibc.h"
#include "goo/gmem.h"
#include "goo/gfile.h"
#include "goo/GooString.h"
#include "Error.h"
#include "GlobalParams.h"
#include "UnicodeMap.h"

//------------------------------------------------------------------------

#define maxExtCode 16

struct UnicodeMapExt
{
    Unicode u; // Unicode char
    char code[maxExtCode];
    unsigned int nBytes;
};

//------------------------------------------------------------------------

UnicodeMap *UnicodeMap::parse(const std::string &encodingNameA)
{
    FILE *f;
    UnicodeMap *map;
    UnicodeMapRange *range;
    UnicodeMapExt *eMap;
    int size, eMapsSize;
    char buf[256];
    int line, nBytes, i;
    char *tok1, *tok2, *tok3;
    char *tokptr;

    if (!(f = globalParams->getUnicodeMapFile(encodingNameA))) {
        error(errSyntaxError, -1, "Couldn't find unicodeMap file for the '{0:s}' encoding", encodingNameA.c_str());
        return nullptr;
    }

    map = new UnicodeMap(encodingNameA);

    size = 8;
    UnicodeMapRange *customRanges = (UnicodeMapRange *)gmallocn(size, sizeof(UnicodeMapRange));
    eMapsSize = 0;

    line = 1;
    while (getLine(buf, sizeof(buf), f)) {
        if ((tok1 = strtok_r(buf, " \t\r\n", &tokptr)) && (tok2 = strtok_r(nullptr, " \t\r\n", &tokptr))) {
            if (!(tok3 = strtok_r(nullptr, " \t\r\n", &tokptr))) {
                tok3 = tok2;
                tok2 = tok1;
            }
            nBytes = strlen(tok3) / 2;
            if (nBytes <= 4) {
                if (map->len == size) {
                    size *= 2;
                    customRanges = (UnicodeMapRange *)greallocn(customRanges, size, sizeof(UnicodeMapRange));
                }
                range = &customRanges[map->len];
                sscanf(tok1, "%x", &range->start);
                sscanf(tok2, "%x", &range->end);
                sscanf(tok3, "%x", &range->code);
                range->nBytes = nBytes;
                ++map->len;
            } else if (tok2 == tok1) {
                if (map->eMapsLen == eMapsSize) {
                    eMapsSize += 16;
                    map->eMaps = (UnicodeMapExt *)greallocn(map->eMaps, eMapsSize, sizeof(UnicodeMapExt));
                }
                eMap = &map->eMaps[map->eMapsLen];
                sscanf(tok1, "%x", &eMap->u);
                for (i = 0; i < nBytes; ++i) {
                    unsigned int x;
                    sscanf(tok3 + i * 2, "%2x", &x);
                    eMap->code[i] = (char)x;
                }
                eMap->nBytes = nBytes;
                ++map->eMapsLen;
            } else {
                error(errSyntaxError, -1, "Bad line ({0:d}) in unicodeMap file for the '{1:s}' encoding", line, encodingNameA.c_str());
            }
        } else {
            error(errSyntaxError, -1, "Bad line ({0:d}) in unicodeMap file for the '{1:s}' encoding", line, encodingNameA.c_str());
        }
        ++line;
    }

    fclose(f);

    map->ranges = customRanges;
    return map;
}

UnicodeMap::UnicodeMap(const std::string &encodingNameA)
{
    encodingName = encodingNameA;
    unicodeOut = false;
    kind = unicodeMapUser;
    ranges = nullptr;
    len = 0;
    eMaps = nullptr;
    eMapsLen = 0;
}

UnicodeMap::UnicodeMap(const char *encodingNameA, bool unicodeOutA, const UnicodeMapRange *rangesA, int lenA)
{
    encodingName = encodingNameA;
    unicodeOut = unicodeOutA;
    kind = unicodeMapResident;
    ranges = rangesA;
    len = lenA;
    eMaps = nullptr;
    eMapsLen = 0;
}

UnicodeMap::UnicodeMap(const char *encodingNameA, bool unicodeOutA, UnicodeMapFunc funcA)
{
    encodingName = encodingNameA;
    unicodeOut = unicodeOutA;
    kind = unicodeMapFunc;
    func = funcA;
    eMaps = nullptr;
    eMapsLen = 0;
}

UnicodeMap::~UnicodeMap()
{
    if (kind == unicodeMapUser && ranges) {
        gfree(const_cast<UnicodeMapRange *>(ranges));
    }
    if (eMaps) {
        gfree(eMaps);
    }
}

UnicodeMap::UnicodeMap(UnicodeMap &&other) noexcept : encodingName { std::move(other.encodingName) }, kind { other.kind }, unicodeOut { other.unicodeOut }, len { other.len }, eMaps { other.eMaps }, eMapsLen { other.eMapsLen }
{
    switch (kind) {
    case unicodeMapUser:
    case unicodeMapResident:
        ranges = other.ranges;
        other.ranges = nullptr;
        break;
    case unicodeMapFunc:
        func = other.func;
        break;
    }
    other.eMaps = nullptr;
}

UnicodeMap &UnicodeMap::operator=(UnicodeMap &&other) noexcept
{
    if (this != &other)
        swap(other);
    return *this;
}

void UnicodeMap::swap(UnicodeMap &other) noexcept
{
    using std::swap;
    swap(encodingName, other.encodingName);
    swap(unicodeOut, other.unicodeOut);
    switch (kind) {
    case unicodeMapUser:
    case unicodeMapResident:
        switch (other.kind) {
        case unicodeMapUser:
        case unicodeMapResident:
            swap(ranges, other.ranges);
            break;
        case unicodeMapFunc: {
            const auto tmp = ranges;
            func = other.func;
            other.ranges = tmp;
            break;
        }
        }
        break;
    case unicodeMapFunc:
        switch (other.kind) {
        case unicodeMapUser:
        case unicodeMapResident: {
            const auto tmp = func;
            ranges = other.ranges;
            other.func = tmp;
            break;
        }
        case unicodeMapFunc:
            swap(func, other.func);
            break;
        }
        break;
    }
    swap(kind, other.kind);
    swap(len, other.len);
    swap(eMaps, other.eMaps);
    swap(eMapsLen, other.eMapsLen);
}

bool UnicodeMap::match(const std::string &encodingNameA) const
{
    return encodingName == encodingNameA;
}

int UnicodeMap::mapUnicode(Unicode u, char *buf, int bufSize) const
{
    int a, b, m, n, i, j;
    unsigned int code;

    if (kind == unicodeMapFunc) {
        return (*func)(u, buf, bufSize);
    }

    a = 0;
    b = len;
    if (u >= ranges[a].start) {
        // invariant: ranges[a].start <= u < ranges[b].start
        while (b - a > 1) {
            m = (a + b) / 2;
            if (u >= ranges[m].start) {
                a = m;
            } else if (u < ranges[m].start) {
                b = m;
            }
        }
        if (u <= ranges[a].end) {
            n = ranges[a].nBytes;
            if (n > bufSize) {
                return 0;
            }
            code = ranges[a].code + (u - ranges[a].start);
            for (i = n - 1; i >= 0; --i) {
                buf[i] = (char)(code & 0xff);
                code >>= 8;
            }
            return n;
        }
    }

    for (i = 0; i < eMapsLen; ++i) {
        if (eMaps[i].u == u) {
            n = eMaps[i].nBytes;
            for (j = 0; j < n; ++j) {
                buf[j] = eMaps[i].code[j];
            }
            return n;
        }
    }

    return 0;
}

//------------------------------------------------------------------------

UnicodeMapCache::UnicodeMapCache() { }

UnicodeMapCache::~UnicodeMapCache()
{
    for (UnicodeMap *map : cache) {
        delete map;
    }
}

const UnicodeMap *UnicodeMapCache::getUnicodeMap(const std::string &encodingName)
{
    for (UnicodeMap *map : cache) {
        if (map->match(encodingName)) {
            return map;
        }
    }
    UnicodeMap *map = UnicodeMap::parse(encodingName);
    if (map) {
        cache.emplace_back(map);
    }
    return map;
}