Configuration

/**
 * Get or set default configuration options
 * @param options - Optional configuration object to merge with defaults
 * @returns object - Current default configuration (deep copy)
 */
function defaults(options);

const figlet = require("figlet");

// Get current defaults
const currentDefaults = figlet.defaults();
console.log("Current font:", currentDefaults.font);
console.log("Font path:", currentDefaults.fontPath);

// Set new defaults
figlet.defaults({
  font: "Ghost",
  fontPath: "./custom-fonts"
});

// All subsequent calls will use new defaults
const result1 = figlet.textSync("Hello");  // Uses Ghost font
const result2 = figlet.textSync("World", { font: "Big" });  // Overrides to Big

// Reset to specific defaults
figlet.defaults({
  font: "Standard",
  fontPath: "./fonts"
});

/**
 * Retrieve metadata about a specific font
 * @param fontName - Name of the font to query
 * @param callback - Optional callback function (err, options, headerComment) => void
 * @returns Promise<[object, string]> - Array containing font options and header comment
 */
function metadata(fontName, callback);

// Promise-based metadata access
const [fontOptions, headerComment] = await figlet.metadata("Standard");
console.log("Font height:", fontOptions.height);
console.log("Baseline:", fontOptions.baseline);
console.log("Header comment:", headerComment);
console.log("Fitting rules:", fontOptions.fittingRules);

// Callback-based metadata access
figlet.metadata("Big", (err, options, comment) => {
  if (err) {
    console.error("Could not get metadata:", err);
    return;
  }
  
  console.log(`Font: Big`);
  console.log(`Height: ${options.height} lines`);
  console.log(`Max character width: ${options.maxLength}`);
  console.log(`Print direction: ${options.printDirection === 0 ? 'LTR' : 'RTL'}`);
  console.log(`Comment: ${comment}`);
});

// Analyze font capabilities
async function analyzeFontCapabilities(fontName) {
  try {
    const [options] = await figlet.metadata(fontName);
    const rules = options.fittingRules;
    
    console.log(`\nFont Analysis: ${fontName}`);
    console.log(`Dimensions: ${options.maxLength}x${options.height}`);
    console.log(`Horizontal Layout: ${getLayoutName(rules.hLayout)}`);
    console.log(`Vertical Layout: ${getLayoutName(rules.vLayout)}`);
    console.log(`Smushing Rules: H${countSmushingRules(rules, 'h')} V${countSmushingRules(rules, 'v')}`);
  } catch (err) {
    console.error(`Analysis failed for ${fontName}:`, err.message);
  }
}

function getLayoutName(layout) {
  const layouts = ["Full Width", "Fitting", "Smushing", "Controlled Smushing"];
  return layouts[layout] || "Unknown";
}

function countSmushingRules(rules, prefix) {
  return Object.keys(rules)
    .filter(key => key.startsWith(prefix + 'Rule') && rules[key])
    .length;
}

/**
 * Internal font storage object containing all loaded fonts
 * @type object
 * @readonly
 */
figlet.figFonts;

// Examine loaded fonts
console.log("Currently loaded fonts:", Object.keys(figlet.figFonts));

// Access font character data (advanced usage)
const standardFont = figlet.figFonts["Standard"];
if (standardFont) {
  console.log("Font options:", standardFont.options);
  console.log("Font comment:", standardFont.comment);
  console.log("Number of characters:", standardFont.numChars);
  
  // Access character ASCII art (character code 65 = 'A')
  const charA = standardFont[65];
  if (charA) {
    console.log("Character 'A' representation:");
    charA.forEach(line => console.log(line));
  }
}

// Check if font is already loaded
function isFontLoaded(fontName) {
  return fontName in figlet.figFonts;
}

// Get font loading status
function getFontStatus() {
  const loaded = Object.keys(figlet.figFonts);
  return {
    totalLoaded: loaded.length,
    fonts: loaded,
    hasStandard: loaded.includes("Standard")
  };
}

interface FigletDefaults {
  font: string;       // Default font name ("Standard")
  fontPath: string;   // Path to font directory ("./fonts")
}

// Layout mode constants (internal use)
const FULL_WIDTH = 0;           // Full width spacing
const FITTING = 1;              // Characters touch but don't overlap  
const SMUSHING = 2;             // Universal character overlapping
const CONTROLLED_SMUSHING = 3;  // Rule-based character overlapping

// Font file header structure
interface FigletHeader {
  signature: string;        // "flf2a" signature
  hardBlank: string;        // Hard blank character  
  height: number;           // Character height in lines
  baseline: number;         // Baseline position
  maxLength: number;        // Maximum character width
  oldLayout: number;        // Legacy layout specification
  commentLines: number;     // Number of header comment lines
  printDirection?: number;  // Print direction (optional)
  fullLayout?: number;      // Full layout specification (optional)
  codeTagCount?: number;    // Code tag count (optional)
}

// Node.js specific font path resolution
const path = require("path");
const fontDir = path.join(__dirname, "../fonts/");

// Font loading uses filesystem
figlet.loadFontSync = function(name) {
  const fs = require("fs");
  const fontPath = path.join(fontDir, name + ".flf");
  const fontData = fs.readFileSync(fontPath, { encoding: "utf-8" });
  return figlet.parseFont(name, fontData);
};

// Browser uses fetch API for font loading
figlet.defaults({
  fontPath: "./fonts"  // Relative to current page
});

// Font loading uses network requests
figlet.loadFont = function(name) {
  return fetch(`${figDefaults.fontPath}/${name}.flf`)
    .then(response => response.text())
    .then(data => figlet.parseFont(name, data));
};

// Safe configuration updates
try {
  figlet.defaults({
    font: "CustomFont",
    fontPath: "./assets/fonts"
  });
  
  // Test the configuration
  const result = figlet.textSync("Test");
  console.log("Configuration successful");
} catch (err) {
  console.error("Configuration failed:", err.message);
  
  // Restore safe defaults
  figlet.defaults({
    font: "Standard",
    fontPath: "./fonts"
  });
}

// Validate font metadata
figlet.metadata("UnknownFont")
  .then(([options, comment]) => {
    console.log("Font is valid and loaded");
  })
  .catch(err => {
    console.error("Font metadata unavailable:", err.message);
  });

// Create font manager utility
class FontManager {
  constructor() {
    this.loadedFonts = new Set();
    this.fontCache = new Map();
  }
  
  async ensureFont(fontName) {
    if (!this.loadedFonts.has(fontName)) {
      const options = await figlet.loadFont(fontName);
      this.loadedFonts.add(fontName);
      this.fontCache.set(fontName, options);
      return options;
    }
    return this.fontCache.get(fontName);
  }
  
  async generateWithFont(text, fontName, options = {}) {
    await this.ensureFont(fontName);
    return figlet.text(text, { ...options, font: fontName });
  }
}

// Usage
const fontManager = new FontManager();
const result = await fontManager.generateWithFont("Hello", "Ghost");

// Create configuration profiles for different use cases
const profiles = {
  compact: {
    horizontalLayout: "fitted",
    verticalLayout: "fitted",
    width: 60
  },
  
  banner: {
    font: "Big",
    horizontalLayout: "controlled smushing",
    width: 120
  },
  
  artistic: {
    font: "Larry 3D",
    horizontalLayout: "universal smushing",
    verticalLayout: "universal smushing"
  }
};

// Apply profile
function useProfile(profileName) {
  const profile = profiles[profileName];
  if (profile) {
    figlet.defaults(profile);
    console.log(`Applied ${profileName} profile`);
  }
}