//             DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
//                    Version 2, December 2004
//
// Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
//
// Everyone is permitted to copy and distribute verbatim or modified
// copies of this license document, and changing it is allowed as long
// as the name is changed.
//
//            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
//   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
//
//  0. You just DO WHAT THE FUCK YOU WANT TO.
//
// Author: zadig <thomas chr(0x40) bailleux.me>

use std;
use std::io::Read;

/// An OLE file reader.
///
/// The parsing method follows the same method described here:
/// <http://www.openoffice.org/sc/compdocfileformat.pdf>
///
/// # Basic Example
///
/// ```
/// use ole::OLEReader;
///
/// let mut reader =
///       OLEReader::<std::fs::File>::from_path("assets/Thumbs.db").unwrap();
///
/// println!("This OLE file stores the following entries: ");
/// for entry in reader.iterate() {
///   println!("{}", entry);
/// }
/// ```
#[derive(Debug)]
pub struct OLEReader<T>
  where T: Read {

  /// Buffer for reading from the source.
  pub(crate) buf_reader: Option<std::io::BufReader<T>>,

  /// Unique identifier.
  pub(crate) uid: std::vec::Vec<u8>,

  /// Revision number.
  pub(crate) revision_number: Option<u16>,

  /// Version number.
  pub(crate) version_number: Option<u16>,

  /// Size of one sector.
  pub(crate) sec_size: Option<usize>,

  /// Size of one short sector.
  pub(crate) short_sec_size: Option<usize>,

  /// Sector Allocation Table.
  pub(crate) sat: Option<std::vec::Vec<u32>>,

  /// Directory Sector Allocation Table.
  pub(crate) dsat: Option<std::vec::Vec<u32>>,

  /// Minimum size of a standard stream size.
  pub(crate) minimum_standard_stream_size: Option<usize>,

  /// Short Sector Allocation Table.
  pub(crate) ssat: Option<std::vec::Vec<u32>>,

  /// Master Sector Allocation Table.
  pub(crate) msat: Option<std::vec::Vec<u32>>,

  /// Body of the file.
  pub(crate) body: Option<std::vec::Vec<u8>>,

  /// Directory entries.
  pub(crate) entries: Option<std::vec::Vec<super::entry::OLEEntry>>,

  /// DirID of the root entry.
  pub(crate) root_entry: Option<u32>
}


impl<T> OLEReader<T>
  where T: std::io::Read {

  /// Constructs a new `OLEReader<T>`.
  ///
  /// # Examples
  ///
  /// ```
  /// use ole;
  /// let mut my_resume = std::fs::File::open("assets/Thumbs.db").unwrap();
  /// let mut parser = ole::OLEReader::new(my_resume).unwrap();
  /// ```
  pub fn new(readable: T) -> std::result::Result<OLEReader<T>, super::error::OLEError> {
    let mut t = OLEReader {
      buf_reader: Some(std::io::BufReader::new(readable)),
      uid: vec![0u8; super::constants::UID_SIZE],
      revision_number: None,
      version_number: None,
      sec_size: None,
      short_sec_size: None,
      sat: None,
      dsat: None,
      minimum_standard_stream_size: None,
      ssat: None,
      msat: None,
      body: None,
      entries: None,
      root_entry: None
    };
    t.parse_header()?;
    t.build_sat()?;
    t.build_directory_entries()?;
    Ok(t)
  }


  /// Constructs a new `OLEReader<std::fs::File>`.
  ///
  /// # Examples
  ///
  /// ```
  /// use ole;
  /// let mut parser = ole::OLEReader::<std::fs::File>::from_path("assets/Thumbs.db").unwrap();
  /// ```
  pub fn from_path(path: &str) -> Result<OLEReader<std::fs::File>, super::error::OLEError> {
    let f = std::fs::File::open(path).map_err(super::error::OLEError::IOError)?;
    OLEReader::new(f)
  }


  /// Returns an iterator for directory entries of the OLE file.
  ///
  /// # Examples
  ///
  /// ```
  /// use ole;
  /// let mut parser = ole::OLEReader::<std::fs::File>::from_path("assets/Thumbs.db").unwrap();
  ///
  /// for entry in parser.iterate() {
  ///   println!("OLEEntry {}", entry.name());
  /// }
  /// ```
  pub fn iterate(&self) -> super::iterator::OLEIterator<T> {
    super::iterator::OLEIterator::<T>::new(self)
  }

  /// Read some bytes from the source.
  pub(crate) fn read(&mut self, buf: &mut [u8]) -> Result<usize, super::error::OLEError> {
    use std::io::Read;
    self.buf_reader.as_mut().unwrap().read_exact(buf).map_err(super::error::OLEError::IOError)?;
    Ok(buf.len())
  }

}


#[cfg(test)]
mod tests {

  use std;
  use super::OLEReader;
  use std::error::Error as e;
  use super::super::error::OLEError;
  #[test]
  fn instance_nok() {
    let path = "Thumbs.db";
    let o : Result<OLEReader<std::fs::File>, OLEError> = OLEReader::<std::fs::File>::from_path(path);
    assert_eq!(o.is_ok(), false);
    let e = o.unwrap_err();
    println!("NOK: {}", e.description());
  }

  #[test]
  fn instance_ok() {
    let path = "./assets/Thumbs.db";
    let o: Result<OLEReader<std::fs::File>, OLEError> = OLEReader::<std::fs::File>::from_path(path);
    assert_eq!(o.is_ok(), true);
  }

  #[test]
  fn sector_sizes() {
    let ole: OLEReader<std::fs::File> = OLEReader::<std::fs::File>::from_path("./assets/Thumbs.db").unwrap();
    assert_eq!(ole.sec_size, Some(512));
    assert_eq!(ole.short_sec_size, Some(64));
  }

  #[test]
  fn array_bad_identifier() {
    let mut vec = super::super::constants::IDENTIFIER.to_vec();
    vec[0] = 0xD1;
    fill(&mut vec);
    let ole = OLEReader::new(&vec[..]);
    assert_eq!(ole.is_ok(), false);
    println!("BAD IDENTIFIER: {}", ole.unwrap_err());
  }

  fn fill(buf: &mut std::vec::Vec<u8>) {
    let missing = vec![0u8; super::super::constants::HEADER_SIZE - buf.len()];
    buf.extend(missing);
  }

  #[test]
  fn array_bad_endianness_identifier() {
    let mut vec = super::super::constants::IDENTIFIER.to_vec();
    vec.extend(vec![0u8; 20]);
    vec.push(0xFE);
    vec.push(0xFE);
    fill(&mut vec);
    let ole = OLEReader::new(&vec[..]);
    assert_eq!(ole.is_ok(), false);
    println!("BAD ENDIANNESS: {}", ole.unwrap_err());
  }

  #[test]
  fn uid() {
    let ole = OLEReader::<std::fs::File>::from_path("./assets/Thumbs.db");
    assert_eq!(ole.is_ok(), true);
    let ole = ole.unwrap();
    assert_eq!(&[0x0u8; 16] == &ole.uid[..], true);
  }

  #[test]
  fn bad_sec_size() {
    let mut vec = super::super::constants::IDENTIFIER.to_vec();
    vec.extend(vec![0x42u8; 20]);
    vec.extend(&super::super::constants::LITTLE_ENDIAN_IDENTIFIER);
    vec.extend(vec![0xFF, 0xFF, 0xFF, 0xFF]);
    vec.extend(vec![0u8; 10]);
    vec.extend(vec![0xFF, 0xFF, 0xFF, 0xFF]);
    fill(&mut vec);
    let ole = OLEReader::new(&vec[..]);
    assert_eq!(ole.is_ok(), false);
  }

  #[test]
  fn several_values() {
    let ole = OLEReader::<std::fs::File>::from_path("./assets/Thumbs.db").unwrap();
    assert_eq!(ole.sat.as_ref().unwrap().capacity(), 128usize);
    assert_eq!(ole.msat.as_ref().unwrap().len(), 1usize);
    assert_eq!(ole.ssat.as_ref().unwrap().capacity(), 512usize);
  }

  #[test]
  fn print_things() {
    use std::io::{Read, Write};
    let ole = OLEReader::<std::fs::File>::from_path("./assets/Thumbs.db").unwrap();
    println!("STREAM SIZE: {}", *ole.minimum_standard_stream_size.as_ref().unwrap());
    println!("MSAT: {:?}", ole.msat.as_ref().unwrap());
    println!("SAT: {:?}", ole.sat.as_ref().unwrap());
    println!("SSAT: {:?}", ole.ssat.as_ref().unwrap());
    println!("DSAT: {:?}", ole.dsat.as_ref().unwrap());
    for entry in ole.iterate() {
      println!("{}", entry);
      let mut slice = ole.get_entry_slice(entry).unwrap();
      let mut buf = vec![0u8; slice.len()];
      let read_size = slice.read(&mut buf).unwrap();
      let mut file = std::fs::File::create(format!("./assets/streams/{}.bin", entry.name())).unwrap();
      file.write_all(&buf).unwrap();
      assert_eq!(read_size, slice.len());
    }
  }
}