/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

// This file is available under and governed by the GNU General Public

// License version 2 only, as published by the Free Software Foundation.

// However, the following notice accompanied the original version of this

// file:

//

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

//

//  Little Color Management System

//  Copyright (c) 1998-2012 Marti Maria Saguer

//

// 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.

//

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

//

#include "lcms2_internal.h"

// Multilocalized unicode objects. That is an attempt to encapsulate i18n.

// Allocates an empty multi localizad unicode object

cmsMLU* CMSEXPORT cmsMLUalloc(cmsContext ContextID, cmsUInt32Number nItems)

{

    cmsMLU* mlu;

    // nItems should be positive if given

    if (nItems <= 0) nItems = 2;

    // Create the container

    mlu = (cmsMLU*) _cmsMallocZero(ContextID, sizeof(cmsMLU));

    if (mlu == NULL) return NULL;

    mlu ->ContextID = ContextID;

    // Create entry array

    mlu ->Entries = (_cmsMLUentry*) _cmsCalloc(ContextID, nItems, sizeof(_cmsMLUentry));

    if (mlu ->Entries == NULL) {

        _cmsFree(ContextID, mlu);

        return NULL;

    }

    // Ok, keep indexes up to date

    mlu ->AllocatedEntries    = nItems;

    mlu ->UsedEntries         = 0;

    return mlu;

}

// Grows a mempool table for a MLU. Each time this function is called, mempool size is multiplied times two.

static

cmsBool GrowMLUpool(cmsMLU* mlu)

{

    cmsUInt32Number size;

    void *NewPtr;

    // Sanity check

    if (mlu == NULL) return FALSE;

    if (mlu ->PoolSize == 0)

        size = 256;

    else

        size = mlu ->PoolSize * 2;

    // Check for overflow

    if (size < mlu ->PoolSize) return FALSE;

    // Reallocate the pool

    NewPtr = _cmsRealloc(mlu ->ContextID, mlu ->MemPool, size);

    if (NewPtr == NULL) return FALSE;

    mlu ->MemPool  = NewPtr;

    mlu ->PoolSize = size;

    return TRUE;

}

// Grows a entry table for a MLU. Each time this function is called, table size is multiplied times two.

static

cmsBool GrowMLUtable(cmsMLU* mlu)

{

    int AllocatedEntries;

    _cmsMLUentry *NewPtr;

    // Sanity check

    if (mlu == NULL) return FALSE;

    AllocatedEntries = mlu ->AllocatedEntries * 2;

    // Check for overflow

    if (AllocatedEntries / 2 != mlu ->AllocatedEntries) return FALSE;

    // Reallocate the memory

    NewPtr = (_cmsMLUentry*)_cmsRealloc(mlu ->ContextID, mlu ->Entries, AllocatedEntries*sizeof(_cmsMLUentry));

    if (NewPtr == NULL) return FALSE;

    mlu ->Entries          = NewPtr;

    mlu ->AllocatedEntries = AllocatedEntries;

    return TRUE;

}

// Search for a specific entry in the structure. Language and Country are used.

static

int SearchMLUEntry(cmsMLU* mlu, cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode)

{

    int i;

    // Sanity check

    if (mlu == NULL) return -1;

    // Iterate whole table

    for (i=0; i < mlu ->UsedEntries; i++) {

        if (mlu ->Entries[i].Country  == CountryCode &&

            mlu ->Entries[i].Language == LanguageCode) return i;

    }

    // Not found

    return -1;

}

// Add a block of characters to the intended MLU. Language and country are specified.

// Only one entry for Language/country pair is allowed.

static

cmsBool AddMLUBlock(cmsMLU* mlu, cmsUInt32Number size, const wchar_t *Block,

                     cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode)

{

    cmsUInt32Number Offset;

    cmsUInt8Number* Ptr;

    // Sanity check

    if (mlu == NULL) return FALSE;

    // Is there any room available?

    if (mlu ->UsedEntries >= mlu ->AllocatedEntries) {

        if (!GrowMLUtable(mlu)) return FALSE;

    }

    // Only one ASCII string

    if (SearchMLUEntry(mlu, LanguageCode, CountryCode) >= 0) return FALSE;  // Only one  is allowed!

    // Check for size

    while ((mlu ->PoolSize - mlu ->PoolUsed) < size) {

            if (!GrowMLUpool(mlu)) return FALSE;

    }

    Offset = mlu ->PoolUsed;

    Ptr = (cmsUInt8Number*) mlu ->MemPool;

    if (Ptr == NULL) return FALSE;

    // Set the entry

    memmove(Ptr + Offset, Block, size);

    mlu ->PoolUsed += size;

    mlu ->Entries[mlu ->UsedEntries].StrW     = Offset;

    mlu ->Entries[mlu ->UsedEntries].Len      = size;

    mlu ->Entries[mlu ->UsedEntries].Country  = CountryCode;

    mlu ->Entries[mlu ->UsedEntries].Language = LanguageCode;

    mlu ->UsedEntries++;

    return TRUE;

}

// Add an ASCII entry.

cmsBool CMSEXPORT cmsMLUsetASCII(cmsMLU* mlu, const char LanguageCode[3], const char CountryCode[3], const char* ASCIIString)

{

    cmsUInt32Number i, len = (cmsUInt32Number) strlen(ASCIIString)+1;

    wchar_t* WStr;

    cmsBool  rc;

    cmsUInt16Number Lang  = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);

    cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode);

    if (mlu == NULL) return FALSE;

    WStr = (wchar_t*) _cmsCalloc(mlu ->ContextID, len,  sizeof(wchar_t));

    if (WStr == NULL) return FALSE;

    for (i=0; i < len; i++)

        WStr[i] = (wchar_t) ASCIIString[i];

    rc = AddMLUBlock(mlu, len  * sizeof(wchar_t), WStr, Lang, Cntry);

    _cmsFree(mlu ->ContextID, WStr);

    return rc;

}

// We don't need any wcs support library

static

cmsUInt32Number mywcslen(const wchar_t *s)

{

    const wchar_t *p;

    p = s;

    while (*p)

        p++;

    return (cmsUInt32Number)(p - s);

}

// Add a wide entry

cmsBool  CMSEXPORT cmsMLUsetWide(cmsMLU* mlu, const char Language[3], const char Country[3], const wchar_t* WideString)

{

    cmsUInt16Number Lang  = _cmsAdjustEndianess16(*(cmsUInt16Number*) Language);

    cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) Country);

    cmsUInt32Number len;

    if (mlu == NULL) return FALSE;

    if (WideString == NULL) return FALSE;

    len = (cmsUInt32Number) (mywcslen(WideString) + 1) * sizeof(wchar_t);

    return AddMLUBlock(mlu, len, WideString, Lang, Cntry);

}

// Duplicating a MLU is as easy as copying all members

cmsMLU* CMSEXPORT cmsMLUdup(const cmsMLU* mlu)

{

    cmsMLU* NewMlu = NULL;

    // Duplicating a NULL obtains a NULL

    if (mlu == NULL) return NULL;

    NewMlu = cmsMLUalloc(mlu ->ContextID, mlu ->UsedEntries);

    if (NewMlu == NULL) return NULL;

    // Should never happen

    if (NewMlu ->AllocatedEntries < mlu ->UsedEntries)

        goto Error;

    // Sanitize...

    if (NewMlu ->Entries == NULL || mlu ->Entries == NULL)  goto Error;

    memmove(NewMlu ->Entries, mlu ->Entries, mlu ->UsedEntries * sizeof(_cmsMLUentry));

    NewMlu ->UsedEntries = mlu ->UsedEntries;

    // The MLU may be empty

    if (mlu ->PoolUsed == 0) {

        NewMlu ->MemPool = NULL;

    }

    else {

        // It is not empty

        NewMlu ->MemPool = _cmsMalloc(mlu ->ContextID, mlu ->PoolUsed);

        if (NewMlu ->MemPool == NULL) goto Error;

    }

    NewMlu ->PoolSize = mlu ->PoolUsed;

    if (NewMlu ->MemPool == NULL || mlu ->MemPool == NULL) goto Error;

    memmove(NewMlu ->MemPool, mlu->MemPool, mlu ->PoolUsed);

    NewMlu ->PoolUsed = mlu ->PoolUsed;

    return NewMlu;

Error:

    if (NewMlu != NULL) cmsMLUfree(NewMlu);

    return NULL;

}

// Free any used memory

void CMSEXPORT cmsMLUfree(cmsMLU* mlu)

{

    if (mlu) {

        if (mlu -> Entries) _cmsFree(mlu ->ContextID, mlu->Entries);

        if (mlu -> MemPool) _cmsFree(mlu ->ContextID, mlu->MemPool);

        _cmsFree(mlu ->ContextID, mlu);

    }

}

// The algorithm first searches for an exact match of country and language, if not found it uses

// the Language. If none is found, first entry is used instead.

static

const wchar_t* _cmsMLUgetWide(const cmsMLU* mlu,

                              cmsUInt32Number *len,

                              cmsUInt16Number LanguageCode, cmsUInt16Number CountryCode,

                              cmsUInt16Number* UsedLanguageCode, cmsUInt16Number* UsedCountryCode)

{

    int i;

    int Best = -1;

    _cmsMLUentry* v;

    if (mlu == NULL) return NULL;

    if (mlu -> AllocatedEntries <= 0) return NULL;

    for (i=0; i < mlu ->UsedEntries; i++) {

        v = mlu ->Entries + i;

        if (v -> Language == LanguageCode) {

            if (Best == -1) Best = i;

            if (v -> Country == CountryCode) {

                if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language;

                if (UsedCountryCode  != NULL) *UsedCountryCode = v ->Country;

                if (len != NULL) *len = v ->Len;

                return (wchar_t*) ((cmsUInt8Number*) mlu ->MemPool + v -> StrW);        // Found exact match

            }

        }

    }

    // No string found. Return First one

    if (Best == -1)

        Best = 0;

    v = mlu ->Entries + Best;

    if (UsedLanguageCode != NULL) *UsedLanguageCode = v ->Language;

    if (UsedCountryCode  != NULL) *UsedCountryCode = v ->Country;

    if (len != NULL) *len   = v ->Len;

    return(wchar_t*) ((cmsUInt8Number*) mlu ->MemPool + v ->StrW);

}

// Obtain an ASCII representation of the wide string. Setting buffer to NULL returns the len

cmsUInt32Number CMSEXPORT cmsMLUgetASCII(const cmsMLU* mlu,

                                       const char LanguageCode[3], const char CountryCode[3],

                                       char* Buffer, cmsUInt32Number BufferSize)

{

    const wchar_t *Wide;

    cmsUInt32Number  StrLen = 0;

    cmsUInt32Number ASCIIlen, i;

    cmsUInt16Number Lang  = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);

    cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode);

    // Sanitize

    if (mlu == NULL) return 0;

    // Get WideChar

    Wide = _cmsMLUgetWide(mlu, &StrLen, Lang, Cntry, NULL, NULL);

    if (Wide == NULL) return 0;

    ASCIIlen = StrLen / sizeof(wchar_t);

    // Maybe we want only to know the len?

    if (Buffer == NULL) return ASCIIlen + 1; // Note the zero at the end

    // No buffer size means no data

    if (BufferSize <= 0) return 0;

    // Some clipping may be required

    if (BufferSize < ASCIIlen + 1)

        ASCIIlen = BufferSize - 1;

    // Precess each character

    for (i=0; i < ASCIIlen; i++) {

        if (Wide[i] == 0)

            Buffer[i] = 0;

        else

            Buffer[i] = (char) Wide[i];

    }

    // We put a termination "\0"

    Buffer[ASCIIlen] = 0;

    return ASCIIlen + 1;

}

// Obtain a wide representation of the MLU, on depending on current locale settings

cmsUInt32Number CMSEXPORT cmsMLUgetWide(const cmsMLU* mlu,

                                      const char LanguageCode[3], const char CountryCode[3],

                                      wchar_t* Buffer, cmsUInt32Number BufferSize)

{

    const wchar_t *Wide;

    cmsUInt32Number  StrLen = 0;

    cmsUInt16Number Lang  = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);

    cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode);

    // Sanitize

    if (mlu == NULL) return 0;

    Wide = _cmsMLUgetWide(mlu, &StrLen, Lang, Cntry, NULL, NULL);

    if (Wide == NULL) return 0;

    // Maybe we want only to know the len?

    if (Buffer == NULL) return StrLen + sizeof(wchar_t);

  // No buffer size means no data

    if (BufferSize <= 0) return 0;

    // Some clipping may be required

    if (BufferSize < StrLen + sizeof(wchar_t))

        StrLen = BufferSize - + sizeof(wchar_t);

    memmove(Buffer, Wide, StrLen);

    Buffer[StrLen / sizeof(wchar_t)] = 0;

    return StrLen + sizeof(wchar_t);

}

// Get also the language and country

CMSAPI cmsBool CMSEXPORT cmsMLUgetTranslation(const cmsMLU* mlu,

                                              const char LanguageCode[3], const char CountryCode[3],

                                              char ObtainedLanguage[3], char ObtainedCountry[3])

{

    const wchar_t *Wide;

    cmsUInt16Number Lang  = _cmsAdjustEndianess16(*(cmsUInt16Number*) LanguageCode);

    cmsUInt16Number Cntry = _cmsAdjustEndianess16(*(cmsUInt16Number*) CountryCode);

    cmsUInt16Number ObtLang, ObtCode;

    // Sanitize

    if (mlu == NULL) return FALSE;

    Wide = _cmsMLUgetWide(mlu, NULL, Lang, Cntry, &ObtLang, &ObtCode);

    if (Wide == NULL) return FALSE;

    // Get used language and code

    *(cmsUInt16Number *)ObtainedLanguage = _cmsAdjustEndianess16(ObtLang);

    *(cmsUInt16Number *)ObtainedCountry  = _cmsAdjustEndianess16(ObtCode);

    ObtainedLanguage[2] = ObtainedCountry[2] = 0;

    return TRUE;

}

// Get the number of translations in the MLU object

cmsUInt32Number CMSEXPORT cmsMLUtranslationsCount(const cmsMLU* mlu)

{

    if (mlu == NULL) return 0;

    return mlu->UsedEntries;

}

// Get the language and country codes for a specific MLU index

cmsBool CMSEXPORT cmsMLUtranslationsCodes(const cmsMLU* mlu,

                                          cmsUInt32Number idx,

                                          char LanguageCode[3],

                                          char CountryCode[3])

{

    _cmsMLUentry *entry;

    if (mlu == NULL) return FALSE;

    if (idx >= (cmsUInt32Number) mlu->UsedEntries) return FALSE;