#!/usr/bin/env python3
"""
Complete Glyph Decoding Pipeline

This script combines hash-based glyph normalization with TTF character matching:
1. Hash-Based Normalization: Renders glyphs from all batches and groups by perceptual hash
2. TTF Matching: Matches unique glyphs to TTF characters using progressive SSIM

Usage:
    python3 decode_glyphs_complete.py <book_dir> [--fast] [--full] [--progressive]

Options:
    --fast          Early exit on good SSIM matches
    --full          Check all characters in font (not just alphanumeric)
    --progressive   Use multi-stage filtering (32→64→128→256→512→1024px)
"""

import json
import sys
from pathlib import Path
from collections import defaultdict, Counter
import io
from multiprocessing import Pool, cpu_count
import string
import time
import numpy as np

try:
    from PIL import Image, ImageOps
    import imagehash
    import cairosvg
    from svgpathtools import parse_path
    from fontTools.ttLib import TTFont
    from fontTools.pens.svgPathPen import SVGPathPen
    from fontTools.pens.boundsPen import BoundsPen
    from fontTools.misc.transform import Transform
    from fontTools.pens.transformPen import TransformPen
    from skimage.metrics import structural_similarity as ssim
    from tqdm import tqdm
except ImportError as e:
    print("[!] Missing dependencies! Install with:")
    print("    pip install pillow cairosvg imagehash svgpathtools fonttools scikit-image tqdm")
    sys.exit(1)


# ============================================================================
# PART 1: HASH-BASED GLYPH NORMALIZATION
# ============================================================================

class GlyphHasher:
    """Renders SVG glyphs and computes perceptual hashes"""

    def __init__(self, size=128):
        self.size = size

    def render_glyph(self, glyph_data):
        """Render SVG path as filled shape"""
        path_str = glyph_data.get('path', '')
        if not path_str or path_str.strip() == '':
            return None

        try:
            # Parse path to get bounding box
            path = parse_path(path_str)
            if len(path) == 0:
                return None

            xmin, xmax, ymin, ymax = path.bbox()
            width = xmax - xmin
            height = ymax - ymin

            if width == 0 or height == 0:
                return None

            # Use font metrics for consistent viewbox
            units_per_em = glyph_data.get('unitsPerEm', 1000)
            ascent = glyph_data.get('ascent', 800)
            descent = glyph_data.get('descent', -200)

            # Center glyph both horizontally and vertically
            glyph_center_x = (xmin + xmax) / 2
            glyph_center_y = (ymin + ymax) / 2

            half_width = units_per_em / 2
            font_height = ascent - descent
            half_height = font_height / 2

            viewbox_x = glyph_center_x - half_width
            viewbox_y = glyph_center_y - half_height
            viewbox = f"{viewbox_x} {viewbox_y} {units_per_em} {font_height}"

            # Create SVG document
            svg = f'''<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg" viewBox="{viewbox}" width="{self.size}" height="{self.size}">
  <path d="{path_str}" fill="black"/>
</svg>'''

            # Render using cairosvg
            png_bytes = cairosvg.svg2png(bytestring=svg.encode('utf-8'),
                                         output_width=self.size,
                                         output_height=self.size)

            # Load as RGBA
            img_rgba = Image.open(io.BytesIO(png_bytes))

            # Create white background and composite
            img = Image.new('L', (self.size, self.size), 255)
            if img_rgba.mode == 'RGBA':
                alpha = img_rgba.split()[3]
                inverted = ImageOps.invert(alpha)
                img.paste(0, mask=inverted)

            return img

        except Exception:
            return None

    def compute_hash(self, img):
        """Compute hash - use multiple hash types for better precision"""
        if img is None:
            return None
        # Use average hash (more precise) + dhash (directional) for better uniqueness
        # Larger hash_size = more precision, less chance of collisions
        ahash = str(imagehash.average_hash(img, hash_size=16))
        dhash = str(imagehash.dhash(img, hash_size=16))
        return f"{ahash}_{dhash}"  # Combine both for maximum uniqueness


def process_batch(args):
    """Process a single batch (for multiprocessing)"""
    book_dir, batch_num, save_images = args
    batch_dir = Path(book_dir) / f'batch_{batch_num}'
    glyphs_file = batch_dir / 'glyphs.json'

    if not glyphs_file.exists():
        return None

    hasher = GlyphHasher()
    batch_results = {
        'batch_num': batch_num,
        'glyph_to_hash': {},
        'glyphs_in_text': [],
        'images': {}
    }

    # Load glyphs and compute hashes
    with open(glyphs_file) as f:
        glyph_data = json.load(f)

    for font_data in glyph_data:
        font_family = font_data['fontFamily']
        glyphs = font_data.get('glyphs', {})

        for glyph_id, glyph_info in glyphs.items():
            # Add font metrics
            glyph_info['unitsPerEm'] = font_data.get('unitsPerEm', 1000)
            glyph_info['ascent'] = font_data.get('ascent', 800)
            glyph_info['descent'] = font_data.get('descent', -200)

            # Render and hash
            img = hasher.render_glyph(glyph_info)
            if img is not None:
                phash = hasher.compute_hash(img)
                batch_results['glyph_to_hash'][int(glyph_id)] = {
                    'hash': phash,
                    'font': font_family
                }

                if save_images and phash not in batch_results['images']:
                    batch_results['images'][phash] = img

    # Load text and extract all glyph IDs used
    page_files = sorted(batch_dir.glob('page_data_*.json'))
    for page_file in page_files:
        with open(page_file) as f:
            pages = json.load(f)

        for page in pages:
            for run in page.get('children', []):
                if 'glyphs' in run:
                    batch_results['glyphs_in_text'].extend(run['glyphs'])

    return batch_results


def create_hash_mapping(book_dir):
    """Phase 1: Create hash-based mapping of all glyphs"""
    print(f"\n{'='*80}")
    print(f"PHASE 1: HASH-BASED GLYPH NORMALIZATION")
    print(f"{'='*80}\n")
    print(f"Book directory: {book_dir}")
    print(f"Using all {cpu_count()} CPU cores")

    # Find all batches
    batch_dirs = []
    front_batches = sorted([d for d in book_dir.iterdir() if d.is_dir() and d.name.startswith('batch_front')])
    batch_dirs.extend(front_batches)
    numbered_batches = sorted([d for d in book_dir.iterdir() if d.is_dir() and d.name.startswith('batch_') and not d.name.startswith('batch_front')],
                              key=lambda x: int(x.name.split('_')[1]))
    batch_dirs.extend(numbered_batches)
    batch_nums = list(range(len(batch_dirs)))

    print(f"\n[*] Found {len(batch_dirs)} batches")

    # Process all batches in parallel
    print(f"[*] Processing batches (rendering all glyphs)...")
    with Pool(cpu_count()) as pool:
        batch_args = [(str(book_dir), batch_num, True) for batch_num in batch_nums]
        results = list(pool.imap_unordered(process_batch, batch_args))

    results = [r for r in results if r is not None]
    print(f"[✓] Processed {len(results)} batches")

    # Build hash -> unique_id mapping
    print(f"\n[*] Building hash-based mapping...")
    hash_to_id = {}
    hash_counter = 0
    hash_fonts = {}
    hash_samples = {}
    hash_images = {}

    for result in results:
        batch_num = result['batch_num']

        for phash, img in result.get('images', {}).items():
            if phash not in hash_images:
                hash_images[phash] = img

        for local_glyph_id, glyph_info in result['glyph_to_hash'].items():
            phash = glyph_info['hash']
            font = glyph_info['font']

            if phash not in hash_to_id:
                hash_to_id[phash] = hash_counter
                hash_fonts[hash_counter] = font
                hash_samples[hash_counter] = (batch_num, local_glyph_id)
                hash_counter += 1

    print(f"[✓] Found {len(hash_to_id)} unique glyphs")

    # Verify no hash collisions
    print(f"\n[*] Verifying hash uniqueness...")
    from collections import Counter
    hash_counts = Counter(hash_to_id.keys())
    collisions = {h: count for h, count in hash_counts.items() if count > 1}

    if collisions:
        print(f"⚠ WARNING: Found {len(collisions)} hash collisions!")
        print(f"This means some distinct glyphs are being merged together.")
        print(f"First few collisions:")
        for h, count in list(collisions.items())[:5]:
            print(f"  Hash {h}: {count} glyphs")
        print(f"\n⚠ This will cause incorrect decoding. Please report this issue.")
    else:
        print(f"✓ No hash collisions - each glyph has a unique hash")

    # Normalize all text
    print(f"\n[*] Normalizing all text...")
    all_normalized_glyphs = []

    for result in sorted(results, key=lambda r: r['batch_num']):
        batch_mapping = {}
        for local_glyph_id, glyph_info in result['glyph_to_hash'].items():
            phash = glyph_info['hash']
            batch_mapping[local_glyph_id] = hash_to_id[phash]

        for glyph_id in result['glyphs_in_text']:
            unique_id = batch_mapping.get(glyph_id, -1)
            all_normalized_glyphs.append(unique_id)

    print(f"[✓] Normalized {len(all_normalized_glyphs):,} glyphs")

    # Save results
    output_dir = book_dir / 'hash_mapping'
    output_dir.mkdir(exist_ok=True)

    hash_info = {
        'total_unique_glyphs': len(hash_to_id),
        'hash_to_id': hash_to_id,
        'id_to_font': {str(k): v for k, v in hash_fonts.items()},
        'id_samples': {str(k): {'batch': v[0], 'glyph': v[1]} for k, v in hash_samples.items()}
    }

    with open(output_dir / 'hash_info.json', 'w') as f:
        json.dump(hash_info, f, indent=2)

    with open(output_dir / 'all_glyphs.json', 'w') as f:
        json.dump(all_normalized_glyphs, f)

    # Save glyph images
    images_dir = output_dir / 'glyph_images'
    images_dir.mkdir(exist_ok=True)

    for phash, unique_id in hash_to_id.items():
        if phash in hash_images:
            img = hash_images[phash]
            font = hash_fonts[unique_id]
            img.save(images_dir / f'id_{unique_id:03d}_{font}.png')

    print(f"[✓] Saved to {output_dir}/")

    # Show frequency
    freq = Counter(all_normalized_glyphs)
    print(f"\n[*] Top 20 most frequent glyphs:")
    for unique_id, count in freq.most_common(20):
        pct = count / len(all_normalized_glyphs) * 100
        font = hash_fonts.get(unique_id, 'unknown')
        print(f"    ID {unique_id:3d} ({font:12s}): {count:7,} ({pct:5.2f}%)")

    return output_dir, hash_info


# ============================================================================
# PART 2: TTF CHARACTER MATCHING
# ============================================================================

def render_glyph_by_name(tt, glyph_name, size=128):
    """Render a glyph by name from TTF"""
    glyph_set = tt.getGlyphSet()
    if glyph_name not in glyph_set:
        return None

    glyph = glyph_set[glyph_name]

    # Get font metrics
    head = tt['head']
    units_per_em = head.unitsPerEm
    hhea = tt['hhea']
    ascent = hhea.ascent
    descent = hhea.descent

    # Get bounding box
    bounds_pen = BoundsPen(glyph_set)
    glyph.draw(bounds_pen)
    if bounds_pen.bounds is None:
        return None
    xmin, ymin, xmax, ymax = bounds_pen.bounds

    # Apply Y-flip to bbox
    ymin_svg = -ymax
    ymax_svg = -ymin

    # Extract SVG path with Y-flip
    svg_pen = SVGPathPen(glyph_set)
    transform_pen = TransformPen(svg_pen, Transform(1, 0, 0, -1, 0, 0))
    glyph.draw(transform_pen)
    path_data = svg_pen.getCommands()

    if not path_data or path_data.strip() == '':
        return None

    # Center glyph
    glyph_center_x = (xmin + xmax) / 2
    glyph_center_y = (ymin_svg + ymax_svg) / 2
    font_height = ascent - descent
    viewbox_x = glyph_center_x - units_per_em / 2
    viewbox_y = glyph_center_y - font_height / 2
    viewbox = f"{viewbox_x} {viewbox_y} {units_per_em} {font_height}"

    # Create SVG
    svg = f'''<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg" viewBox="{viewbox}" width="{size}" height="{size}">
  <path d="{path_data}" fill="black"/>
</svg>'''

    # Render
    try:
        png_bytes = cairosvg.svg2png(
            bytestring=svg.encode('utf-8'),
            output_width=size,
            output_height=size
        )
        img_rgba = Image.open(io.BytesIO(png_bytes))
        img = Image.new('L', (size, size), 255)
        alpha = img_rgba.split()[3]
        inverted = ImageOps.invert(alpha)
        img.paste(0, mask=inverted)
        return img
    except Exception:
        return None


def render_char_from_ttf(tt, char, size=128):
    """Render a character from TTF"""
    cmap = tt.getBestCmap()
    if ord(char) not in cmap:
        return None
    glyph_name = cmap[ord(char)]
    return render_glyph_by_name(tt, glyph_name, size)


def compare_images_ssim(img1, img2):
    """Compare two images using SSIM. Returns distance (0=identical)"""
    arr1 = np.array(img1)
    arr2 = np.array(img2)
    similarity = ssim(arr1, arr2)
    distance = (1 - similarity) * 10
    return distance


def match_single_glyph(args):
    """Match a single glyph (for parallel processing)"""
    unique_id, glyph_images_dir, ttf_library_items, fast_mode, progressive_mode = args

    # Load Amazon glyph image
    glyph_image_files = list(glyph_images_dir.glob(f'id_{unique_id:03d}_*.png'))
    if not glyph_image_files:
        return (unique_id, None, float('inf'))

    amazon_img = Image.open(glyph_image_files[0])

    if not progressive_mode:
        # Original single-pass approach
        best_match = None
        best_distance = float('inf')
        early_exit_threshold = 0.05 if fast_mode else -1

        for (char, font_name, style), ttf_img in ttf_library_items:
            distance = compare_images_ssim(amazon_img, ttf_img)
            if distance < best_distance:
                best_distance = distance
                best_match = (char, font_name, style)

                if fast_mode and distance <= early_exit_threshold:
                    break

        return (unique_id, best_match, best_distance)

    # Progressive resolution approach
    # Stage 1: 128x128 - Quick filter
    amazon_128 = amazon_img.resize((128, 128), Image.LANCZOS)
    candidates_128 = []

    for (char, font_name, style), ttf_img in ttf_library_items:
        ttf_128 = ttf_img.resize((128, 128), Image.LANCZOS)
        distance = compare_images_ssim(amazon_128, ttf_128)
        candidates_128.append(((char, font_name, style), ttf_img, distance))

    # Sort and keep top 30 candidates only
    candidates_128.sort(key=lambda x: x[2])
    candidates_128 = candidates_128[:30]

    # Stage 2: 256x256 - Narrow down
    amazon_256 = amazon_img.resize((256, 256), Image.LANCZOS)
    candidates_256 = []

    for (char, font_name, style), ttf_img, _ in candidates_128:
        ttf_256 = ttf_img.resize((256, 256), Image.LANCZOS)
        distance = compare_images_ssim(amazon_256, ttf_256)
        candidates_256.append(((char, font_name, style), ttf_img, distance))

    # Sort and keep top 10
    candidates_256.sort(key=lambda x: x[2])
    candidates_256 = candidates_256[:10]

    # Stage 3: 512x512 - Final decision
    amazon_512 = amazon_img.resize((512, 512), Image.LANCZOS)
    best_match = None
    best_distance = float('inf')

    for (char, font_name, style), ttf_img, _ in candidates_256:
        ttf_512 = ttf_img.resize((512, 512), Image.LANCZOS)
        distance = compare_images_ssim(amazon_512, ttf_512)
        if distance < best_distance:
            best_distance = distance
            best_match = (char, font_name, style)

            # Early exit if very confident
            if distance < 0.05:
                break

    return (unique_id, best_match, best_distance)


def match_ttf_characters(hash_mapping_dir, fast_mode, full_mode, progressive_mode):
    """Phase 2: Match unique glyphs to TTF characters"""
    print(f"\n{'='*80}")
    print(f"PHASE 2: TTF CHARACTER MATCHING")
    print(f"{'='*80}\n")

    hash_info_file = hash_mapping_dir / 'hash_info.json'
    glyph_images_dir = hash_mapping_dir / 'glyph_images'

    # Load hash info
    with open(hash_info_file) as f:
        hash_info = json.load(f)

    id_to_font = {int(k): v for k, v in hash_info['id_to_font'].items()}

    # Find all font files (check multiple directories)
    font_dirs = [Path('fonts'), Path('.')]
    font_files = []
    for font_dir in font_dirs:
        if font_dir.exists():
            font_files.extend(font_dir.glob('*.ttf'))

    font_files = sorted(set(font_files))  # Remove duplicates
    print(f"Found {len(font_files)} font files")

    # Check which fonts we have vs what the book needs
    found_font_names = {f.stem.lower() for f in font_files}
    needed_fonts = set(id_to_font.values())
    missing_fonts = needed_fonts - found_font_names

    if missing_fonts:
        print(f"\n⚠ WARNING: Book uses fonts not in font directory:")
        for font in missing_fonts:
            glyph_count = sum(1 for f in id_to_font.values() if f == font)
            print(f"  - {font}: {glyph_count} glyphs")
        print(f"\nGlyphs using these fonts will be matched against available fonts (may be inaccurate)")
    else:
        print(f"✓ All required fonts available")

    # Characters to test
    if full_mode:
        chars_to_test = []
        print("Full mode: Will check ALL characters in font")
    else:
        # Standard ASCII characters
        chars_to_test = string.ascii_letters + string.digits + string.punctuation + " "

        # Add common special characters that appear in books
        special_chars = [
            '\u2022',  # • BULLET
            '\u2023',  # ‣ TRIANGULAR BULLET
            '\u2043',  # ⁃ HYPHEN BULLET
            '\u00B7',  # · MIDDLE DOT
            '\u25E6',  # ◦ WHITE BULLET
            '\u2219',  # ∙ BULLET OPERATOR
            '\u00A0',  # Non-breaking space
            '\u00A9',  # © COPYRIGHT
            '\u00AE',  # ® REGISTERED
            '\u2122',  # ™ TRADEMARK
            '\u00AB',  # « LEFT DOUBLE ANGLE QUOTE
            '\u00BB',  # » RIGHT DOUBLE ANGLE QUOTE
            '\u2018',  # ' LEFT SINGLE QUOTE (already in ligatures but add anyway)
            '\u2019',  # ' RIGHT SINGLE QUOTE
            '\u201A',  # ‚ SINGLE LOW-9 QUOTE
            '\u201B',  # ‛ SINGLE HIGH-REVERSED-9 QUOTE
            '\u2032',  # ′ PRIME
            '\u2033',  # ″ DOUBLE PRIME
        ]
        chars_to_test += ''.join(special_chars)
        print(f"Standard mode: Checking {len(chars_to_test)} predefined characters (including special chars)")

    # Ligatures and special glyphs
    ligature_glyphs = {
        'f_f': 'ff', 'f_i': 'fi', 'f_l': 'fl', 'f_f_i': 'ffi', 'f_f_l': 'ffl',
        'uniFB00': 'ff', 'uniFB01': 'fi', 'uniFB02': 'fl', 'uniFB03': 'ffi', 'uniFB04': 'ffl',
        'space': ' ',
        'endash': chr(0x2013), 'emdash': chr(0x2014),
        'quotedblleft': chr(0x201C), 'quotedblright': chr(0x201D),
        'quoteleft': chr(0x2018), 'quoteright': chr(0x2019),
        'ellipsis': chr(0x2026),
    }

    # Build TTF character library
    print("=" * 60)
    print("Building TTF character library...")
    print("=" * 60)

    ttf_library = {}

    for font_path in font_files:
        font_name = font_path.stem
        print(f"\nProcessing: {font_name}")

        font_style = "normal"
        if "Bold" in font_name and "Italic" in font_name:
            font_style = "bold-italic"
        elif "Bold" in font_name:
            font_style = "bold"
        elif "Italic" in font_name:
            font_style = "italic"

        try:
            tt = TTFont(font_path)
            rendered_count = 0

            if full_mode:
                cmap = tt.getBestCmap()
                if cmap:
                    for codepoint, glyph_name in cmap.items():
                        char = chr(codepoint)
                        img = render_char_from_ttf(tt, char)
                        if img is not None:
                            ttf_library[(char, font_name, font_style)] = img
                            rendered_count += 1
            else:
                for char in chars_to_test:
                    img = render_char_from_ttf(tt, char)
                    if img is not None:
                        ttf_library[(char, font_name, font_style)] = img
                        rendered_count += 1

            # Render ligatures and special characters
            glyph_set = tt.getGlyphSet()
            for glyph_name, char in ligature_glyphs.items():
                if glyph_name in glyph_set:
                    img = render_glyph_by_name(tt, glyph_name)
                    if img is not None:
                        ttf_library[(char, font_name, font_style)] = img
                        rendered_count += 1

            print(f"  Rendered {rendered_count} glyphs")

        except Exception as e:
            print(f"  Error: {e}")

    print(f"\n[✓] TTF library built: {len(ttf_library)} glyphs")

    # Match glyphs
    print("\n" + "=" * 60)
    mode_parts = []
    if progressive_mode:
        mode_parts.append("PROGRESSIVE MODE - 3-stage filtering (128→256→512px)")
    elif fast_mode:
        mode_parts.append("FAST MODE - early exit on good matches")
    else:
        mode_parts.append("FULL MODE - exhaustive search")

    print(f"Matching Amazon glyphs to TTF characters (using SSIM, {cpu_count()} threads)")
    print(f"{' | '.join(mode_parts)}")
    print("=" * 60)

    # Prepare arguments
    ttf_library_items = list(ttf_library.items())
    glyph_ids = sorted(id_to_font.keys())
    args_list = [(gid, glyph_images_dir, ttf_library_items, fast_mode, progressive_mode) for gid in glyph_ids]

    # Process in parallel
    matches = {}
    no_match_count = 0

    start_time = time.time()
    with Pool(cpu_count()) as pool:
        results = list(tqdm(pool.imap(match_single_glyph, args_list), total=len(args_list), desc="Matching glyphs"))
    elapsed_time = time.time() - start_time

    for unique_id, best_match, best_distance in results:
        if best_match and best_distance <= 1.0:
            matches[unique_id] = (*best_match, best_distance)
            # Highlight potential mismatches
            if best_match[0] in [',', "'", '"', '`'] and best_distance > 0.3:
                print(f"⚠ Glyph {unique_id:3d} → '{best_match[0]}' (distance={best_distance:.3f}, font={best_match[1]}) [UNCERTAIN]")
            else:
                print(f"✓ Glyph {unique_id:3d} → '{best_match[0]}' (distance={best_distance:.3f}, font={best_match[1]})")
        else:
            no_match_count += 1
            print(f"✗ Glyph {unique_id:3d} → NO MATCH (best distance={best_distance:.3f})")

    # Add special case for space
    matches[-1] = (' ', 'special', 'normal', 0)

    print("\n" + "=" * 60)
    print("RESULTS")
    print("=" * 60)
    print(f"Matched: {len(matches)-1}/{len(id_to_font)} glyphs ({100*(len(matches)-1)/len(id_to_font):.0f}%)")
    print(f"No match: {no_match_count} glyphs")
    print(f"Time taken: {elapsed_time:.2f} seconds")
    print(f"\nUnmatched glyph IDs: {[k for k in sorted(id_to_font.keys()) if k not in matches]}")

    # Save mapping
    output_file = Path('ttf_character_mapping.json')
    mapping_output = {
        str(glyph_id): {
            "character": char,
            "font": font,
            "style": style,
            "distance": dist
        }
        for glyph_id, (char, font, style, dist) in matches.items()
    }

    with open(output_file, 'w', encoding='utf-8') as f:
        json.dump(mapping_output, f, indent=2, ensure_ascii=False)

    print(f"\nMapping saved to: {output_file}")

    # Show character frequency
    char_counts = defaultdict(int)
    style_counts = defaultdict(int)
    for char, _font, style, _dist in matches.values():
        char_counts[char] += 1
        style_counts[style] += 1

    print("\nMost common matched characters:")
    for char, count in sorted(char_counts.items(), key=lambda x: -x[1])[:20]:
        print(f"  '{char}': {count} glyphs")

    print("\nMatches by style:")
    for style, count in sorted(style_counts.items()):
        print(f"  {style}: {count} glyphs")

    return output_file


# ============================================================================
# MAIN
# ============================================================================

def main():
    if len(sys.argv) < 2:
        print("Usage: python3 decode_glyphs_complete.py <book_dir> [--fast] [--full] [--progressive]")
        print("\nOptions:")
        print("  --fast          Early exit on good SSIM matches")
        print("  --full          Check all characters in font (not just alphanumeric)")
        print("  --progressive   Use multi-stage filtering (32→64→128→256→512→1024px)")
        sys.exit(1)

    fast_mode = "--fast" in sys.argv
    full_mode = "--full" in sys.argv
    progressive_mode = "--progressive" in sys.argv
    book_dir = Path(sys.argv[1])

    print(f"\n{'='*80}")
    print(f"COMPLETE GLYPH DECODING PIPELINE")
    print(f"{'='*80}")
    print(f"\nBook: {book_dir}")
    print(f"Options:")
    print(f"  Fast mode: {fast_mode}")
    print(f"  Full character set: {full_mode}")
    print(f"  Progressive matching: {progressive_mode}")

    # Phase 1: Hash-based normalization
    hash_mapping_dir, hash_info = create_hash_mapping(book_dir)

    # Phase 2: TTF character matching
    mapping_file = match_ttf_characters(hash_mapping_dir, fast_mode, full_mode, progressive_mode)

    print(f"\n{'='*80}")
    print(f"[✓] COMPLETE PIPELINE FINISHED!")
    print(f"{'='*80}")
    print(f"\nOutputs:")
    print(f"  Hash mapping: {hash_mapping_dir}/")
    print(f"  Character mapping: {mapping_file}")


if __name__ == '__main__':
    main()