//
// Copyright (c) 2017 KAMADA Ken'ichi.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
// SUCH DAMAGE.
//

//! Read, write, re-read, and compare the results.
//!
//! This test can be also compiled as a command-line program.

extern crate exif;

use std::env;
use std::fs::File;
use std::io::{BufReader, Cursor};
use std::path::Path;

use exif::experimental::Writer;
#[cfg(not(test))]
use exif::Error;
use exif::{Exif, In, Reader, Tag, Value};

#[test]
fn exif_heic() {
    rwr_compare("tests/exif.heic");
}

#[test]
fn exif_jpg() {
    rwr_compare("tests/exif.jpg");
}

#[test]
fn exif_png() {
    rwr_compare("tests/exif.png");
}

#[test]
fn exif_tif() {
    rwr_compare("tests/exif.tif");
}

#[test]
fn exif_webp() {
    rwr_compare("tests/exif.webp");
}

fn main() {
    for path in env::args_os().skip(1) {
        rwr_compare(&path);
    }
}

fn rwr_compare<P>(path: P)
where
    P: AsRef<Path>,
{
    let path = path.as_ref();

    // Read.
    let file = File::open(path).unwrap();
    let mut bufreader = BufReader::new(&file);
    #[cfg(test)]
    let exif1 = Reader::new().read_from_container(&mut bufreader).unwrap();
    #[cfg(not(test))]
    let exif1 = match Reader::new().read_from_container(&mut bufreader) {
        Ok(exif) => exif,
        Err(e) => {
            println!("{}: {}: Skipped", path.display(), e);
            return;
        }
    };
    let strips = get_strips(&exif1, In::PRIMARY);
    let tn_strips = get_strips(&exif1, In::THUMBNAIL);
    let tiles = get_tiles(&exif1, In::PRIMARY);
    let tn_jpeg = get_jpeg(&exif1, In::THUMBNAIL);

    // Write.
    let mut writer = Writer::new();
    for f in exif1.fields() {
        writer.push_field(f);
    }
    if let Some(ref strips) = strips {
        writer.set_strips(strips, In::PRIMARY);
    }
    if let Some(ref tn_strips) = tn_strips {
        writer.set_strips(tn_strips, In::THUMBNAIL);
    }
    if let Some(ref tiles) = tiles {
        writer.set_tiles(tiles, In::PRIMARY);
    }
    if let Some(ref tn_jpeg) = tn_jpeg {
        writer.set_jpeg(tn_jpeg, In::THUMBNAIL);
    }
    let mut out = Cursor::new(Vec::new());
    #[cfg(test)]
    writer.write(&mut out, exif1.little_endian()).unwrap();
    #[cfg(not(test))]
    match writer.write(&mut out, exif1.little_endian()) {
        Ok(_) => {}
        Err(Error::NotSupported(_)) => {
            println!("{}: Contains unknown type", path.display());
            return;
        }
        e => e.unwrap(),
    }
    let out = out.into_inner();

    // Re-read.
    let exif2 = Reader::new().read_raw(out).unwrap();

    // Sort the fields (some files have wrong tag order).
    let mut fields1 = exif1.fields().collect::<Vec<_>>();
    fields1.sort_by_key(|f| (f.ifd_num, f.tag));
    let mut fields2 = exif2.fields().collect::<Vec<_>>();
    fields2.sort_by_key(|f| (f.ifd_num, f.tag));

    // Compare.
    assert_eq!(fields1.len(), fields2.len());
    for (f1, f2) in fields1.iter().zip(fields2.iter()) {
        assert_eq!(f1.tag, f2.tag);
        assert_eq!(f1.ifd_num, f2.ifd_num);
        match f1.tag {
            Tag::StripOffsets | Tag::TileOffsets | Tag::JPEGInterchangeFormat => continue,
            _ => {}
        }
        compare_field_value(&f1.value, &f2.value);
    }
    assert_eq!(get_strips(&exif2, In::PRIMARY), strips);
    assert_eq!(get_strips(&exif2, In::THUMBNAIL), tn_strips);
    assert_eq!(get_tiles(&exif2, In::PRIMARY), tiles);
    assert_eq!(get_jpeg(&exif2, In::THUMBNAIL), tn_jpeg);
}

// Compare field values.
fn compare_field_value(value1: &Value, value2: &Value) {
    // The TIFF standard requires that BYTE, SHORT, or LONG values should
    // be accepted for any unsigned integer field.
    if let (Some(it1), Some(it2)) = (value1.iter_uint(), value2.iter_uint()) {
        assert!(it1.eq(it2));
        return;
    }
    // Compare other fields strictly.
    match (value1, value2) {
        (&Value::Ascii(ref v1), &Value::Ascii(ref v2)) => assert_eq!(v1, v2),
        (&Value::Rational(ref v1), &Value::Rational(ref v2)) => {
            assert_eq!(v1.len(), v2.len());
            for (r1, r2) in v1.iter().zip(v2.iter()) {
                assert_eq!(r1.num, r2.num);
                assert_eq!(r1.denom, r2.denom);
            }
        }
        (&Value::SByte(ref v1), &Value::SByte(ref v2)) => assert_eq!(v1, v2),
        (&Value::Undefined(ref v1, _), &Value::Undefined(ref v2, _)) => assert_eq!(v1, v2),
        (&Value::SShort(ref v1), &Value::SShort(ref v2)) => assert_eq!(v1, v2),
        (&Value::SLong(ref v1), &Value::SLong(ref v2)) => assert_eq!(v1, v2),
        (&Value::SRational(ref v1), &Value::SRational(ref v2)) => {
            assert_eq!(v1.len(), v2.len());
            for (r1, r2) in v1.iter().zip(v2.iter()) {
                assert_eq!(r1.num, r2.num);
                assert_eq!(r1.denom, r2.denom);
            }
        }
        (&Value::Float(ref v1), &Value::Float(ref v2)) => assert_eq!(v1, v2),
        (&Value::Double(ref v1), &Value::Double(ref v2)) => assert_eq!(v1, v2),
        _ => panic!("{:?} != {:?}", value1, value2),
    }
}

fn get_strips<Buf: AsRef<[u8]>>(exif: &Exif<Buf>, ifd_num: In) -> Option<Vec<&[u8]>> {
    let offsets = exif
        .get_field(Tag::StripOffsets, ifd_num)
        .and_then(|f| f.value.iter_uint());
    let counts = exif
        .get_field(Tag::StripByteCounts, ifd_num)
        .and_then(|f| f.value.iter_uint());
    let (offsets, counts) = match (offsets, counts) {
        (Some(offsets), Some(counts)) => (offsets, counts),
        (None, None) => return None,
        _ => panic!("inconsistent strip offsets and byte counts"),
    };
    let buf = exif.buf();
    assert_eq!(offsets.len(), counts.len());
    let strips = offsets
        .zip(counts)
        .map(|(ofs, cnt)| &buf[ofs as usize..(ofs + cnt) as usize])
        .collect();
    Some(strips)
}

fn get_tiles<Buf: AsRef<[u8]>>(exif: &Exif<Buf>, ifd_num: In) -> Option<Vec<&[u8]>> {
    let offsets = exif
        .get_field(Tag::TileOffsets, ifd_num)
        .and_then(|f| f.value.iter_uint());
    let counts = exif
        .get_field(Tag::TileByteCounts, ifd_num)
        .and_then(|f| f.value.iter_uint());
    let (offsets, counts) = match (offsets, counts) {
        (Some(offsets), Some(counts)) => (offsets, counts),
        (None, None) => return None,
        _ => panic!("inconsistent tile offsets and byte counts"),
    };
    assert_eq!(offsets.len(), counts.len());
    let buf = exif.buf();
    let strips = offsets
        .zip(counts)
        .map(|(ofs, cnt)| &buf[ofs as usize..(ofs + cnt) as usize])
        .collect();
    Some(strips)
}

fn get_jpeg<Buf: AsRef<[u8]>>(exif: &Exif<Buf>, ifd_num: In) -> Option<&[u8]> {
    let offset = exif
        .get_field(Tag::JPEGInterchangeFormat, ifd_num)
        .and_then(|f| f.value.get_uint(0));
    let len = exif
        .get_field(Tag::JPEGInterchangeFormatLength, ifd_num)
        .and_then(|f| f.value.get_uint(0));
    let (offset, len) = match (offset, len) {
        (Some(offset), Some(len)) => (offset as usize, len as usize),
        (None, None) => return None,
        _ => panic!("inconsistent JPEG offset and length"),
    };
    let buf = exif.buf();
    Some(&buf[offset..offset + len])
}