/*

 * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * 1.  Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer. 

 * 2.  Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution. 

 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

 *     its contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission. 

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#import "config.h"

#import "FontCache.h"

#import "Font.h"

#import "FontData.h"

#import "FontPlatformData.h"

#import "WebCoreSystemInterface.h"

#import "WebFontCache.h"

namespace WebCore {

static bool getAppDefaultValue(CFStringRef key, int *v)

{

    CFPropertyListRef value;

    value = CFPreferencesCopyValue(key, kCFPreferencesCurrentApplication,

                                   kCFPreferencesAnyUser,

                                   kCFPreferencesAnyHost);

    if (value == 0) {

        value = CFPreferencesCopyValue(key, kCFPreferencesCurrentApplication,

                                       kCFPreferencesCurrentUser,

                                       kCFPreferencesAnyHost);

        if (value == 0)

            return false;

    }

    if (CFGetTypeID(value) == CFNumberGetTypeID()) {

        if (v != 0)

            CFNumberGetValue((const CFNumberRef)value, kCFNumberIntType, v);

    } else if (CFGetTypeID(value) == CFStringGetTypeID()) {

        if (v != 0)

            *v = CFStringGetIntValue((const CFStringRef)value);

    } else {

        CFRelease(value);

        return false;

    }

    CFRelease(value);

    return true;

}

static bool getUserDefaultValue(CFStringRef key, int *v)

{

    CFPropertyListRef value;

    value = CFPreferencesCopyValue(key, kCFPreferencesAnyApplication,

                                   kCFPreferencesCurrentUser,

                                   kCFPreferencesCurrentHost);

    if (value == 0)

        return false;

    if (CFGetTypeID(value) == CFNumberGetTypeID()) {

        if (v != 0)

            CFNumberGetValue((const CFNumberRef)value, kCFNumberIntType, v);

    } else if (CFGetTypeID(value) == CFStringGetTypeID()) {

        if (v != 0)

            *v = CFStringGetIntValue((const CFStringRef)value);

    } else {

        CFRelease(value);

        return false;

    }

    CFRelease(value);

    return true;

}

static int getLCDScaleParameters(void)

{

    int mode;

    CFStringRef key;

    key = CFSTR("AppleFontSmoothing");

    if (!getAppDefaultValue(key, &mode)) {

        if (!getUserDefaultValue(key, &mode))

            return 1;

    }

    if (wkFontSmoothingModeIsLCD(mode))

        return 4;

    return 1;

}

#define MINIMUM_GLYPH_CACHE_SIZE 1536 * 1024

void FontCache::platformInit()

{

    size_t s = MINIMUM_GLYPH_CACHE_SIZE*getLCDScaleParameters();

    wkSetUpFontCache(s);

}

const FontData* FontCache::getFontDataForCharacters(const Font& font, const UChar* characters, int length)

{

    const FontPlatformData& platformData = font.primaryFont()->platformData();

    NSFont *nsFont = platformData.font();

    NSString *string = [[NSString alloc] initWithCharactersNoCopy:const_cast<UChar*>(characters)

        length:length freeWhenDone:NO];

    NSFont *substituteFont = wkGetFontInLanguageForRange(nsFont, string, NSMakeRange(0, length));

    [string release];

    if (!substituteFont && length == 1)

        substituteFont = wkGetFontInLanguageForCharacter(nsFont, characters[0]);

    if (!substituteFont)

        return 0;

    // Use the family name from the AppKit-supplied substitute font, requesting the

    // traits, weight, and size we want. One way this does better than the original

    // AppKit request is that it takes synthetic bold and oblique into account.

    // But it does create the possibility that we could end up with a font that

    // doesn't actually cover the characters we need.

    NSFontManager *manager = [NSFontManager sharedFontManager];

    NSFontTraitMask traits = [manager traitsOfFont:nsFont];

    if (platformData.syntheticBold)

        traits |= NSBoldFontMask;

    if (platformData.syntheticOblique)

        traits |= NSItalicFontMask;

    NSFont *bestVariation = [manager fontWithFamily:[substituteFont familyName]

        traits:traits

        weight:[manager weightOfFont:nsFont]

        size:[nsFont pointSize]];

    if (bestVariation)

        substituteFont = bestVariation;

    substituteFont = font.fontDescription().usePrinterFont()

        ? [substituteFont printerFont] : [substituteFont screenFont];

    NSFontTraitMask substituteFontTraits = [manager traitsOfFont:substituteFont];

    FontPlatformData alternateFont(substituteFont, 

        !font.isPlatformFont() && (traits & NSBoldFontMask) && !(substituteFontTraits & NSBoldFontMask),

        !font.isPlatformFont() && (traits & NSItalicFontMask) && !(substituteFontTraits & NSItalicFontMask));

    return getCachedFontData(&alternateFont);

}

FontPlatformData* FontCache::getSimilarFontPlatformData(const Font& font)

{

    // Attempt to find an appropriate font using a match based on 

    // the presence of keywords in the the requested names.  For example, we'll

    // match any name that contains "Arabic" to Geeza Pro.

    FontPlatformData* platformData = 0;

    const FontFamily* currFamily = &font.fontDescription().family();

    while (currFamily && !platformData) {

        if (currFamily->family().length()) {

            static String matchWords[3] = { String("Arabic"), String("Pashto"), String("Urdu") };

            static AtomicString geezaStr("Geeza Pro");

            for (int j = 0; j < 3 && !platformData; ++j)

                if (currFamily->family().contains(matchWords[j], false))

                    platformData = getCachedFontPlatformData(font.fontDescription(), geezaStr);

        }

        currFamily = currFamily->next();

    }

    return platformData;

}

FontPlatformData* FontCache::getLastResortFallbackFont(const Font& font)

{

    static AtomicString timesStr("Times");

    static AtomicString lucidaGrandeStr("Lucida Grande");

    // FIXME: Would be even better to somehow get the user's default font here.  For now we'll pick

    // the default that the user would get without changing any prefs.

    FontPlatformData* platformFont = getCachedFontPlatformData(font.fontDescription(), timesStr);

    if (!platformFont)

        // The Times fallback will almost always work, but in the highly unusual case where

        // the user doesn't have it, we fall back on Lucida Grande because that's

        // guaranteed to be there, according to Nathan Taylor. This is good enough

        // to avoid a crash at least.

        platformFont = getCachedFontPlatformData(font.fontDescription(), lucidaGrandeStr);

    return platformFont;

}

FontPlatformData* FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family)

{

    NSFontTraitMask traits = 0;

    if (fontDescription.italic())

        traits |= NSItalicFontMask;

    if (fontDescription.bold())

        traits |= NSBoldFontMask;

    float size = fontDescription.computedPixelSize();

    NSFont* nsFont = [WebFontCache fontWithFamily:family traits:traits size:size];

    if (!nsFont)

        return 0;

    NSFontTraitMask actualTraits = 0;

    if (fontDescription.bold() || fontDescription.italic())

        actualTraits = [[NSFontManager sharedFontManager] traitsOfFont:nsFont];

    FontPlatformData* result = new FontPlatformData;

    // Use the correct font for print vs. screen.

    result->setFont(fontDescription.usePrinterFont() ? [nsFont printerFont] : [nsFont screenFont]);

    result->syntheticBold = (traits & NSBoldFontMask) && !(actualTraits & NSBoldFontMask);

    result->syntheticOblique = (traits & NSItalicFontMask) && !(actualTraits & NSItalicFontMask);

    return result;

}

} // namespace WebCore