/*
 * Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.
 * 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.
 */

package sun.font;

import java.util.Locale;

import sun.awt.SunHints;
import sun.awt.SunToolkit;
import sun.util.logging.PlatformLogger;

/**
 * Small utility class to manage FontConfig.
 */
public class FontConfigManager {

 static boolean fontConfigFailed = false;

 /* This is populated by native */
 private static final FontConfigInfo fcInfo = new FontConfigInfo();

 /* Begin support for GTK Look and Feel - query libfontconfig and
 * return a composite Font to Swing that uses the desktop font(s).
 */

 /* These next three classes are just data structures.
 */
 public static class FontConfigFont {
 public String familyName; // eg Bitstream Vera Sans
 public String styleStr; // eg Bold
 public String fullName; // eg Bitstream Vera Sans Bold
 public String fontFile; // eg /usr/X11/lib/fonts/foo.ttf
 }

 public static class FcCompFont {
 public String fcName; // eg sans
 public String fcFamily; // eg sans
 public String jdkName; // eg sansserif
 public int style; // eg 0=PLAIN
 public FontConfigFont firstFont;
 public FontConfigFont[] allFonts;
 //boolean preferBitmaps; // if embedded bitmaps preferred over AA
 public CompositeFont compFont; // null if not yet created/known.
 }

 public static class FontConfigInfo {
 public int fcVersion;
 public String[] cacheDirs = new String[4];
 }

 /* fontconfig recognises slants roman, italic, as well as oblique,
 * and a slew of weights, where the ones that matter here are
 * regular and bold.
 * To fully qualify what we want, we can for example ask for (eg)
 * Font.PLAIN : "serif:regular:roman"
 * Font.BOLD : "serif:bold:roman"
 * Font.ITALIC : "serif:regular:italic"
 * Font.BOLD|Font.ITALIC : "serif:bold:italic"
 */
 private static String[] fontConfigNames = {
 "sans:regular:roman",
 "sans:bold:roman",
 "sans:regular:italic",
 "sans:bold:italic",

 "serif:regular:roman",
 "serif:bold:roman",
 "serif:regular:italic",
 "serif:bold:italic",

 "monospace:regular:roman",
 "monospace:bold:roman",
 "monospace:regular:italic",
 "monospace:bold:italic",
 };

 /* This array has the array elements created in Java code and is
 * passed down to native to be filled in.
 */
 private FcCompFont[] fontConfigFonts;

 /**
 * Instantiates a new FontConfigManager getting the default instance
 * of FontManager from the FontManagerFactory.
 */
 public FontConfigManager() {
 }

 /* Called from code that needs to know what are the AA settings
 * that apps using FC would pick up for the default desktop font.
 * Note apps can change the default desktop font. etc, so this
 * isn't certain to be right but its going to correct for most cases.
 * Native return values map to the text aa values in sun.awt.SunHints.
 * which is used to look up the renderinghint value object.
 */
 public static Object getFontConfigAAHint() {
 return getFontConfigAAHint("sans");
 }

 /* This is public solely so that for debugging purposes it can be called
 * with other names, which might (eg) include a size, eg "sans-24"
 * The return value is a text aa rendering hint value.
 * Normally we should call the no-args version.
 */
 public static Object getFontConfigAAHint(String fcFamily) {
 if (FontUtilities.isWindows) {
 return null;
 } else {
 int hint = getFontConfigAASettings(getFCLocaleStr(), fcFamily);
 if (hint < 0) {
 return null;
 } else {
 return SunHints.Value.get(SunHints.INTKEY_TEXT_ANTIALIASING,
 hint);
 }
 }
 }


 private static String getFCLocaleStr() {
 Locale l = SunToolkit.getStartupLocale();
 String localeStr = l.getLanguage();
 String country = l.getCountry();
 if (!country.equals("")) {
 localeStr = localeStr + "-" + country;
 }
 return localeStr;
 }

 /* This does cause the native libfontconfig to be loaded and unloaded,
 * but it does not incur the overhead of initialisation of its
 * data structures, so shouldn't have a measurable impact.
 */
 public static native int getFontConfigVersion();

 /* This can be made public if it's needed to force a re-read
 * rather than using the cached values. The re-read would be needed
 * only if some event signalled that the fontconfig has changed.
 * In that event this method would need to return directly the array
 * to be used by the caller in case it subsequently changed.
 */
 public synchronized void initFontConfigFonts(boolean includeFallbacks) {

 if (fontConfigFonts != null) {
 if (!includeFallbacks || (fontConfigFonts[0].allFonts != null)) {
 return;
 }
 }

 if (FontUtilities.isWindows || fontConfigFailed) {
 return;
 }

 long t0 = 0;
 if (FontUtilities.isLogging()) {
 t0 = System.nanoTime();
 }

 FcCompFont[] fontArr = new FcCompFont[fontConfigNames.length];

 for (int i = 0; i < fontArr.length; i++) {
 fontArr[i] = new FcCompFont();
 fontArr[i].fcName = fontConfigNames[i];
 int colonPos = fontArr[i].fcName.indexOf(':');
 fontArr[i].fcFamily = fontArr[i].fcName.substring(0, colonPos);
 fontArr[i].jdkName = FontUtilities.mapFcName(fontArr[i].fcFamily);
 fontArr[i].style = i % 4; // depends on array order.
 }
 getFontConfig(getFCLocaleStr(), fcInfo, fontArr, includeFallbacks);
 FontConfigFont anyFont = null;
 /* If don't find anything (eg no libfontconfig), then just return */
 for (int i = 0; i < fontArr.length; i++) {
 FcCompFont fci = fontArr[i];
 if (fci.firstFont == null) {
 if (FontUtilities.isLogging()) {
 PlatformLogger logger = FontUtilities.getLogger();
 logger.info("Fontconfig returned no font for " +
 fontArr[i].fcName);
 }
 fontConfigFailed = true;
 } else if (anyFont == null) {
 anyFont = fci.firstFont;
 }
 }

 if (anyFont == null) {
 if (FontUtilities.isLogging()) {
 PlatformLogger logger = FontUtilities.getLogger();
 logger.info("Fontconfig returned no fonts at all.");
 }
 fontConfigFailed = true;
 return;
 } else if (fontConfigFailed) {
 for (int i = 0; i < fontArr.length; i++) {
 if (fontArr[i].firstFont == null) {
 fontArr[i].firstFont = anyFont;
 }
 }
 }

 fontConfigFonts = fontArr;

 if (FontUtilities.isLogging()) {

 PlatformLogger logger = FontUtilities.getLogger();

 long t1 = System.nanoTime();
 logger.info("Time spent accessing fontconfig="
 + ((t1 - t0) / 1000000) + "ms.");

 for (int i = 0; i < fontConfigFonts.length; i++) {
 FcCompFont fci = fontConfigFonts[i];
 logger.info("FC font " + fci.fcName + " maps to family " +
 fci.firstFont.familyName +
 " in file " + fci.firstFont.fontFile);
 if (fci.allFonts != null) {
 for (int f = 0; f < fci.allFonts.length; f++) {
 FontConfigFont fcf = fci.allFonts[f];
 logger.info("Family=" + fcf.familyName +
 " Style=" + fcf.styleStr +
 " Fullname=" + fcf.fullName +
 " File=" + fcf.fontFile);
 }
 }
 }
 }
 }

 public PhysicalFont registerFromFcInfo(FcCompFont fcInfo) {

 SunFontManager fm = SunFontManager.getInstance();

 /* If it's a TTC file we need to know that as we will need to
 * make sure we return the right font */
 String fontFile = fcInfo.firstFont.fontFile;
 int offset = fontFile.length() - 4;
 if (offset <= 0) {
 return null;
 }
 String ext = fontFile.substring(offset).toLowerCase();
 boolean isTTC = ext.equals(".ttc");

 /* If this file is already registered, can just return its font.
 * However we do need to check in case it's a TTC as we need
 * a specific font, so rather than directly returning it, let
 * findFont2D resolve that.
 */
 PhysicalFont physFont = fm.getRegisteredFontFile(fontFile);
 if (physFont != null) {
 if (isTTC) {
 Font2D f2d = fm.findFont2D(fcInfo.firstFont.familyName,
 fcInfo.style,
 FontManager.NO_FALLBACK);
 if (f2d instanceof PhysicalFont) { /* paranoia */
 return (PhysicalFont) f2d;
 } else {
 return null;
 }
 } else {
 return physFont;
 }
 }

 /* If the font may hide a JRE font (eg fontconfig says it is
 * Lucida Sans), we want to use the JRE version, so make it
 * point to the JRE font.
 */
 physFont = fm.findJREDeferredFont(fcInfo.firstFont.familyName,
 fcInfo.style);

 /* It is also possible the font file is on the "deferred" list,
 * in which case we can just initialise it now.
 */
 if (physFont == null &&
 fm.isDeferredFont(fontFile) == true) {
 physFont = fm.initialiseDeferredFont(fcInfo.firstFont.fontFile);
 /* use findFont2D to get the right font from TTC's */
 if (physFont != null) {
 if (isTTC) {
 Font2D f2d = fm.findFont2D(fcInfo.firstFont.familyName,
 fcInfo.style,
 FontManager.NO_FALLBACK);
 if (f2d instanceof PhysicalFont) { /* paranoia */
 return (PhysicalFont) f2d;
 } else {
 return null;
 }
 } else {
 return physFont;
 }
 }
 }

 /* In the majority of cases we reach here, and need to determine
 * the type and rank to register the font.
 */
 if (physFont == null) {
 int fontFormat = SunFontManager.FONTFORMAT_NONE;
 int fontRank = Font2D.UNKNOWN_RANK;

 if (ext.equals(".ttf") || isTTC) {
 fontFormat = SunFontManager.FONTFORMAT_TRUETYPE;
 fontRank = Font2D.TTF_RANK;
 } else if (ext.equals(".pfa") || ext.equals(".pfb")) {
 fontFormat = SunFontManager.FONTFORMAT_TYPE1;
 fontRank = Font2D.TYPE1_RANK;
 }
 physFont = fm.registerFontFile(fcInfo.firstFont.fontFile, null,
 fontFormat, true, fontRank);
 }
 return physFont;
 }

 /*
 * We need to return a Composite font which has as the font in
 * its first slot one obtained from fontconfig.
 */
 public CompositeFont getFontConfigFont(String name, int style) {

 name = name.toLowerCase();

 initFontConfigFonts(false);
 if (fontConfigFonts == null) {
 // This avoids an immediate NPE if fontconfig look up failed
 // but doesn't guarantee this is a recoverable situation.
 return null;
 }

 FcCompFont fcInfo = null;
 for (int i = 0; i < fontConfigFonts.length; i++) {
 if (name.equals(fontConfigFonts[i].fcFamily) &&
 style == fontConfigFonts[i].style) {
 fcInfo = fontConfigFonts[i];
 break;
 }
 }
 if (fcInfo == null) {
 fcInfo = fontConfigFonts[0];
 }

 if (FontUtilities.isLogging()) {
 FontUtilities.getLogger()
 .info("FC name=" + name + " style=" + style +
 " uses " + fcInfo.firstFont.familyName +
 " in file: " + fcInfo.firstFont.fontFile);
 }

 if (fcInfo.compFont != null) {
 return fcInfo.compFont;
 }

 /* jdkFont is going to be used for slots 1..N and as a fallback.
 * Slot 0 will be the physical font from fontconfig.
 */
 FontManager fm = FontManagerFactory.getInstance();
 CompositeFont jdkFont = (CompositeFont)
 fm.findFont2D(fcInfo.jdkName, style, FontManager.LOGICAL_FALLBACK);

 if (fcInfo.firstFont.familyName == null ||
 fcInfo.firstFont.fontFile == null) {
 return (fcInfo.compFont = jdkFont);
 }

 /* First, see if the family and exact style is already registered.
 * If it is, use it. If it's not, then try to register it.
 * If that registration fails (signalled by null) just return the
 * regular JDK composite.
 * Algorithmically styled fonts won't match on exact style, so
 * will fall through this code, but the regisration code will
 * find that file already registered and return its font.
 */
 FontFamily family = FontFamily.getFamily(fcInfo.firstFont.familyName);
 PhysicalFont physFont = null;
 if (family != null) {
 Font2D f2D = family.getFontWithExactStyleMatch(fcInfo.style);
 if (f2D instanceof PhysicalFont) {
 physFont = (PhysicalFont) f2D;
 }
 }

 if (physFont == null ||
 !fcInfo.firstFont.fontFile.equals(physFont.platName)) {
 physFont = registerFromFcInfo(fcInfo);
 if (physFont == null) {
 return (fcInfo.compFont = jdkFont);
 }
 family = FontFamily.getFamily(physFont.getFamilyName(null));
 }

 /* Now register the fonts in the family (the other styles) after
 * checking that they aren't already registered and are actually in
 * a different file. They may be the same file in CJK cases.
 * For cases where they are different font files - eg as is common for
 * Latin fonts, then we rely on fontconfig to report these correctly.
 * Assume that all styles of this font are found by fontconfig,
 * so we can find all the family members which must be registered
 * together to prevent synthetic styling.
 */
 for (int i = 0; i < fontConfigFonts.length; i++) {
 FcCompFont fc = fontConfigFonts[i];
 if (fc != fcInfo &&
 physFont.getFamilyName(null).equals(fc.firstFont.familyName) &&
 !fc.firstFont.fontFile.equals(physFont.platName) &&
 family.getFontWithExactStyleMatch(fc.style) == null) {

 registerFromFcInfo(fontConfigFonts[i]);
 }
 }

 /* Now we have a physical font. We will back this up with the JDK
 * logical font (sansserif, serif, or monospaced) that corresponds
 * to the Pango/GTK/FC logical font name.
 */
 return (fcInfo.compFont = new CompositeFont(physFont, jdkFont));
 }

 /**
 * @param locale
 * @param fcFamily
 * @return
 */
 public FcCompFont[] getFontConfigFonts() {
 return fontConfigFonts;
 }

 /* Return an array of FcCompFont structs describing the primary
 * font located for each of fontconfig/GTK/Pango's logical font names.
 */
 private static native void getFontConfig(String locale,
 FontConfigInfo fcInfo,
 FcCompFont[] fonts,
 boolean includeFallbacks);

 void populateFontConfig(FcCompFont[] fcInfo) {
 fontConfigFonts = fcInfo;
 }

 FcCompFont[] loadFontConfig() {
 initFontConfigFonts(true);
 return fontConfigFonts;
 }

 FontConfigInfo getFontConfigInfo() {
 initFontConfigFonts(true);
 return fcInfo;
 }

 private static native int
 getFontConfigAASettings(String locale, String fcFamily);
}