exiftool_rs/metadata/

exif.rs

//! EXIF/TIFF IFD metadata reader.
//!
//! Implements reading of TIFF IFD structures used in EXIF, GPS, and Interop metadata.
//! Mirrors the core logic of ExifTool's Exif.pm ProcessExif function.

use byteorder::{BigEndian, ByteOrder, LittleEndian};

use std::cell::{Cell, RefCell};

use crate::error::{Error, Result};
use crate::tag::{Tag, TagGroup, TagId};
use crate::tags::exif as exif_tags;
use crate::value::Value;

thread_local! {
    static SHOW_UNKNOWN: Cell<u8> = const { Cell::new(0) };
    /// Whether every instance of a tag name must be reported. ExifTool's CLI turns
    /// the Duplicates option on together with -ee, and `FoundTag` then keeps each
    /// instance under its own key; the name-level pruning in this module reproduces
    /// the Duplicates-off collapse and must be skipped in that case.
    static KEEP_DUPLICATES: Cell<bool> = const { Cell::new(false) };
    /// ExifTool's `$$self{TIFF_TYPE}`: which flavour of TIFF is being read.
    /// Several tag names depend on it -- 0x0201 in IFD0 is a thumbnail offset
    /// in a JPEG and a preview offset in an ARW -- and it is set once per file
    /// rather than threaded through every IFD reader.
    static TIFF_TYPE: RefCell<String> = const { RefCell::new(String::new()) };
    /// ExifTool's `$$self{Software}`: the EXIF Software tag, stored as it is
    /// read because MakerNote conditions ask for it. Sony tells one ILCE-9
    /// firmware from another that way, and reads a different offset for each.
    static SOFTWARE: RefCell<String> = const { RefCell::new(String::new()) };
    /// ExifTool's `$$self{Make}`, kept for the same reason as Software: a
    /// binary sub-table can be conditioned on it, and Kodak's Type9 reads four
    /// of its fields only when the file says Kodak wrote it.
    static MAKE: RefCell<String> = const { RefCell::new(String::new()) };
}

/// Set the Software string the file declares (ExifTool's `$$self{Software}`).
pub fn set_software(text: &str) {
    SOFTWARE.with(|s| s.borrow_mut().replace_range(.., text));
}

/// The Software string the file declares.
#[must_use]
pub fn software() -> String {
    SOFTWARE.with(|s| s.borrow().clone())
}

/// Set the Make the file declares (ExifTool's `$$self{Make}`).
pub fn set_make(text: &str) {
    MAKE.with(|s| s.borrow_mut().replace_range(.., text));
}

/// The Make the file declares.
#[must_use]
pub fn make() -> String {
    MAKE.with(|s| s.borrow().clone())
}

/// Set the TIFF flavour being read (ExifTool's `TIFF_TYPE`).
pub fn set_tiff_type(kind: &str) {
    TIFF_TYPE.with(|s| s.borrow_mut().replace_range(.., kind));
}

/// The TIFF flavour being read.
#[must_use]
pub fn tiff_type() -> String {
    TIFF_TYPE.with(|s| s.borrow().clone())
}

/// Set whether duplicate tag names must all be kept (ExifTool's Duplicates option).
pub fn set_keep_duplicates(keep: bool) {
    KEEP_DUPLICATES.with(|s| s.set(keep));
}

/// Whether duplicate tag names must all be kept.
pub fn keep_duplicates() -> bool {
    KEEP_DUPLICATES.with(|s| s.get())
}

/// Set the show_unknown level for the current thread (used by MakerNotes).
pub fn set_show_unknown(level: u8) {
    SHOW_UNKNOWN.with(|s| s.set(level));
}

/// Get the show_unknown level for the current thread (used by MakerNotes).
pub fn get_show_unknown() -> u8 {
    SHOW_UNKNOWN.with(|s| s.get())
}

/// Byte order of the TIFF data.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ByteOrderMark {
    LittleEndian,
    BigEndian,
}

/// Parsed TIFF header.
#[derive(Debug)]
pub struct TiffHeader {
    pub byte_order: ByteOrderMark,
    pub ifd0_offset: u32,
}

/// EXIF IFD entry as read from the file.
#[derive(Debug)]
struct IfdEntry {
    tag: u16,
    data_type: u16,
    count: u32,
    value_offset: u32,
    /// For values that fit in 4 bytes, the raw 4 bytes
    inline_data: [u8; 4],
}

/// Size in bytes for each TIFF data type.
fn type_size(data_type: u16) -> Option<usize> {
    match data_type {
        1 => Some(1),  // BYTE
        2 => Some(1),  // ASCII
        3 => Some(2),  // SHORT
        4 => Some(4),  // LONG
        5 => Some(8),  // RATIONAL
        6 => Some(1),  // SBYTE
        7 => Some(1),  // UNDEFINED
        8 => Some(2),  // SSHORT
        9 => Some(4),  // SLONG
        10 => Some(8), // SRATIONAL
        11 => Some(4), // FLOAT
        12 => Some(8), // DOUBLE
        13 => Some(4), // IFD
        _ => None,
    }
}

/// Parse a TIFF header from raw bytes.
pub fn parse_tiff_header(data: &[u8]) -> Result<TiffHeader> {
    if data.len() < 8 {
        return Err(Error::InvalidTiffHeader);
    }

    let byte_order = match (data[0], data[1]) {
        (b'I', b'I') => ByteOrderMark::LittleEndian,
        (b'M', b'M') => ByteOrderMark::BigEndian,
        _ => return Err(Error::InvalidTiffHeader),
    };

    let magic = match byte_order {
        ByteOrderMark::LittleEndian => LittleEndian::read_u16(&data[2..4]),
        ByteOrderMark::BigEndian => BigEndian::read_u16(&data[2..4]),
    };

    if magic != 42 {
        return Err(Error::InvalidTiffHeader);
    }

    let ifd0_offset = match byte_order {
        ByteOrderMark::LittleEndian => LittleEndian::read_u32(&data[4..8]),
        ByteOrderMark::BigEndian => BigEndian::read_u32(&data[4..8]),
    };

    Ok(TiffHeader {
        byte_order,
        ifd0_offset,
    })
}

/// Tags where the EXIF IFD value takes priority over a same-named MakerNotes tag
/// (structural/authoritative EXIF). For all other duplicates, MakerNotes wins —
/// matching ExifTool's group priority.
pub(crate) const EXIF_PRIMARY_TAGS: &[&str] = &[
    "ThumbnailOffset",
    "ThumbnailLength",
    "ThumbnailImage",
    "StripOffsets",
    "StripByteCounts",
    "PreviewImageStart",
    "PreviewImageLength",
    "PreviewImage",
    "ImageWidth",
    "ImageHeight",
    "BitsPerSample",
    "Compression",
    "PhotometricInterpretation",
    "SamplesPerPixel",
    "RowsPerStrip",
    "PlanarConfiguration",
    "XResolution",
    "YResolution",
    "ResolutionUnit",
    "Orientation",
    "Make",
    "Model",
    "Software",
    "ExifByteOrder",
    "CR2CFAPattern",
    "RawImageSegmentation",
    "ColorSpace",
    "ExifVersion",
    "FlashpixVersion",
    "ExifImageWidth",
    "ExifImageHeight",
    "InteropIndex",
    "InteropVersion",
    "DateTimeOriginal",
    "CreateDate",
    "ModifyDate",
    "DateTime",
    "FocalPlaneXResolution",
    "FocalPlaneYResolution",
    "FocalPlaneResolutionUnit",
    "CustomRendered",
    "ExposureMode",
    "SceneCaptureType",
    // IFD0 PrintIM wins over a MakerNotes PrintIM copy.
    "PrintIMVersion",
    "Flash",
    "FocalLength",
    "ExposureTime",
    // ExposureProgram is deliberately absent: Sony::Tag9404c states no priority
    // of its own and is read after the ExifIFD, so ExifTool's own rule -- an
    // incoming tag takes the name when its priority is >= the stored one's --
    // gives it the name. Listing it here dropped the maker-note copy before the
    // arbitration that implements that rule could see it.
    "FNumber",
    "ShutterSpeedValue",
    "ApertureValue",
    "ComponentsConfiguration",
    "UserComment",
    // Standard EXIF image-parameter tags (0xa408-0xa40c) take priority over the
    // manufacturer's MakerNote duplicate when both are present (ExifTool default).
    "Contrast",
    "Saturation",
    "Sharpness",
];

/// EXIF metadata reader.
pub struct ExifReader;

impl ExifReader {
    /// Parse EXIF data from a byte slice (starting at the TIFF header).
    pub fn read(data: &[u8]) -> Result<Vec<Tag>> {
        Self::read_with_base(data, 0)
    }

    /// Parse EXIF data, adding `base` (the TIFF header's offset within the file) to
    /// offset-type tags so they read as absolute file offsets, matching ExifTool.
    pub fn read_with_base(data: &[u8], base: usize) -> Result<Vec<Tag>> {
        let mut tags = Self::read_inner(data, base)?;
        if base != 0 {
            // ExifTool reports these IsOffset tags relative to the start of the file.
            const OFFSET_TAGS: &[&str] = &[
                "ThumbnailOffset",
                "PreviewImageStart",
                "JpgFromRawStart",
                "OtherImageStart",
                "StripOffsets",
            ];
            for t in tags.iter_mut() {
                if OFFSET_TAGS.contains(&t.name.as_str()) {
                    if let Some(off) = t.raw_value.as_u64() {
                        let abs = off + base as u64;
                        t.raw_value = Value::U32(abs as u32);
                        t.print_value = abs.to_string();
                    }
                }
            }
        }
        Ok(tags)
    }

    /// ExifTool raises ExifByteOrder at file level, not from IFD0.
    fn exif_byte_order_tag(byte_order: ByteOrderMark) -> Tag {
        let bo_str = match byte_order {
            ByteOrderMark::LittleEndian => "Little-endian (Intel, II)",
            ByteOrderMark::BigEndian => "Big-endian (Motorola, MM)",
        };
        Tag {
            id: TagId::Text("ExifByteOrder".to_string()),
            name: "ExifByteOrder".to_string(),
            description: "Exif Byte Order".to_string(),
            group: TagGroup {
                family0: "File".to_string(),
                family1: "File".to_string(),
                family2: "Image".to_string(),
                family3: "Main".into(),
            },
            raw_value: Value::String(bo_str.to_string()),
            print_value: bo_str.to_string(),
            priority: 0,
        }
    }

    fn read_inner(data: &[u8], exif_base: usize) -> Result<Vec<Tag>> {
        let header = parse_tiff_header(data)?;
        let mut tags = Vec::new();

        // Emit ExifByteOrder tag
        tags.push(Self::exif_byte_order_tag(header.byte_order));

        // Detect CR2: "CR" at offset 8 in TIFF data
        let is_cr2 = data.len() > 10 && &data[8..10] == b"CR";

        // Read IFD0 (main image)
        Self::read_ifd(data, &header, header.ifd0_offset, "IFD0", &mut tags)?;

        // An ARW or SR2 names its IFD0 0x0201/0x0202 pair PreviewImageStart and
        // PreviewImageLength (done as they are read), and ExifTool extracts the
        // image they point at, exactly as it does for a CR2.
        let preview_in_ifd0 = is_cr2 || matches!(tiff_type().as_str(), "ARW" | "SR2");

        // For CR2 files, rename IFD0 StripOffsets→PreviewImageStart and
        // StripByteCounts→PreviewImageLength, then construct PreviewImage.
        if preview_in_ifd0 {
            // Rename tags in-place
            for tag in tags.iter_mut() {
                if tag.group.family1 == "IFD0" {
                    if tag.name == "StripOffsets" {
                        tag.name = "PreviewImageStart".to_string();
                        tag.description = "Preview Image Start".to_string();
                        tag.id = TagId::Text("PreviewImageStart".to_string());
                    } else if tag.name == "StripByteCounts" {
                        tag.name = "PreviewImageLength".to_string();
                        tag.description = "Preview Image Length".to_string();
                        tag.id = TagId::Text("PreviewImageLength".to_string());
                    }
                }
            }
            // Construct PreviewImage from PreviewImageStart + PreviewImageLength
            let preview_start = tags
                .iter()
                .find(|t| t.name == "PreviewImageStart" && t.group.family1 == "IFD0")
                .and_then(|t| t.raw_value.as_u64())
                .map(|v| v as usize);
            let preview_len = tags
                .iter()
                .find(|t| t.name == "PreviewImageLength" && t.group.family1 == "IFD0")
                .and_then(|t| t.raw_value.as_u64())
                .map(|v| v as usize);
            if let (Some(start), Some(len)) = (preview_start, preview_len) {
                if len > 0 {
                    // The tag reports the length the file declares. A preview
                    // that runs past the end of what we hold still exists as a
                    // tag -- ExifTool lists it from the pair, not from the
                    // bytes -- so only the payload is trimmed to what is there.
                    let img_data = data
                        .get(start..start + len)
                        .or_else(|| data.get(start..))
                        .unwrap_or_default()
                        .to_vec();
                    let pv = format!("(Binary data {} bytes, use -b option to extract)", len);
                    tags.push(Tag {
                        id: TagId::Text("PreviewImage".to_string()),
                        name: "PreviewImage".to_string(),
                        description: "Preview Image".to_string(),
                        group: TagGroup {
                            family0: "EXIF".to_string(),
                            family1: "IFD0".to_string(),
                            family2: "Preview".to_string(),
                            family3: "Main".into(),
                        },
                        raw_value: Value::Binary(img_data),
                        print_value: pv,
                        priority: 0,
                    });
                }
            }
        }

        // ExifTool stores Software as it reads it (`DataMember => 'Software'`,
        // Exif.pm:905) because MakerNote conditions test it -- Sony reads
        // ShutterCount2 from a different offset on an ILCE-9 running v5 or v6.
        if let Some(sw) = tags.iter().find(|t| t.name == "Software") {
            set_software(sw.print_value.trim_end());
        }

        // Extract Make + Model for MakerNotes detection and sub-table dispatch
        if let Some(mk) = tags.iter().find(|t| t.name == "Make") {
            set_make(mk.print_value.trim_end());
        }
        let make = tags
            .iter()
            .find(|t| t.name == "Make")
            .map(|t| t.print_value.clone())
            .unwrap_or_default();

        let model = tags
            .iter()
            .find(|t| t.name == "Model")
            .map(|t| t.print_value.clone())
            .unwrap_or_default();

        // Store model for sub-table dispatch
        let make_and_model = if model.is_empty() {
            make.clone()
        } else {
            model
        };

        // Find and parse MakerNotes
        // Look for the MakerNote tag (0x927C) that was stored as Undefined
        let mn_info: Option<(usize, usize)> = {
            // Re-scan ExifIFD for MakerNote offset/size
            let mut result = None;
            Self::find_makernote(data, &header, &mut result);
            result
        };

        if let Some((mn_offset, mn_size)) = mn_info {
            let mn_tags = crate::metadata::makernotes::parse_makernotes_exif_base(
                data,
                mn_offset,
                mn_size,
                &make,
                &make_and_model,
                header.byte_order,
                exif_base,
            );
            // The parsed tags take the raw MakerNote tag's place in the stream.
            // ExifTool descends into the maker note the moment ProcessExif reaches
            // 0x927c inside the ExifIFD (Exif.pm:6113 `ProcessDirectory` on the
            // SubDirectory), so every maker-note tag is stored BEFORE the walk
            // resumes and reaches IFD1. That order decides every priority-0 tie:
            // in a JPEG both `PreviewIFD` and `IFD1` are in LOW_PRIORITY_DIR
            // (ExifTool.pm:4368 and ProcessJPEG :7317), so the tie is first-wins
            // and the PreviewIFD copy has to be seen first.
            // In Perl ExifTool, MakerNotes tags with equal/higher priority overwrite EXIF tags.
            // Tags in the EXIF-primary list: EXIF wins (skip MakerNotes duplicate).
            // Other tags: MakerNotes wins (remove EXIF version, add MakerNotes version).
            // The placeholder is still in `tags` here, so its index is looked up
            // at splice time — the EXIF-duplicate pruning below runs first and
            // would invalidate an index taken any earlier.
            let splice_in = |tags: &mut Vec<Tag>, new: Vec<Tag>| match tags
                .iter()
                .position(|t| t.name == "MakerNote")
            {
                Some(i) => {
                    tags.splice(i..=i, new);
                }
                None => tags.extend(new),
            };
            if keep_duplicates() {
                // Duplicates are kept: ExifTool reports the EXIF and the maker-note
                // copy of a tag side by side (e.g. FujiFilm Contrast/Saturation/
                // Sharpness or Panasonic TextStamp under -ee).
                splice_in(&mut tags, mn_tags);
            } else {
                // Tags where EXIF takes priority over MakerNotes (structural/authoritative EXIF)
                let exif_primary: &[&str] = EXIF_PRIMARY_TAGS;
                // Only a maker-note tag ExifTool would let win outright removes
                // the EXIF duplicate here. A tag whose source table states
                // `PRIORITY => 0` — Minolta::CameraSettings (Minolta.pm:974) and
                // its siblings — does not: FoundTag promotes the stored EXIF tag
                // to 1 first (ExifTool.pm:9544-9551), so it keeps the name unless
                // it is itself demoted, and only the central arbitration knows
                // that. Leaving both instances in place is what lets ExifIFD keep
                // MeteringMode while the maker note takes WhiteBalance, whose
                // 0xa403 carries `Priority => 0` "to keep this WhiteBalance from
                // overriding the MakerNotes WhiteBalance" (Exif.pm:2877-2880).
                // A `PreviewIFD` tag cannot either: ExifTool.pm:4368 initialises
                // `LOW_PRIORITY_DIR = { PreviewIFD => 1 }`, and `Nikon::PreviewIFD`
                // says so itself (Nikon.pm:5391, "these tags are priority 0 by
                // default because PreviewIFD is flagged in LOW_PRIORITY_DIR").
                let mn_name_set: std::collections::HashSet<String> = mn_tags
                    .iter()
                    .filter(|t| {
                        t.priority_rank() >= 0
                            && t.priority != crate::tag::PRIORITY_EXPLICIT_ZERO
                            && t.group.family1 != "PreviewIFD"
                    })
                    .map(|t| t.name.clone())
                    .collect();
                let exif_has: std::collections::HashSet<String> =
                    tags.iter().map(|t| t.name.clone()).collect();
                // Remove EXIF non-primary tags when MakerNotes provides them (MakerNotes wins)
                tags.retain(|t| {
                    !mn_name_set.contains(&t.name) || exif_primary.contains(&t.name.as_str())
                });
                // Add MakerNotes tags, but skip EXIF-primary tags that EXIF already provides.
                // Exception: a few maker notes carry a more precise authoritative value
                // (e.g. Kodak FNumber/ExposureTime) that ExifTool reports over EXIF — keep
                // those so the later precedence pass can promote them.
                let kept: Vec<Tag> = mn_tags
                    .into_iter()
                    .filter(|mn_tag| {
                        let authoritative = mn_tag.group.family1 == "Kodak"
                            && matches!(mn_tag.name.as_str(), "FNumber" | "ExposureTime");
                        // EXIF wins — don't add the MakerNotes version. A
                        // `PreviewIFD` tag is exempt in both directions: it is
                        // priority 0 (ExifTool.pm:4368), so the arbitration pass
                        // in `exiftool` already lets IFD0 beat it, while against
                        // the equally-demoted IFD1 of a JPEG (ProcessJPEG,
                        // ExifTool.pm:7317) the tie is first-wins and the
                        // PreviewIFD copy is the one ExifTool keeps.
                        authoritative
                            || mn_tag.group.family1 == "PreviewIFD"
                            || !exif_primary.contains(&mn_tag.name.as_str())
                            || !exif_has.contains(&mn_tag.name)
                    })
                    .collect();
                splice_in(&mut tags, kept);
            }
        }

        // Sony hangs a private IFD off the same tag, and reaching it does not
        // depend on whether a MakerNote was found: a raw file has both.
        if make.to_ascii_uppercase().starts_with("SONY") {
            Self::parse_sony_sr2(data, &header, &mut tags);
        }

        // DNG PrivateData (0xC634): parse Adobe MakN for MakerNotes if no MakerNote found
        if mn_info.is_none() {
            // Scan for DNGPrivateData in tags — look for "Adobe\0" header
            // Find the offset from the tag value (stored as binary/undefined)
            Self::parse_dng_private_data(data, &header, &make, &make_and_model, &mut tags);
        }

        // Parse IPTC data embedded in TIFF (tag 0x83BB "IPTC-NAA")
        // The raw tag stores IPTC data as undefined bytes or a list of u32 values
        {
            let iptc_data: Option<Vec<u8>> =
                tags.iter().find(|t| t.name == "IPTC-NAA").and_then(|t| {
                    match &t.raw_value {
                        Value::Undefined(bytes) => Some(bytes.clone()),
                        Value::Binary(bytes) => Some(bytes.clone()),
                        Value::List(items) => {
                            // IPTC-NAA stored as uint32 list - convert back to bytes (big-endian)
                            let mut bytes = Vec::with_capacity(items.len() * 4);
                            for item in items {
                                if let Value::U32(v) = item {
                                    bytes.extend_from_slice(&v.to_be_bytes())
                                }
                            }
                            if bytes.is_empty() {
                                None
                            } else {
                                Some(bytes)
                            }
                        }
                        _ => None,
                    }
                });

            if let Some(iptc_bytes) = iptc_data {
                // Compute MD5 of the raw IPTC data for CurrentIPTCDigest
                let md5_hex = crate::md5::md5_hex(&iptc_bytes);

                if let Ok(iptc_tags) = crate::metadata::IptcReader::read(&iptc_bytes) {
                    // Replace raw IPTC-NAA tag with parsed IPTC tags
                    tags.retain(|t| t.name != "IPTC-NAA");
                    tags.extend(iptc_tags);
                }

                // Add CurrentIPTCDigest tag
                tags.push(crate::tag::Tag {
                    id: crate::tag::TagId::Text("CurrentIPTCDigest".into()),
                    name: "CurrentIPTCDigest".into(),
                    description: "Current IPTC Digest".into(),
                    group: crate::tag::TagGroup {
                        family0: "IPTC".into(),
                        family1: "IPTC".into(),
                        family2: "Other".into(),
                        family3: "Main".into(),
                    },
                    raw_value: Value::String(md5_hex.clone()),
                    print_value: md5_hex,
                    priority: 0,
                });
            }
        }

        // Parse ICC_Profile data embedded in TIFF (tag 0x8773)
        {
            let icc_data: Option<Vec<u8>> =
                tags.iter()
                    .find(|t| t.name == "ICC_Profile")
                    .and_then(|t| match &t.raw_value {
                        Value::Undefined(bytes) => Some(bytes.clone()),
                        Value::Binary(bytes) => Some(bytes.clone()),
                        _ => None,
                    });

            if let Some(icc_bytes) = icc_data {
                if let Ok(icc_tags) = crate::formats::icc::read_icc(&icc_bytes) {
                    // Replace raw ICC_Profile tag with parsed ICC tags
                    tags.retain(|t| t.name != "ICC_Profile");
                    tags.extend(icc_tags);
                }
            }
        }

        // Process GeoTIFF key directory if present
        process_geotiff_keys(&mut tags);

        // Final deduplication: within MakerNotes, if the same tag name appears multiple times
        // (e.g., from different sub-tables), keep the last occurrence.
        // Only deduplicate MakerNotes tags (family0 == "MakerNotes") to avoid affecting
        // structural EXIF/IFD tags.
        //
        // This is ExifTool collapsing its name-keyed VALUE hash, so it must not run
        // when the Duplicates option is on: a maker note that genuinely defines the
        // same name at several tag IDs (Panasonic TextStamp at 0x3b, 0x3e, 0x8008
        // and 0x8009, BabyAge at 0x33 and 0x8010 — Panasonic.pm:727, 789, 811,
        // 1570, 1576, 1581) is then reported once per ID.
        {
            // With duplicates kept, a name is only collapsed when the SAME tag ID
            // produced it twice — that is our own sub-table reading a tag the main
            // table already read, never two IDs the maker note really defines
            // under one name.
            let by_id = keep_duplicates();
            if tags.iter().any(|t| t.group.family0 == "MakerNotes") {
                // Replay FoundTag's comparison rather than simply keeping the
                // last occurrence: an incoming tag takes the name only when its
                // priority is >= the stored one's, and a stored 0 is promoted to
                // 1 first (ExifTool.pm:9544-9560). A sub-table that states
                // `PRIORITY => 0` — every Canon::CameraInfo* (Canon.pm:3162 and
                // siblings) — therefore does not displace the value an earlier
                // sub-table stored, which is how Canon::ShotInfo keeps
                // WhiteBalance against CameraInfo1DmkIII's.
                let eff = |t: &Tag| -> i32 {
                    if t.priority == crate::tag::PRIORITY_EXPLICIT_ZERO {
                        0
                    } else if t.priority == 0 {
                        1
                    } else {
                        t.priority
                    }
                };
                let promoted = |p: i32| if p == 0 { 1 } else { p };
                // With duplicates kept, two instances of a name are the same
                // tag only when they come from the same directory as well as
                // the same id: an ARW holds thirteen SR2DataIFDs, each with a
                // ColorMode of its own, and ExifTool reports all thirteen.
                let mut winner: std::collections::HashMap<
                    (&str, Option<&TagId>, Option<&str>),
                    usize,
                > = std::collections::HashMap::new();
                let mut keep = vec![true; tags.len()];
                for (i, t) in tags.iter().enumerate() {
                    if t.group.family0 != "MakerNotes" {
                        continue;
                    }
                    let key = (
                        t.name.as_str(),
                        if by_id { Some(&t.id) } else { None },
                        if by_id {
                            Some(t.group.family1.as_str())
                        } else {
                            None
                        },
                    );
                    match winner.get(&key).copied() {
                        None => {
                            winner.insert(key, i);
                        }
                        Some(w) => {
                            if eff(t) >= promoted(eff(&tags[w])) {
                                keep[w] = false;
                                winner.insert(key, i);
                            } else {
                                keep[i] = false;
                            }
                        }
                    }
                }
                let mut iter = keep.iter();
                tags.retain(|_| *iter.next().unwrap_or(&true));
            }
        }

        // GPS.pm:17-21 `%coordConv` — GPSLatitude and GPSLongitude print through
        // `ToDMS($self, $val, 1)`, which normalises fractional minutes into
        // seconds and does NOT append the hemisphere reference. The ref belongs to
        // the Composite of the same name (GPS.pm:367-405), whose PrintConv is
        // `ToDMS($self, $val, 1, "N"/"E")`; see `composite::gps_coordinates`.
        for coord in ["GPSLatitude", "GPSLongitude"] {
            if let Some(t) = tags.iter_mut().find(|t| t.name == coord) {
                let parts: Vec<f64> = t
                    .raw_value
                    .to_display_string()
                    .split_whitespace()
                    .filter_map(|s| s.parse::<f64>().ok())
                    .collect();
                if parts.len() == 3 {
                    let dec = parts[0] + parts[1] / 60.0 + parts[2] / 3600.0;
                    let deg = dec.floor();
                    let rem = (dec - deg) * 60.0;
                    let min = rem.floor();
                    let sec = (rem - min) * 60.0;
                    t.print_value = format!("{} deg {}' {:.2}\"", deg as i64, min as i64, sec);
                }
            }
            // Undefined coordinate rationals (0/0 0/0 0/0) yield an empty value.
            if let Some(t) = tags.iter_mut().find(|t| t.name == coord) {
                if t.print_value.split_whitespace().all(|p| p == "undef") {
                    t.print_value = String::new();
                }
            }
        }

        // ExifTool uses the full-resolution sub-IFD (SubfileType = "Full-resolution
        // image") for the primary image dimensions. When such a sub-IFD exists (e.g. the
        // real raw image in a DNG/NEF whose IFD0 is a small reduced-resolution preview),
        // promote its ImageWidth/ImageHeight to the front so they win first-by-name and
        // feed the ImageSize/Megapixels composites.
        let fullres_group = tags
            .iter()
            .find(|t| {
                t.name == "SubfileType"
                    && t.print_value == "Full-resolution image"
                    && t.group.family1 != "IFD0"
            })
            .map(|t| t.group.family1.clone());
        if let Some(group) = fullres_group {
            for dim in ["ImageHeight", "ImageWidth"] {
                if let Some(pos) = tags
                    .iter()
                    .position(|t| t.name == dim && t.group.family1 == group)
                {
                    let t = tags.remove(pos);
                    tags.insert(0, t);
                }
            }
        }

        Ok(tags)
    }

    /// Find MakerNote (tag 0x927C) offset and size in ExifIFD.
    /// Read Sony's private IFD, hung off DNGPrivateData (0xC634).
    ///
    /// Sony writes the tag as a single int32u whose value is where that IFD
    /// starts, rather than as the byte block Adobe puts there.
    fn parse_sony_sr2(data: &[u8], header: &TiffHeader, tags: &mut Vec<Tag>) {
        let ifd0 = header.ifd0_offset as usize;
        if ifd0 + 2 > data.len() {
            return;
        }
        let count = read_u16(data, ifd0, header.byte_order) as usize;
        for i in 0..count {
            let e = ifd0 + 2 + i * 12;
            if e + 12 > data.len() {
                break;
            }
            if read_u16(data, e, header.byte_order) != 0xC634 {
                continue;
            }
            let private_offset = read_u32(data, e + 8, header.byte_order) as usize;
            let le = header.byte_order == ByteOrderMark::LittleEndian;
            tags.extend(crate::metadata::sony_sr2::read(data, private_offset, le));
            return;
        }
    }

    /// Parse DNG PrivateData (0xC634) to extract embedded MakerNotes
    fn parse_dng_private_data(
        data: &[u8],
        header: &TiffHeader,
        make: &str,
        model: &str,
        tags: &mut Vec<Tag>,
    ) {
        // Scan IFD0 for tag 0xC634
        let ifd0_offset = header.ifd0_offset as usize;
        if ifd0_offset + 2 > data.len() {
            return;
        }
        let entry_count = read_u16(data, ifd0_offset, header.byte_order) as usize;
        let entries_start = ifd0_offset + 2;
        for i in 0..entry_count {
            let eoff = entries_start + i * 12;
            if eoff + 12 > data.len() {
                break;
            }
            let tag = read_u16(data, eoff, header.byte_order);
            if tag == 0xC634 {
                let dtype = read_u16(data, eoff + 2, header.byte_order);
                let count = read_u32(data, eoff + 4, header.byte_order) as usize;
                let elem_size = match dtype {
                    1 | 7 => 1,
                    _ => 0,
                };
                let total = elem_size * count;
                if total < 14 {
                    continue;
                }
                let off = read_u32(data, eoff + 8, header.byte_order) as usize;
                if off + total > data.len() {
                    continue;
                }
                let pdata = &data[off..off + total];
                // Parse Adobe DNGPrivateData: "Adobe\0" + blocks
                if !pdata.starts_with(b"Adobe\0") {
                    continue;
                }
                let mut bpos = 6;
                while bpos + 8 <= pdata.len() {
                    let btag = &pdata[bpos..bpos + 4];
                    let bsize = u32::from_be_bytes([
                        pdata[bpos + 4],
                        pdata[bpos + 5],
                        pdata[bpos + 6],
                        pdata[bpos + 7],
                    ]) as usize;
                    bpos += 8;
                    if bpos + bsize > pdata.len() {
                        break;
                    }
                    if btag == b"MakN" && bsize > 6 {
                        let mn_block = &pdata[bpos..bpos + bsize];
                        let mn_bo = if &mn_block[0..2] == b"II" {
                            ByteOrderMark::LittleEndian
                        } else {
                            ByteOrderMark::BigEndian
                        };
                        let mut mn_start = 6; // skip byte order + original offset
                                              // Hack for extra 12 bytes in MakN header (Adobe Camera Raw bug)
                        if bsize >= 18 && &mn_block[6..10] == b"\0\0\0\x01" {
                            mn_start += 12;
                        }
                        if mn_start < bsize {
                            // Emit MakerNoteByteOrder
                            let mn_bo_str = if mn_bo == ByteOrderMark::LittleEndian {
                                "Little-endian (Intel, II)"
                            } else {
                                "Big-endian (Motorola, MM)"
                            };
                            tags.push(Tag {
                                id: TagId::Text("MakerNoteByteOrder".into()),
                                name: "MakerNoteByteOrder".into(),
                                description: "Maker Note Byte Order".into(),
                                group: TagGroup {
                                    family0: "File".into(),
                                    family1: "File".into(),
                                    family2: "Image".into(),
                                    family3: "Main".into(),
                                },
                                raw_value: Value::String(mn_bo_str.into()),
                                print_value: mn_bo_str.into(),
                                priority: 0,
                            });
                            // Canon MakerNotes have a TIFF footer with the original offset.
                            // Sub-table value_offsets are relative to the original file.
                            // We need to pass the full DNG data so offsets resolve correctly.
                            let mn_data_in_block = &mn_block[mn_start..];
                            let mn_abs_offset = off + (bpos - 8 + 8) + mn_start; // absolute offset in DNG file
                                                                                 // Check for Canon TIFF footer (last 8 bytes)
                            let fix_base = if mn_data_in_block.len() > 8 {
                                let footer = &mn_data_in_block[mn_data_in_block.len() - 8..];
                                if (footer[0..2] == *b"II" || footer[0..2] == *b"MM")
                                    && (footer[2..4] == *b"\x2a\x00"
                                        || footer[2..4] == *b"\x00\x2a")
                                {
                                    let old_off = if footer[0] == b'I' {
                                        u32::from_le_bytes([
                                            footer[4], footer[5], footer[6], footer[7],
                                        ])
                                    } else {
                                        u32::from_be_bytes([
                                            footer[4], footer[5], footer[6], footer[7],
                                        ])
                                    } as usize;
                                    if old_off > 0 && mn_abs_offset > old_off {
                                        mn_abs_offset as isize - old_off as isize
                                    } else {
                                        0
                                    }
                                } else {
                                    0
                                }
                            } else {
                                0
                            };

                            let mn_tags = if fix_base != 0 {
                                // Pass full DNG data with corrected offset and base fix
                                crate::metadata::makernotes::parse_makernotes_with_base(
                                    data,
                                    mn_abs_offset,
                                    mn_data_in_block.len(),
                                    make,
                                    model,
                                    mn_bo,
                                    fix_base,
                                )
                            } else {
                                crate::metadata::makernotes::parse_makernotes(
                                    mn_data_in_block,
                                    0,
                                    mn_data_in_block.len(),
                                    make,
                                    model,
                                    mn_bo,
                                )
                            };
                            // DNG MakerNote tags that Perl doesn't emit (conditions/Unknown/offset issues)
                            let dng_suppress = [
                                "AESetting",
                                "CameraISO",
                                "ImageStabilization",
                                "SpotMeteringMode",
                                "RawJpgSize",
                                "Warning",
                            ];
                            for mn_tag in mn_tags {
                                if dng_suppress.contains(&mn_tag.name.as_str()) {
                                    continue;
                                }
                                // No name-collision filtering here: ExifTool
                                // extracts the maker note in full and lets the
                                // duplicate arbitration pick a winner later,
                                // which is the only step the Duplicates option
                                // (and therefore -ee) turns off.
                                tags.push(mn_tag);
                            }
                        }
                    }
                    bpos += bsize;
                }
                break;
            }
        }
    }

    fn find_makernote(data: &[u8], header: &TiffHeader, result: &mut Option<(usize, usize)>) {
        // First find ExifIFD offset from IFD0
        let ifd0_offset = header.ifd0_offset as usize;
        if ifd0_offset + 2 > data.len() {
            return;
        }
        let entry_count = read_u16(data, ifd0_offset, header.byte_order) as usize;
        let entries_start = ifd0_offset + 2;

        for i in 0..entry_count {
            let eoff = entries_start + i * 12;
            if eoff + 12 > data.len() {
                break;
            }
            let tag = read_u16(data, eoff, header.byte_order);
            if tag == 0x8769 {
                // ExifIFD pointer
                let exif_offset = read_u32(data, eoff + 8, header.byte_order) as usize;
                Self::find_makernote_in_ifd(data, header, exif_offset, result);
                break;
            }
        }
    }

    fn find_makernote_in_ifd(
        data: &[u8],
        header: &TiffHeader,
        ifd_offset: usize,
        result: &mut Option<(usize, usize)>,
    ) {
        if ifd_offset + 2 > data.len() {
            return;
        }
        let entry_count = read_u16(data, ifd_offset, header.byte_order) as usize;
        let entries_start = ifd_offset + 2;

        for i in 0..entry_count {
            let eoff = entries_start + i * 12;
            if eoff + 12 > data.len() {
                break;
            }
            let tag = read_u16(data, eoff, header.byte_order);
            if tag == 0x927C {
                let data_type = read_u16(data, eoff + 2, header.byte_order);
                let count = read_u32(data, eoff + 4, header.byte_order) as usize;
                let type_size = match data_type {
                    1 | 2 | 6 | 7 => 1,
                    3 | 8 => 2,
                    4 | 9 | 11 | 13 => 4,
                    5 | 10 | 12 => 8,
                    _ => 1,
                };
                let total_size = type_size * count;

                if total_size <= 4 {
                    // Inline - too small for real MakerNotes
                    break;
                }
                let offset = read_u32(data, eoff + 8, header.byte_order) as usize;
                if offset + total_size <= data.len() {
                    *result = Some((offset, total_size));
                }
                break;
            }
        }
    }

    /// Parse EXIF data from a byte slice with an explicit byte order and offset.
    fn read_ifd(
        data: &[u8],
        header: &TiffHeader,
        offset: u32,
        ifd_name: &str,
        tags: &mut Vec<Tag>,
    ) -> Result<Option<u32>> {
        let offset = offset as usize;
        if offset + 2 > data.len() {
            return Err(Error::InvalidExif(format!(
                "{} offset {} beyond data length {}",
                ifd_name,
                offset,
                data.len()
            )));
        }

        let entry_count = read_u16(data, offset, header.byte_order) as usize;
        let entries_start = offset + 2;
        let _entries_end = entries_start + entry_count * 12;

        // Validate: at minimum, first entry must fit
        if entries_start + 12 > data.len() && entry_count > 0 {
            return Err(Error::InvalidExif(format!(
                "{} entries extend beyond data (need {}, have {})",
                ifd_name,
                entries_start + 12,
                data.len()
            )));
        }
        // Clamp entry count if IFD extends beyond data
        let entry_count = entry_count.min((data.len().saturating_sub(entries_start)) / 12);
        let entries_end = entries_start + entry_count * 12;

        for i in 0..entry_count {
            let entry_offset = entries_start + i * 12;
            let entry = parse_ifd_entry(data, entry_offset, header.byte_order);

            // Check for sub-IFDs (ExifIFD, GPS, Interop)
            match entry.tag {
                0x8769 => {
                    // ExifIFD
                    let sub_offset = entry.value_offset;
                    if (sub_offset as usize) < data.len() {
                        let _ = Self::read_ifd(data, header, sub_offset, "ExifIFD", tags);
                    }
                    continue;
                }
                0x4748 => {
                    // StitchInfo, a binary block Microsoft writes in IFD0
                    // (Exif.pm:1534-1540), little-endian whatever the file is.
                    let total =
                        type_size(entry.data_type).map_or(0, |sz| sz * entry.count as usize);
                    let block: Option<&[u8]> = if total <= 4 {
                        Some(&entry.inline_data[..total.min(4)])
                    } else {
                        let off = entry.value_offset as usize;
                        data.get(off..off + total)
                    };
                    if let Some(block) = block {
                        let mut dm = crate::tags::binary_tables_generated::State::new();
                        tags.extend(crate::tags::binary_tables_generated::decode(
                            "Microsoft::Stitch",
                            block,
                            "",
                            "",
                            ByteOrderMark::LittleEndian,
                            "",
                            "",
                            &mut dm,
                        ));
                    }
                    continue;
                }
                0x8825 => {
                    // GPS IFD
                    let sub_offset = entry.value_offset;
                    if (sub_offset as usize) < data.len() {
                        let _ = Self::read_ifd(data, header, sub_offset, "GPS", tags);
                    }
                    continue;
                }
                0xA005 => {
                    // Interop IFD
                    let sub_offset = entry.value_offset;
                    if (sub_offset as usize) < data.len() {
                        let _ = Self::read_ifd(data, header, sub_offset, "InteropIFD", tags);
                    }
                    continue;
                }
                // PrintIM tag: extract version from "PrintIM" + 4-byte version
                0xC4A5 => {
                    let total_size = match entry.data_type {
                        1 | 2 | 6 | 7 => entry.count as usize,
                        _ => 0,
                    };
                    if total_size >= 12 {
                        let off = entry.value_offset as usize;
                        if off + 12 <= data.len() && &data[off..off + 7] == b"PrintIM" {
                            // "PrintIM\0" is 8 bytes; the 4-byte version follows.
                            let ver =
                                crate::encoding::decode_utf8_or_latin1(&data[off + 8..off + 12])
                                    .trim_end_matches('\0')
                                    .to_string();
                            tags.push(Tag {
                                id: TagId::Text("PrintIMVersion".into()),
                                name: "PrintIMVersion".into(),
                                description: "PrintIM Version".into(),
                                group: TagGroup {
                                    family0: "PrintIM".into(),
                                    family1: "PrintIM".into(),
                                    family2: "Printing".into(),
                                    family3: "Main".into(),
                                },
                                raw_value: Value::String(ver.clone()),
                                print_value: ver,
                                priority: 0,
                            });
                        }
                    }
                    continue; // Suppress raw PrintIM tag
                }
                // GPSAltitude with a 0/0 rational is NOT suppressed: GPS.pm gives a
                // zero-denominator rational the ValueConv string "undef", which the
                // PrintConv `$val =~ /^(inf|undef)$/ ? $val : "$val m"` passes
                // through unchanged (GPS.pm:119-125). So it prints "undef", exactly
                // like the sibling GPSSpeed rational in the same file.
                // Exif.pm 0x201: the name depends on where the tag is and what
                // kind of TIFF this is. In an ARW or an SR2, IFD0 holds the
                // preview, not a thumbnail.
                0x0201 | 0x0202
                    if ifd_name == "IFD0" && matches!(tiff_type().as_str(), "ARW" | "SR2") =>
                {
                    if let Some(val) = read_ifd_value(data, &entry, header.byte_order) {
                        let (name, desc) = if entry.tag == 0x0201 {
                            ("PreviewImageStart", "Preview Image Start")
                        } else {
                            ("PreviewImageLength", "Preview Image Length")
                        };
                        let pv = val.to_display_string();
                        tags.push(Tag {
                            id: TagId::Numeric(entry.tag),
                            name: name.into(),
                            description: desc.into(),
                            group: TagGroup {
                                family0: "EXIF".into(),
                                family1: ifd_name.to_string(),
                                family2: "Image".into(),
                                family3: "Main".into(),
                            },
                            raw_value: val,
                            print_value: pv,
                            priority: 0,
                        });
                    }
                    continue;
                }
                // In SubIFD, tag 0x0201 = JpgFromRawStart (JPEG preview offset)
                0x0201 if ifd_name.starts_with("SubIFD") => {
                    if let Some(val) = read_ifd_value(data, &entry, header.byte_order) {
                        let pv = val.to_display_string();
                        tags.push(Tag {
                            id: TagId::Numeric(entry.tag),
                            name: "JpgFromRawStart".into(),
                            description: "Jpg From Raw Start".into(),
                            group: TagGroup {
                                family0: "EXIF".into(),
                                family1: ifd_name.to_string(),
                                family2: "Image".into(),
                                family3: "Main".into(),
                            },
                            raw_value: val,
                            print_value: pv,
                            priority: 0,
                        });
                    }
                    continue;
                }
                // In SubIFD, tag 0x0202 = JpgFromRawLength (JPEG preview byte count)
                0x0202 if ifd_name.starts_with("SubIFD") => {
                    if let Some(val) = read_ifd_value(data, &entry, header.byte_order) {
                        let pv = val.to_display_string();
                        tags.push(Tag {
                            id: TagId::Numeric(entry.tag),
                            name: "JpgFromRawLength".into(),
                            description: "Jpg From Raw Length".into(),
                            group: TagGroup {
                                family0: "EXIF".into(),
                                family1: ifd_name.to_string(),
                                family2: "Image".into(),
                                family3: "Main".into(),
                            },
                            raw_value: val,
                            print_value: pv,
                            priority: 0,
                        });
                    }
                    continue;
                }
                // SubIFD pointer (0x014A): follow to read SubIFD entries
                0x014A if ifd_name == "IFD0" => {
                    // Read SubIFD offset(s) — may be a single uint32 or array
                    if let Some(val) = read_ifd_value(data, &entry, header.byte_order) {
                        let offsets: Vec<u32> = match &val {
                            Value::U32(v) => vec![*v],
                            Value::List(items) => items
                                .iter()
                                .filter_map(|v| {
                                    if let Value::U32(o) = v {
                                        Some(*o)
                                    } else {
                                        None
                                    }
                                })
                                .collect(),
                            _ => vec![],
                        };
                        for (idx, &off) in offsets.iter().enumerate() {
                            if (off as usize) < data.len() {
                                // ExifTool leaves the first SubIFD unnumbered and
                                // numbers the rest from 1.
                                let sub_name = if idx == 0 {
                                    "SubIFD".to_string()
                                } else {
                                    format!("SubIFD{}", idx)
                                };
                                let before_idx = tags.len();
                                let _ = Self::read_ifd(data, header, off, &sub_name, tags);

                                // Check if this SubIFD has JPEG compression
                                let is_jpeg = tags[before_idx..].iter().any(|t| {
                                    t.name == "Compression"
                                        && (t.print_value.contains("JPEG")
                                            || t.raw_value.as_u64() == Some(6))
                                });

                                // Exif.pm makes 0x111 and 0x117 conditional arrays: the
                                // StripOffsets / StripByteCounts branch (Exif.pm:638 and
                                // Exif.pm:738) is skipped when
                                //   `$$self{TIFF_TYPE} =~ /^(DNG|TIFF)$/ and
                                //    $$self{Compression} eq '7' and $$self{SubfileType} ne '0'`
                                // and the next branch names the tag PreviewImageStart /
                                // PreviewImageLength -- or, in SubIFD2, JpgFromRawStart /
                                // JpgFromRawLength (Exif.pm:664/761, 675/771). It is a RENAME: such
                                // a directory has no StripOffsets at all, which is why
                                // ExifTool reports DNG.dng's IFD0 StripOffsets (13470) as
                                // primary even though SubIFD2 comes later in the file.
                                let is_renamed_offset_pair = tags[before_idx..].iter().any(|t| {
                                    t.name == "Compression" && t.raw_value.as_u64() == Some(7)
                                }) && tags[before_idx..].iter().any(
                                    |t| t.name == "SubfileType" && t.raw_value.as_u64() != Some(0),
                                );

                                if is_jpeg {
                                    // Rename StripOffsets/StripByteCounts based on SubIFD index
                                    // Perl: SubIFD2 → JpgFromRaw*, others → PreviewImage*
                                    let (start_name, len_name, img_name) = if idx == 2 {
                                        ("JpgFromRawStart", "JpgFromRawLength", "JpgFromRaw")
                                    } else {
                                        ("PreviewImageStart", "PreviewImageLength", "PreviewImage")
                                    };
                                    // Find StripOffsets and StripByteCounts in this SubIFD
                                    let strip_off = tags[before_idx..]
                                        .iter()
                                        .find(|t| t.name == "StripOffsets")
                                        .and_then(|t| t.raw_value.as_u64());
                                    let strip_len = tags[before_idx..]
                                        .iter()
                                        .find(|t| t.name == "StripByteCounts")
                                        .and_then(|t| t.raw_value.as_u64());
                                    if let (Some(s), Some(l)) = (strip_off, strip_len) {
                                        tags.push(Tag {
                                            id: TagId::Text(start_name.into()),
                                            name: start_name.into(),
                                            description: start_name.into(),
                                            group: TagGroup {
                                                family0: "EXIF".into(),
                                                family1: sub_name.clone(),
                                                family2: "Preview".into(),
                                                family3: "Main".into(),
                                            },
                                            raw_value: Value::U32(s as u32),
                                            print_value: s.to_string(),
                                            priority: 0,
                                        });
                                        tags.push(Tag {
                                            id: TagId::Text(len_name.into()),
                                            name: len_name.into(),
                                            description: len_name.into(),
                                            group: TagGroup {
                                                family0: "EXIF".into(),
                                                family1: sub_name.clone(),
                                                family2: "Preview".into(),
                                                family3: "Main".into(),
                                            },
                                            raw_value: Value::U32(l as u32),
                                            print_value: l.to_string(),
                                            priority: 0,
                                        });
                                        // Extract binary image data
                                        let s = s as usize;
                                        let l = l as usize;
                                        if l > 0 && s + l <= data.len() {
                                            let pv = format!(
                                                "(Binary data {} bytes, use -b option to extract)",
                                                l
                                            );
                                            tags.push(Tag {
                                                id: TagId::Text(img_name.into()),
                                                name: img_name.into(),
                                                description: img_name.into(),
                                                group: TagGroup {
                                                    family0: "EXIF".into(),
                                                    family1: sub_name.clone(),
                                                    family2: "Preview".into(),
                                                    family3: "Main".into(),
                                                },
                                                raw_value: Value::Binary(data[s..s + l].to_vec()),
                                                print_value: pv,
                                                priority: 0,
                                            });
                                        }
                                    }
                                }

                                if is_renamed_offset_pair {
                                    let mut i = 0usize;
                                    tags.retain(|t| {
                                        let keep = i < before_idx
                                            || !matches!(
                                                t.name.as_str(),
                                                "StripOffsets" | "StripByteCounts"
                                            );
                                        i += 1;
                                        keep
                                    });
                                }

                                // Also handle a SubIFD whose 0x0201/0x0202 pair was
                                // already named JpgFromRawStart/Length when it was read
                                // -- but only if the rename branch above has not already
                                // produced the image, or it would be reported twice.
                                let jpg_done =
                                    tags[before_idx..].iter().any(|t| t.name == "JpgFromRaw");
                                let jpg_start = tags[before_idx..]
                                    .iter()
                                    .find(|t| t.name == "JpgFromRawStart")
                                    .and_then(|t| t.raw_value.as_u64());
                                let jpg_len = tags[before_idx..]
                                    .iter()
                                    .find(|t| t.name == "JpgFromRawLength")
                                    .and_then(|t| t.raw_value.as_u64());
                                if let (false, Some(start), Some(len)) =
                                    (jpg_done, jpg_start, jpg_len)
                                {
                                    let start = start as usize;
                                    let len = len as usize;
                                    if len > 0 && start + len <= data.len() {
                                        let pv = format!(
                                            "(Binary data {} bytes, use -b option to extract)",
                                            len
                                        );
                                        tags.push(Tag {
                                            id: TagId::Text("JpgFromRaw".into()),
                                            name: "JpgFromRaw".into(),
                                            description: "Jpg From Raw".into(),
                                            group: TagGroup {
                                                family0: "EXIF".into(),
                                                family1: sub_name,
                                                family2: "Preview".into(),
                                                family3: "Main".into(),
                                            },
                                            raw_value: Value::Binary(
                                                data[start..start + len].to_vec(),
                                            ),
                                            print_value: pv,
                                            priority: 0,
                                        });
                                    }
                                }
                            }
                        }
                    }
                    continue;
                }
                // CR2 IFD2 (preview JPEG) and IFD3 (raw data) repeat names IFD0
                // already defines. ExifTool reads them all and lets the name-keyed
                // collapse pick IFD0's ImageWidth/ImageHeight/BitsPerSample/
                // Compression and IFD3's StripOffsets/StripByteCounts; with the
                // Duplicates option on it reports every copy, so only skip them
                // when we are collapsing.
                0x0100 | 0x0101 | 0x0102 | 0x0103 | 0x0111 | 0x0117
                    if ifd_name == "IFD2" && !keep_duplicates() =>
                {
                    continue;
                }
                0x0103 if ifd_name == "IFD3" && !keep_duplicates() => {
                    continue;
                }
                _ => {}
            }

            if let Some(mut value) = read_ifd_value(data, &entry, header.byte_order) {
                // GPS TimeStamp (0x0007): convert 0/0 rationals to 0/1 so it displays as "0, 0, 0"
                // (Perl treats 0/0 as 0 for GPS time, enabling GPSDateTime composite)
                if ifd_name == "GPS" && entry.tag == 0x0007 {
                    if let Value::List(ref mut items) = value {
                        for item in items.iter_mut() {
                            if matches!(item, Value::URational(0, 0)) {
                                *item = Value::URational(0, 1);
                            }
                        }
                    }
                }
                let tag_info = exif_tags::lookup(ifd_name, entry.tag);
                let (name, description, family2) = match tag_info {
                    Some(info) => (
                        info.name.to_string(),
                        info.description.to_string(),
                        info.family2.to_string(),
                    ),
                    None => {
                        // Skip known SubDirectory/internal tags that Perl doesn't emit
                        if matches!(
                            entry.tag,
                            // 0x014A handled above (SubIFD traversal)
                            // 0x02BC (ApplicationNotes) now parsed as XMP above
                            0xC634 // DNG PrivateData — processed after IFD scan
                        ) {
                            continue;
                        }
                        // Fallback to generated tags
                        match exif_tags::lookup_generated(entry.tag) {
                            Some((n, d)) => (n.to_string(), d.to_string(), "Other".to_string()),
                            None => {
                                // Perl doesn't emit unknown EXIF tags by default
                                continue;
                            }
                        }
                    }
                };

                // Per-tag RawConv that trims trailing blanks. In Exif.pm only a
                // handful of string tags do this: Make (0x010f), Model (0x0110),
                // Software (0x0131) and Artist (0x013b) each carry
                // `RawConv => '$val =~ s/\s+$//'`, and Copyright (0x8298) strips the
                // blanks preceding its NUL separator (`s/ *\0/\n/; ...; s/\n$//`),
                // which reduces to a trailing-blank trim for the single-part values.
                // Every other EXIF string keeps its fixed-width space padding (the
                // generic 'string' reader only does `s/\0.*//s`); the padding is
                // dropped from text output later by Printable, not from the value.
                if matches!(
                    name.as_str(),
                    "Make" | "Model" | "Software" | "Artist" | "Copyright"
                ) {
                    if let Value::String(ref s) = value {
                        let trimmed = s.trim_end();
                        if trimmed.len() != s.len() {
                            value = Value::String(trimmed.to_string());
                        }
                    }
                }

                // Parse ApplicationNotes (0x02BC) as XMP
                if name == "ApplicationNotes" {
                    if let Value::Binary(ref xmp_bytes) = value {
                        if let Ok(xmp_tags) = crate::metadata::XmpReader::read(xmp_bytes) {
                            tags.extend(xmp_tags);
                        }
                    }
                    continue;
                }
                // Suppress known SubDirectory/internal tags
                if matches!(
                    name.as_str(),
                    "MinSampleValue" | "MaxSampleValue" | // Not emitted by Perl for raw formats
                    "ProcessingSoftware" | // Protected tag, not always emitted
                    "PanasonicTitle" | "PanasonicTitle2" // DNG tags, wrong match for RW2
                ) {
                    continue;
                }

                let print_value = if name.starts_with("Tag0x") && get_show_unknown() >= 2 {
                    // -U mode: show binary data for unknown tags
                    match &value {
                        Value::Binary(bytes) | Value::Undefined(bytes) => bytes
                            .iter()
                            .map(|b| format!("{:02x}", b))
                            .collect::<Vec<_>>()
                            .join(" "),
                        _ => value.to_display_string(),
                    }
                } else if name.starts_with("Tag0x") {
                    // -u mode: show unknown tags but use standard display for values
                    value.to_display_string()
                } else {
                    exif_tags::print_conv(ifd_name, entry.tag, &value)
                        .or_else(|| {
                            // Fallback to generated print conversions
                            value
                                .as_u64()
                                .and_then(|v| {
                                    crate::tags::print_conv_generated::print_conv_by_name(
                                        &name, v as i64,
                                    )
                                })
                                .map(|s| s.to_string())
                        })
                        .unwrap_or_else(|| value.to_display_string())
                };

                // Priority the Exif tables state themselves, whether as an
                // explicit `Priority => 0` or as the `Avoid => 1` that FoundTag
                // resolves to one (ExifTool.pm:9469-9472). Only the IFD tag
                // number identifies it: 0xfe54 Contrast is priority 0 while
                // 0xa408 Contrast is not, so the name alone would be ambiguous.
                let priority =
                    if crate::tags::priority0_generated::exif_is_priority0(entry.tag, &name) {
                        crate::tag::PRIORITY_EXPLICIT_ZERO
                    } else {
                        0
                    };
                tags.push(Tag {
                    id: TagId::Numeric(entry.tag),
                    name,
                    description,
                    group: TagGroup {
                        family0: "EXIF".to_string(),
                        family1: ifd_name.to_string(),
                        family2,
                        family3: "Main".into(),
                    },
                    raw_value: value,
                    print_value,
                    priority,
                });
            }
        }

        // Read next IFD offset
        let next_ifd_offset = if entries_end + 4 <= data.len() {
            read_u32(data, entries_end, header.byte_order)
        } else {
            0
        };
        if next_ifd_offset != 0 && ifd_name == "IFD0" {
            // IFD1 = thumbnail
            let ifd1_start_idx = tags.len();
            let ifd1_next = Self::read_ifd(data, header, next_ifd_offset, "IFD1", tags)
                .ok()
                .flatten();
            // IFD1 (the thumbnail IFD) repeats several IFD0 tags — XResolution,
            // YResolution, ResolutionUnit, Orientation… Collapsing them here would
            // be wrong: ExifTool keeps every instance when the Duplicates option is
            // on, which the CLI turns on together with -ee. IFD1 is a
            // LOW_PRIORITY_DIR, so the general FoundTag pass in exiftool.rs keeps
            // IFD0's copy in the default mode and every copy under -ee. Nothing to
            // suppress at parse time.
            let _ = ifd1_start_idx;

            // Create ThumbnailImage tag if offset+length are present
            let thumb_offset = tags
                .iter()
                .find(|t| t.name == "ThumbnailOffset" && t.group.family1 == "IFD1")
                .and_then(|t| t.raw_value.as_u64());
            let thumb_length = tags
                .iter()
                .find(|t| t.name == "ThumbnailLength" && t.group.family1 == "IFD1")
                .and_then(|t| t.raw_value.as_u64());

            if let (Some(off), Some(len)) = (thumb_offset, thumb_length) {
                let off = off as usize;
                let len = len as usize;
                if off + len <= data.len() && len > 0 {
                    tags.push(Tag {
                        id: TagId::Text("ThumbnailImage".into()),
                        name: "ThumbnailImage".into(),
                        description: "Thumbnail Image".into(),
                        group: TagGroup {
                            family0: "EXIF".into(),
                            family1: "IFD1".into(),
                            family2: "Image".into(),
                            family3: "Main".into(),
                        },
                        raw_value: Value::Binary(data[off..off + len].to_vec()),
                        print_value: format!(
                            "(Binary data {} bytes, use -b option to extract)",
                            len
                        ),
                        priority: 0,
                    });
                }
            }

            // CR2 files have additional IFDs (IFD2, IFD3) following IFD1 in the chain.
            // CR2 is identified by "CR" bytes at offset 8 in the TIFF data.
            let is_cr2 = data.len() > 10 && &data[8..10] == b"CR";
            if is_cr2 {
                if let Some(ifd2_offset) = ifd1_next {
                    // IFD2 = preview JPEG image data (emit selected tags)
                    let ifd2_next = Self::read_ifd(data, header, ifd2_offset, "IFD2", tags)
                        .ok()
                        .flatten();
                    // IFD3 = raw image data (emit CR2CFAPattern, RawImageSegmentation, StripOffsets, StripByteCounts)
                    if let Some(ifd3_offset) = ifd2_next {
                        let _ = Self::read_ifd(data, header, ifd3_offset, "IFD3", tags);
                    }
                }
            }
        }

        Ok(if next_ifd_offset != 0 {
            Some(next_ifd_offset)
        } else {
            None
        })
    }

    /// Parse a TIFF where IFD0 is treated as a named IFD (e.g. "GPS", "ExifIFD").
    /// Used for CR3 CMT4 (GPS-only TIFF) and CMT2 (ExifIFD-only TIFF).
    /// Does no MakerNote/IFD1 processing.
    pub fn read_as_named_ifd(data: &[u8], ifd_name: &str) -> Vec<Tag> {
        let header = match parse_tiff_header(data) {
            Ok(h) => h,
            Err(_) => return Vec::new(),
        };
        let mut tags = Vec::new();
        // Each of these boxes is a TIFF file of its own, and ExifTool's
        // ProcessTIFF raises ExifByteOrder once per TIFF it processes — a CR3
        // therefore reports it for CMT1, CMT2 and CMT4 (verified with -v2 on
        // CanonRaw.cr3; CMT3 goes through the maker-note path and raises none).
        tags.push(Self::exif_byte_order_tag(header.byte_order));
        let _ = Self::read_ifd(data, &header, header.ifd0_offset, ifd_name, &mut tags);
        tags
    }

    /// Parse a single IFD located at `offset` inside a TIFF-like container whose
    /// header this reader cannot parse itself (RW2 uses magic 0x55 instead of
    /// 0x2A). Offsets inside the IFD stay relative to the start of `data`, which
    /// is what a TIFF IFD always uses. No ExifByteOrder and no IFD1 chaining.
    pub fn read_ifd_at(data: &[u8], little_endian: bool, offset: u32, ifd_name: &str) -> Vec<Tag> {
        let header = TiffHeader {
            byte_order: if little_endian {
                ByteOrderMark::LittleEndian
            } else {
                ByteOrderMark::BigEndian
            },
            ifd0_offset: offset,
        };
        let mut tags = Vec::new();
        let _ = Self::read_ifd(data, &header, offset, ifd_name, &mut tags);
        tags
    }
}

fn parse_ifd_entry(data: &[u8], offset: usize, byte_order: ByteOrderMark) -> IfdEntry {
    let tag = read_u16(data, offset, byte_order);
    let data_type = read_u16(data, offset + 2, byte_order);
    let count = read_u32(data, offset + 4, byte_order);
    let value_offset = read_u32(data, offset + 8, byte_order);
    let mut inline_data = [0u8; 4];
    inline_data.copy_from_slice(&data[offset + 8..offset + 12]);

    IfdEntry {
        tag,
        data_type,
        count,
        value_offset,
        inline_data,
    }
}

fn read_ifd_value(data: &[u8], entry: &IfdEntry, byte_order: ByteOrderMark) -> Option<Value> {
    let elem_size = type_size(entry.data_type)?;
    let total_size = elem_size * entry.count as usize;

    let value_data = if total_size <= 4 {
        &entry.inline_data[..total_size]
    } else {
        let offset = entry.value_offset as usize;
        if offset + total_size > data.len() {
            return None;
        }
        &data[offset..offset + total_size]
    };

    // IPTC-NAA (0x83BB): always read as raw binary regardless of declared type
    if entry.tag == 0x83BB {
        return Some(Value::Binary(value_data.to_vec()));
    }

    // ApplicationNotes (0x02BC): always read as raw binary (XMP data)
    if entry.tag == 0x02BC {
        return Some(Value::Binary(value_data.to_vec()));
    }

    match entry.data_type {
        // BYTE
        1 => {
            if entry.count == 1 {
                Some(Value::U8(value_data[0]))
            } else {
                Some(Value::List(
                    value_data.iter().map(|&b| Value::U8(b)).collect(),
                ))
            }
        }
        // ASCII
        2 => {
            let s = crate::encoding::decode_utf8_or_latin1(value_data);
            // ExifTool truncates at the first null only (ExifTool.pm:10038
            // `$val =~ s/\0.*//s`). Trailing blanks that pad a fixed-width field
            // (e.g. "OLYMPUS DIGITAL CAMERA         ") are PRESERVED in the stored
            // value; they are stripped only at text-output time by Printable
            // (exiftool:3009 `$val =~ s/\s+$//`), which our text path mirrors in
            // sanitize_display_value. JSON output keeps them, matching ExifTool.
            let s = s.split('\0').next().unwrap_or("").to_string();
            Some(Value::String(s))
        }
        // SHORT
        3 => {
            if entry.count == 1 {
                Some(Value::U16(read_u16(value_data, 0, byte_order)))
            } else {
                let vals: Vec<Value> = (0..entry.count as usize)
                    .map(|i| Value::U16(read_u16(value_data, i * 2, byte_order)))
                    .collect();
                Some(Value::List(vals))
            }
        }
        // LONG
        4 | 13 => {
            if entry.count == 1 {
                Some(Value::U32(read_u32(value_data, 0, byte_order)))
            } else {
                let vals: Vec<Value> = (0..entry.count as usize)
                    .map(|i| Value::U32(read_u32(value_data, i * 4, byte_order)))
                    .collect();
                Some(Value::List(vals))
            }
        }
        // RATIONAL (unsigned)
        5 => {
            if entry.count == 1 {
                let n = read_u32(value_data, 0, byte_order);
                let d = read_u32(value_data, 4, byte_order);
                Some(Value::URational(n, d))
            } else {
                let vals: Vec<Value> = (0..entry.count as usize)
                    .map(|i| {
                        let n = read_u32(value_data, i * 8, byte_order);
                        let d = read_u32(value_data, i * 8 + 4, byte_order);
                        Value::URational(n, d)
                    })
                    .collect();
                Some(Value::List(vals))
            }
        }
        // SBYTE
        6 => {
            if entry.count == 1 {
                Some(Value::I16(value_data[0] as i8 as i16))
            } else {
                let vals: Vec<Value> = value_data
                    .iter()
                    .map(|&b| Value::I16(b as i8 as i16))
                    .collect();
                Some(Value::List(vals))
            }
        }
        // UNDEFINED
        7 => Some(Value::Undefined(value_data.to_vec())),
        // SSHORT
        8 => {
            if entry.count == 1 {
                Some(Value::I16(read_i16(value_data, 0, byte_order)))
            } else {
                let vals: Vec<Value> = (0..entry.count as usize)
                    .map(|i| Value::I16(read_i16(value_data, i * 2, byte_order)))
                    .collect();
                Some(Value::List(vals))
            }
        }
        // SLONG
        9 => {
            if entry.count == 1 {
                Some(Value::I32(read_i32(value_data, 0, byte_order)))
            } else {
                let vals: Vec<Value> = (0..entry.count as usize)
                    .map(|i| Value::I32(read_i32(value_data, i * 4, byte_order)))
                    .collect();
                Some(Value::List(vals))
            }
        }
        // SRATIONAL
        10 => {
            if entry.count == 1 {
                let n = read_i32(value_data, 0, byte_order);
                let d = read_i32(value_data, 4, byte_order);
                Some(Value::IRational(n, d))
            } else {
                let vals: Vec<Value> = (0..entry.count as usize)
                    .map(|i| {
                        let n = read_i32(value_data, i * 8, byte_order);
                        let d = read_i32(value_data, i * 8 + 4, byte_order);
                        Value::IRational(n, d)
                    })
                    .collect();
                Some(Value::List(vals))
            }
        }
        // FLOAT
        11 => {
            if entry.count == 1 {
                let bits = read_u32(value_data, 0, byte_order);
                Some(Value::F32(f32::from_bits(bits)))
            } else {
                let vals: Vec<Value> = (0..entry.count as usize)
                    .map(|i| {
                        let bits = read_u32(value_data, i * 4, byte_order);
                        Value::F32(f32::from_bits(bits))
                    })
                    .collect();
                Some(Value::List(vals))
            }
        }
        // DOUBLE
        12 => {
            if entry.count == 1 {
                let bits = read_u64(value_data, 0, byte_order);
                Some(Value::F64(f64::from_bits(bits)))
            } else {
                let vals: Vec<Value> = (0..entry.count as usize)
                    .map(|i| {
                        let bits = read_u64(value_data, i * 8, byte_order);
                        Value::F64(f64::from_bits(bits))
                    })
                    .collect();
                Some(Value::List(vals))
            }
        }
        _ => None,
    }
}

// Byte-order-aware read helpers
fn read_u16(data: &[u8], offset: usize, bo: ByteOrderMark) -> u16 {
    match bo {
        ByteOrderMark::LittleEndian => LittleEndian::read_u16(&data[offset..]),
        ByteOrderMark::BigEndian => BigEndian::read_u16(&data[offset..]),
    }
}

fn read_u32(data: &[u8], offset: usize, bo: ByteOrderMark) -> u32 {
    match bo {
        ByteOrderMark::LittleEndian => LittleEndian::read_u32(&data[offset..]),
        ByteOrderMark::BigEndian => BigEndian::read_u32(&data[offset..]),
    }
}

fn read_u64(data: &[u8], offset: usize, bo: ByteOrderMark) -> u64 {
    match bo {
        ByteOrderMark::LittleEndian => LittleEndian::read_u64(&data[offset..]),
        ByteOrderMark::BigEndian => BigEndian::read_u64(&data[offset..]),
    }
}

fn read_i16(data: &[u8], offset: usize, bo: ByteOrderMark) -> i16 {
    match bo {
        ByteOrderMark::LittleEndian => LittleEndian::read_i16(&data[offset..]),
        ByteOrderMark::BigEndian => BigEndian::read_i16(&data[offset..]),
    }
}

fn read_i32(data: &[u8], offset: usize, bo: ByteOrderMark) -> i32 {
    match bo {
        ByteOrderMark::LittleEndian => LittleEndian::read_i32(&data[offset..]),
        ByteOrderMark::BigEndian => BigEndian::read_i32(&data[offset..]),
    }
}

/// Process GeoTIFF key directory (tag GeoTiffDirectory / GeoKeyDirectory)
/// and replace raw directory/ascii/double params with named GeoTIFF tags.
fn process_geotiff_keys(tags: &mut Vec<Tag>) {
    // Extract GeoTiffDirectory values
    let dir_vals: Option<Vec<u16>> =
        tags.iter()
            .find(|t| t.name == "GeoTiffDirectory")
            .and_then(|t| match &t.raw_value {
                Value::List(items) => {
                    let vals: Vec<u16> = items
                        .iter()
                        .filter_map(|v| match v {
                            Value::U16(x) => Some(*x),
                            Value::U32(x) => Some(*x as u16),
                            _ => None,
                        })
                        .collect();
                    if vals.is_empty() {
                        None
                    } else {
                        Some(vals)
                    }
                }
                _ => None,
            });

    let dir_vals = match dir_vals {
        Some(v) => v,
        None => return,
    };

    if dir_vals.len() < 4 {
        return;
    }

    let version = dir_vals[0];
    let revision = dir_vals[1];
    let minor_rev = dir_vals[2];
    let num_entries = dir_vals[3] as usize;

    if dir_vals.len() < 4 + num_entries * 4 {
        return;
    }

    // Extract ASCII params
    let ascii_params: Option<String> = tags
        .iter()
        .find(|t| t.name == "GeoTiffAsciiParams")
        .map(|t| t.print_value.clone());

    // Extract double params
    let double_params: Option<Vec<f64>> = tags
        .iter()
        .find(|t| t.name == "GeoTiffDoubleParams")
        .and_then(|t| match &t.raw_value {
            Value::List(items) => {
                let vals: Vec<f64> = items
                    .iter()
                    .filter_map(|v| match v {
                        Value::F64(x) => Some(*x),
                        Value::F32(x) => Some(*x as f64),
                        _ => None,
                    })
                    .collect();
                if vals.is_empty() {
                    None
                } else {
                    Some(vals)
                }
            }
            _ => None,
        });

    let mut new_tags = Vec::new();

    // Version tag
    new_tags.push(Tag {
        id: TagId::Text("GeoTiffVersion".to_string()),
        name: "GeoTiffVersion".to_string(),
        description: "GeoTiff Version".to_string(),
        group: TagGroup {
            // GeoTiff.pm's own group, not the IFD0 tag that carries the keys.
            family0: "GeoTiff".into(),
            family1: "GeoTiff".into(),
            family2: "Location".into(),
            family3: "Main".into(),
        },
        raw_value: Value::String(format!("{}.{}.{}", version, revision, minor_rev)),
        print_value: format!("{}.{}.{}", version, revision, minor_rev),
        priority: 0,
    });

    // Process each GeoKey
    for i in 0..num_entries {
        let base = 4 + i * 4;
        let key_id = dir_vals[base];
        let location = dir_vals[base + 1];
        let count = dir_vals[base + 2] as usize;
        let value_or_offset = dir_vals[base + 3];

        let raw_val: Option<String> = match location {
            0 => {
                // Value stored inline in value_or_offset
                Some(format!("{}", value_or_offset))
            }
            34737 => {
                // ASCII params
                if let Some(ref ascii) = ascii_params {
                    let off = value_or_offset as usize;
                    let end = (off + count).min(ascii.len());
                    if off <= end {
                        let s = &ascii[off..end];
                        // Remove trailing '|' separators
                        let s = s.trim_end_matches('|').trim().to_string();
                        Some(s)
                    } else {
                        None
                    }
                } else {
                    None
                }
            }
            34736 => {
                // Double params
                if let Some(ref doubles) = double_params {
                    let off = value_or_offset as usize;
                    if count == 1 && off < doubles.len() {
                        Some(format!("{}", doubles[off]))
                    } else if count > 1 {
                        let vals: Vec<String> = doubles
                            .iter()
                            .skip(off)
                            .take(count)
                            .map(|v| format!("{}", v))
                            .collect();
                        Some(vals.join(" "))
                    } else {
                        None
                    }
                } else {
                    None
                }
            }
            _ => None,
        };

        let val_str = match raw_val {
            Some(v) => v,
            None => continue,
        };

        // Map GeoKey ID to tag name and print value
        let (tag_name, print_val) = geotiff_key_to_tag(key_id, &val_str);
        if tag_name.is_empty() {
            continue;
        }

        new_tags.push(Tag {
            id: TagId::Text(tag_name.clone()),
            name: tag_name.clone(),
            description: tag_name.clone(),
            group: TagGroup {
                // GeoTIFF keys travel inside an IFD0 tag, but ExifTool reads
                // them with GeoTiff.pm, a group of its own -- same as the
                // GeoTiffVersion tag emitted just above.
                family0: "GeoTiff".into(),
                family1: "GeoTiff".into(),
                family2: "Location".into(),
                family3: "Main".into(),
            },
            raw_value: Value::String(val_str),
            print_value: print_val,
            priority: 0,
        });
    }

    if !new_tags.is_empty() {
        // Remove raw GeoTIFF tags
        tags.retain(|t| {
            t.name != "GeoTiffDirectory"
                && t.name != "GeoTiffAsciiParams"
                && t.name != "GeoTiffDoubleParams"
        });
        tags.extend(new_tags);
    }
}

/// Map a GeoKey ID to (tag_name, print_value).
fn geotiff_key_to_tag(key_id: u16, value: &str) -> (String, String) {
    let val_u16: Option<u16> = value.parse().ok();

    match key_id {
        // Section 6.2.1: GeoTIFF Configuration Keys
        0x0001 => return ("GeoTiffVersion".to_string(), value.to_string()), // not used here
        0x0400 => {
            // GTModelType
            let print = match val_u16 {
                Some(1) => "Projected".to_string(),
                Some(2) => "Geographic".to_string(),
                Some(3) => "Geocentric".to_string(),
                Some(32767) => "User Defined".to_string(),
                _ => value.to_string(),
            };
            return ("GTModelType".to_string(), print);
        }
        0x0401 => {
            // GTRasterType
            let print = match val_u16 {
                Some(1) => "Pixel Is Area".to_string(),
                Some(2) => "Pixel Is Point".to_string(),
                Some(32767) => "User Defined".to_string(),
                _ => value.to_string(),
            };
            return ("GTRasterType".to_string(), print);
        }
        0x0402 => return ("GTCitation".to_string(), value.to_string()),

        // Section 6.2.2: Geographic CS Parameter Keys
        0x0800 => {
            return (
                "GeographicType".to_string(),
                geotiff_pcs_name(val_u16.unwrap_or(0), value),
            )
        }
        0x0801 => return ("GeogCitation".to_string(), value.to_string()),
        0x0802 => {
            let print = match val_u16 {
                Some(32767) | Some(32766) => "User Defined".to_string(),
                _ => value.to_string(),
            };
            return ("GeogGeodeticDatum".to_string(), print);
        }
        0x0803 => return ("GeogPrimeMeridian".to_string(), value.to_string()),
        0x0804 => {
            return (
                "GeogLinearUnits".to_string(),
                geotiff_linear_unit_name(val_u16.unwrap_or(0), value),
            )
        }
        0x0805 => return ("GeogLinearUnitSize".to_string(), value.to_string()),
        0x0806 => return ("GeogAngularUnits".to_string(), value.to_string()),
        0x0807 => return ("GeogAngularUnitSize".to_string(), value.to_string()),
        0x0808 => return ("GeogEllipsoid".to_string(), value.to_string()),
        0x0809 => return ("GeogSemiMajorAxis".to_string(), value.to_string()),
        0x080a => return ("GeogSemiMinorAxis".to_string(), value.to_string()),
        0x080b => return ("GeogInvFlattening".to_string(), value.to_string()),
        0x080c => return ("GeogAzimuthUnits".to_string(), value.to_string()),
        0x080d => return ("GeogPrimeMeridianLong".to_string(), value.to_string()),

        // Section 6.2.3: Projected CS Parameter Keys
        0x0C00 => {
            // ProjectedCSType
            return (
                "ProjectedCSType".to_string(),
                geotiff_pcs_name(val_u16.unwrap_or(0), value),
            );
        }
        0x0C01 => return ("PCSCitation".to_string(), value.to_string()),
        0x0C02 => {
            // UTM zones follow a regular range in GeoTiff.pm's Projection table:
            // 16001-16060 = UTM zone N (north), 16101-16160 = UTM zone N (south).
            let print = match val_u16 {
                Some(v @ 16001..=16060) => format!("UTM zone {}N", v - 16000),
                Some(v @ 16101..=16160) => format!("UTM zone {}S", v - 16100),
                Some(32767) | Some(32766) => "User Defined".to_string(),
                _ => value.to_string(),
            };
            return ("Projection".to_string(), print);
        }
        0x0C03 => return ("ProjCoordTrans".to_string(), value.to_string()),
        0x0C04 => {
            return (
                "ProjLinearUnits".to_string(),
                geotiff_linear_unit_name(val_u16.unwrap_or(0), value),
            )
        }
        0x0C05 => return ("ProjLinearUnitSize".to_string(), value.to_string()),
        0x0C06 => return ("ProjStdParallel1".to_string(), value.to_string()),
        0x0C07 => return ("ProjStdParallel2".to_string(), value.to_string()),
        0x0C08 => return ("ProjNatOriginLong".to_string(), value.to_string()),
        0x0C09 => return ("ProjNatOriginLat".to_string(), value.to_string()),
        0x0c0a => return ("ProjFalseEasting".to_string(), value.to_string()),
        0x0c0b => return ("ProjFalseNorthing".to_string(), value.to_string()),
        0x0c0c => return ("ProjFalseOriginLong".to_string(), value.to_string()),
        0x0c0d => return ("ProjFalseOriginLat".to_string(), value.to_string()),
        0x0c0e => return ("ProjFalseOriginEasting".to_string(), value.to_string()),
        0x0c0f => return ("ProjFalseOriginNorthing".to_string(), value.to_string()),
        0x0C10 => return ("ProjCenterLong".to_string(), value.to_string()),
        0x0C11 => return ("ProjCenterLat".to_string(), value.to_string()),
        0x0C12 => return ("ProjCenterEasting".to_string(), value.to_string()),
        0x0C13 => return ("ProjCenterNorthing".to_string(), value.to_string()),
        0x0C14 => return ("ProjScaleAtNatOrigin".to_string(), value.to_string()),
        0x0C15 => return ("ProjScaleAtCenter".to_string(), value.to_string()),
        0x0C16 => return ("ProjAzimuthAngle".to_string(), value.to_string()),
        0x0C17 => return ("ProjStraightVertPoleLong".to_string(), value.to_string()),

        // Section 6.2.4: Vertical CS Keys
        0x1000 => return ("VerticalCSType".to_string(), value.to_string()),
        0x1001 => return ("VerticalCitation".to_string(), value.to_string()),
        0x1002 => return ("VerticalDatum".to_string(), value.to_string()),
        0x1003 => {
            return (
                "VerticalUnits".to_string(),
                geotiff_linear_unit_name(val_u16.unwrap_or(0), value),
            )
        }

        _ => {}
    }
    (String::new(), String::new())
}

fn geotiff_linear_unit_name(val: u16, fallback: &str) -> String {
    match val {
        9001 => "Linear Meter".to_string(),
        9002 => "Linear Foot".to_string(),
        9003 => "Linear Foot US Survey".to_string(),
        9004 => "Linear Foot Modified American".to_string(),
        9005 => "Linear Foot Clarke".to_string(),
        9006 => "Linear Foot Indian".to_string(),
        9007 => "Linear Link".to_string(),
        9008 => "Linear Link Benoit".to_string(),
        9009 => "Linear Link Sears".to_string(),
        9010 => "Linear Chain Benoit".to_string(),
        9011 => "Linear Chain Sears".to_string(),
        9012 => "Linear Yard Sears".to_string(),
        9013 => "Linear Yard Indian".to_string(),
        9014 => "Linear Fathom".to_string(),
        9015 => "Linear Mile International Nautical".to_string(),
        _ => fallback.to_string(),
    }
}

fn geotiff_pcs_name(val: u16, fallback: &str) -> String {
    // Common PCS codes - just return the code with description for common ones
    match val {
        26918 => "NAD83 UTM zone 18N".to_string(),
        26919 => "NAD83 UTM zone 19N".to_string(),
        32618 => "WGS84 UTM zone 18N".to_string(),
        32619 => "WGS84 UTM zone 19N".to_string(),
        4326 => "WGS 84".to_string(),
        4269 => "NAD83".to_string(),
        4267 => "NAD27".to_string(),
        32767 => "User Defined".to_string(),
        _ => fallback.to_string(),
    }
}