/* Copyright (c) 2018 Garrett Berg, vitiral@gmail.com
 *
 * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
 * http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
 * http://opensource.org/licenses/MIT>, at your option. This file may not be
 * copied, modified, or distributed except according to those terms.
 */
use std::fs;
use std::fmt;
use std::io;
use std_prelude::*;

use super::{Error, Result};
use super::{FileEdit, FileRead, FileWrite, PathAbs, PathArc};

#[derive(Clone, Eq, Hash, PartialEq, PartialOrd, Ord)]
/// a `PathAbs` that was a file at the time of initialization, with associated methods.
pub struct PathFile(pub(crate) PathAbs);

impl PathFile {
    /// Instantiate a new `PathFile`. The file must exist or `io::Error` will be returned.
    ///
    /// Returns `io::ErrorKind::InvalidInput` if the path exists but is not a file.
    ///
    /// # Examples
    /// ```rust
    /// # extern crate path_abs;
    /// use path_abs::PathFile;
    ///
    /// # fn try_main() -> ::std::io::Result<()> {
    /// let lib = PathFile::new("src/lib.rs")?;
    /// # Ok(()) } fn main() { try_main().unwrap() }
    /// ```
    pub fn new<P: AsRef<Path>>(path: P) -> Result<PathFile> {
        let abs = PathAbs::new(path)?;
        PathFile::from_abs(abs)
    }

    /// Consume the `PathAbs` validating that the path is a file and returning `PathFile`. The file
    /// must exist or `io::Error` will be returned.
    ///
    /// If the path is actually a dir returns `io::ErrorKind::InvalidInput`.
    ///
    /// > This does not call [`Path::cannonicalize()`][1], instead trusting that the input is
    /// > already a fully qualified path.
    ///
    /// [1]: https://doc.rust-lang.org/std/path/struct.Path.html?search=#method.canonicalize
    ///
    /// # Examples
    /// ```rust
    /// # extern crate path_abs;
    /// use path_abs::{PathAbs, PathFile};
    ///
    /// # fn try_main() -> ::std::io::Result<()> {
    /// let lib_abs = PathAbs::new("src/lib.rs")?;
    /// let lib_file = PathFile::from_abs(lib_abs)?;
    /// # Ok(()) } fn main() { try_main().unwrap() }
    /// ```
    pub fn from_abs(abs: PathAbs) -> Result<PathFile> {
        if abs.is_file() {
            Ok(PathFile::from_abs_unchecked(abs))
        } else {
            Err(Error::new(
                io::Error::new(io::ErrorKind::InvalidInput, "path is not a file"),
                "resolving",
                abs.into(),
            ))
        }
    }

    #[inline(always)]
    /// Do the conversion _without checking_.
    ///
    /// This is typically used by external libraries when the type is already known
    /// through some other means (to avoid a syscall).
    pub fn from_abs_unchecked(abs: PathAbs) -> PathFile {
        PathFile(abs)
    }

    /// Instantiate a new `PathFile`, creating an empty file if it doesn't exist.
    ///
    /// # Examples
    /// ```rust
    /// # extern crate path_abs;
    /// # extern crate tempdir;
    /// use path_abs::PathFile;
    ///
    /// # fn try_main() -> ::std::io::Result<()> {
    /// let example = "example.txt";
    /// # let tmp = tempdir::TempDir::new("ex")?;
    /// # let example = &tmp.path().join(example);
    ///
    /// # let tmp = tempdir::TempDir::new("ex")?;
    /// # let example = &tmp.path().join(example);
    ///
    /// let file = PathFile::create(example)?;
    ///
    /// // It can be done twice with no effect.
    /// let _ = PathFile::create(example)?;
    /// # Ok(()) } fn main() { try_main().unwrap() }
    /// ```
    pub fn create<P: AsRef<Path>>(path: P) -> Result<PathFile> {
        fs::OpenOptions::new()
            .write(true)
            .create(true)
            .open(&path)
            .map_err(|err| Error::new(err, "opening", PathArc::new(&path)))?;
        PathFile::new(path)
    }

    /// Read the entire contents of the file into a `String`.
    ///
    /// # Examples
    /// ```rust
    /// # extern crate path_abs;
    /// # extern crate tempdir;
    /// use path_abs::PathFile;
    ///
    /// # fn try_main() -> ::std::io::Result<()> {
    /// let example = "example.txt";
    /// # let tmp = tempdir::TempDir::new("ex")?;
    /// # let example = &tmp.path().join(example);
    /// let file = PathFile::create(example)?;
    ///
    /// let expected = "foo\nbar";
    /// file.write_str(expected)?;
    /// assert_eq!(expected, file.read_string()?);
    /// # Ok(()) } fn main() { try_main().unwrap() }
    /// ```
    pub fn read_string(&self) -> Result<String> {
        let mut f = self.read()?;
        f.read_string()
    }

    /// Write the `str` to a file, truncating it first if it exists and creating it otherwise.
    ///
    /// # Examples
    /// ```rust
    /// # extern crate path_abs;
    /// # extern crate tempdir;
    /// use path_abs::PathFile;
    ///
    /// # fn try_main() -> ::std::io::Result<()> {
    /// let example = "example.txt";
    /// # let tmp = tempdir::TempDir::new("ex")?;
    /// # let example = &tmp.path().join(example);
    /// let file = PathFile::create(example)?;
    ///
    /// let expected = "foo\nbar";
    /// file.write_str(expected)?;
    /// assert_eq!(expected, file.read_string()?);
    /// # Ok(()) } fn main() { try_main().unwrap() }
    /// ```
    pub fn write_str(&self, s: &str) -> Result<()> {
        let mut options = fs::OpenOptions::new();
        options.create(true);
        options.truncate(true);
        let mut f = FileWrite::open_path(self.clone(), options)?;
        if s.is_empty() {
            return Ok(());
        }
        f.write_str(s)?;
        f.flush()
    }

    /// Append the `str` to a file, creating it if it doesn't exist.
    ///
    /// # Examples
    /// ```rust
    /// # extern crate path_abs;
    /// # extern crate tempdir;
    /// use path_abs::PathFile;
    ///
    /// # fn try_main() -> ::std::io::Result<()> {
    /// let example = "example.txt";
    /// # let tmp = tempdir::TempDir::new("ex")?;
    /// # let example = &tmp.path().join(example);
    /// let file = PathFile::create(example)?;
    ///
    /// let expected = "foo\nbar\nbaz";
    /// file.append_str("foo\nbar")?;
    /// file.append_str("\nbaz")?;
    /// assert_eq!(expected, file.read_string()?);
    /// # Ok(()) } fn main() { try_main().unwrap() }
    /// ```
    pub fn append_str(&self, s: &str) -> Result<()> {
        let mut f = self.append()?;
        if s.is_empty() {
            return Ok(());
        }
        f.write_str(s)?;
        f.flush()
    }

    /// Open the file as read-only.
    ///
    /// # Examples
    /// ```rust
    /// # extern crate path_abs;
    /// # extern crate tempdir;
    /// use std::io::Read;
    /// use path_abs::PathFile;
    ///
    /// # fn try_main() -> ::std::io::Result<()> {
    /// let example = "example.txt";
    /// # let tmp = tempdir::TempDir::new("ex")?;
    /// # let example = &tmp.path().join(example);
    /// let file = PathFile::create(example)?;
    ///
    /// let expected = "foo\nbar";
    /// file.write_str(expected)?;
    ///
    /// let mut read = file.read()?;
    /// let mut s = String::new();
    /// read.read_to_string(&mut s)?;
    /// assert_eq!(expected, s);
    /// # Ok(()) } fn main() { try_main().unwrap() }
    /// ```
    pub fn read(&self) -> Result<FileRead> {
        FileRead::read_path(self.clone())
    }

    /// Open the file as write-only in append mode.
    ///
    /// # Examples
    /// ```rust
    /// # extern crate path_abs;
    /// # extern crate tempdir;
    /// use std::io::Write;
    /// use path_abs::PathFile;
    ///
    /// # fn try_main() -> ::std::io::Result<()> {
    /// let example = "example.txt";
    /// # let tmp = tempdir::TempDir::new("ex")?;
    /// # let example = &tmp.path().join(example);
    /// let file = PathFile::create(example)?;
    ///
    /// let expected = "foo\nbar\n";
    /// file.write_str("foo\n")?;
    ///
    /// let mut append = file.append()?;
    /// append.write_all(b"bar\n")?;
    /// append.flush();
    /// assert_eq!(expected, file.read_string()?);
    /// # Ok(()) } fn main() { try_main().unwrap() }
    /// ```
    pub fn append(&self) -> Result<FileWrite> {
        let mut options = fs::OpenOptions::new();
        options.append(true);
        FileWrite::open_path(self.clone(), options)
    }

    /// Open the file for editing (reading and writing).
    ///
    /// # Examples
    /// ```rust
    /// # extern crate path_abs;
    /// # extern crate tempdir;
    /// use std::io::{Read, Seek, Write, SeekFrom};
    /// use path_abs::PathFile;
    ///
    /// # fn try_main() -> ::std::io::Result<()> {
    /// let example = "example.txt";
    /// # let tmp = tempdir::TempDir::new("ex")?;
    /// # let example = &tmp.path().join(example);
    /// let file = PathFile::create(example)?;
    ///
    /// let expected = "foo\nbar";
    ///
    /// let mut edit = file.edit()?;
    /// let mut s = String::new();
    ///
    /// edit.write_all(expected.as_bytes())?;
    /// edit.seek(SeekFrom::Start(0))?;
    /// edit.read_to_string(&mut s)?;
    /// assert_eq!(expected, s);
    /// # Ok(()) } fn main() { try_main().unwrap() }
    /// ```
    pub fn edit(&self) -> Result<FileEdit> {
        FileEdit::open_path(self.clone(), fs::OpenOptions::new())
    }

    /// Remove (delete) the file from the filesystem, consuming self.
    ///
    /// # Examples
    /// ```rust
    /// # extern crate path_abs;
    /// # extern crate tempdir;
    /// use path_abs::PathFile;
    /// use std::path::Path;
    ///
    /// # fn try_main() -> ::std::io::Result<()> {
    /// let example = "example.txt";
    /// # let tmp = tempdir::TempDir::new("ex")?;
    /// # let example = &tmp.path().join(example);
    /// let file = PathFile::create(example)?;
    /// assert!(file.exists());
    /// file.remove()?;
    ///
    /// // file.exists() <--- COMPILER ERROR, `file` was consumed
    ///
    /// assert!(!Path::new(example).exists());
    /// # Ok(()) } fn main() { try_main().unwrap() }
    /// ```
    pub fn remove(self) -> Result<()> {
        fs::remove_file(&self).map_err(|err| Error::new(err, "removing", self.into()))
    }

    /// Return a reference to a basic `std::path::Path`
    pub fn as_path(&self) -> &Path {
        self.as_ref()
    }

    /// Create a mock file type. *For use in tests only*.
    ///
    /// See the docs for [`PathAbs::mock`](struct.PathAbs.html#method.mock)
    pub fn mock<P: AsRef<Path>>(path: P) -> PathFile {
        PathFile(PathAbs::mock(path))
    }
}

impl fmt::Debug for PathFile {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl AsRef<PathAbs> for PathFile {
    fn as_ref(&self) -> &PathAbs {
        &self.0
    }
}

impl AsRef<Path> for PathFile {
    fn as_ref(&self) -> &Path {
        self.0.as_ref()
    }
}

impl AsRef<PathBuf> for PathFile {
    fn as_ref(&self) -> &PathBuf {
        self.0.as_ref()
    }
}

impl Deref for PathFile {
    type Target = PathAbs;

    fn deref(&self) -> &PathAbs {
        &self.0
    }
}

impl Into<PathAbs> for PathFile {
    /// Downgrades the `PathFile` into a `PathAbs`
    ///
    /// # Examples
    /// ```
    /// # extern crate path_abs;
    /// use std::path::PathBuf;
    /// use path_abs::{PathFile, PathAbs};
    ///
    /// # fn try_main() -> ::std::io::Result<()> {
    /// let file = PathFile::new("src/lib.rs")?;
    /// let abs: PathAbs = file.clone().into();
    /// # Ok(()) } fn main() { try_main().unwrap() }
    /// ```
    fn into(self) -> PathAbs {
        self.0
    }
}

impl Into<PathArc> for PathFile {
    /// Downgrades the `PathFile` into a `PathArc`
    fn into(self) -> PathArc {
        (self.0).0
    }
}

impl Into<PathBuf> for PathFile {
    /// Downgrades the `PathFile` into a `PathBuf`. Avoids a clone if this is the only reference.
    ///
    /// # Examples
    /// ```
    /// # extern crate path_abs;
    /// use path_abs::PathFile;
    /// use std::path::PathBuf;
    ///
    /// # fn try_main() -> ::std::io::Result<()> {
    /// let file = PathFile::new("src/lib.rs")?;
    /// let buf: PathBuf = file.into();
    /// # Ok(()) } fn main() { try_main().unwrap() }
    /// ```
    fn into(self) -> PathBuf {
        let arc: PathArc = self.into();
        arc.into()
    }
}