use std::ffi::CString;
use std::io::{ Read, Write, Seek, SeekFrom, Result };
use std::mem;
use libc::{ c_int, c_char, c_void };
use primitives::*;
use super::{ PhysFSContext };
use super::util::physfs_error_as_io_error;

#[link(name = "physfs")]
extern {
    // valid filehandle on success, NULL on failure
    fn PHYSFS_openAppend(filename: *const c_char) -> *const RawFile;
    fn PHYSFS_openRead(filename: *const c_char) -> *const RawFile;
    fn PHYSFS_openWrite(filename: *const c_char) -> *const RawFile;

    // nonzero on success, 0 on failure (and the handle stays open)
    // The docs make it sound like failure is rare.
    fn PHYSFS_close(file: *const RawFile) -> c_int;

    // Number of bytes read on success, -1 on failure.
    fn PHYSFS_read(file: *const RawFile, buffer: *mut c_void,
                   obj_size: PHYSFS_uint32, obj_count: PHYSFS_uint32) -> PHYSFS_sint64;

    // Number of bytes written on success, -1 on failure.
    fn PHYSFS_write(file: *const RawFile, buffer: *const c_void,
                    obj_size: PHYSFS_uint32, obj_count: PHYSFS_uint32) -> PHYSFS_sint64;

    // Flush buffered file; no-op for unbuffered files.
    fn PHYSFS_flush(file: *const RawFile) -> c_int;

    // Seek to position in file; nonzero on succss, zero on error.
    fn PHYSFS_seek(file: *const RawFile, pos: PHYSFS_uint64) -> c_int;

    // Current position in file, -1 on failure.
    fn PHYSFS_tell(file: *const RawFile) -> PHYSFS_sint64;

    // nonzero if EOF, zero if not.
    fn PHYSFS_eof(file: *const RawFile) -> c_int;

    // Determine file size; returns -1 if impossible
    fn PHYSFS_fileLength(file: *const RawFile) -> PHYSFS_sint64;
}

/// Possible ways to open a file.
#[derive(Copy, Clone)]
pub enum Mode {
    /// Append to the end of the file.
    Append,
    /// Read from the file.
    Read,
    /// Write to the file, overwriting previous data.
    Write,
}

/// A wrapper for the PHYSFS_File type.
#[repr(C)]
struct RawFile {
    opaque: *const c_void,
}

/// A file handle.
#[allow(dead_code)]
pub struct File<'f> {
    raw: *const RawFile,
    mode: Mode,
    context: &'f PhysFSContext,
}

impl<'f> File<'f> {
    /// Opens a file with a specific mode.
    pub fn open<'g>(context: &'g PhysFSContext, filename: String, mode: Mode) -> Result<File<'g>> {
        let c_filename = try!(CString::new(filename));
        let raw = unsafe { match mode {
            Mode::Append => PHYSFS_openAppend(c_filename.as_ptr()),
            Mode::Read => PHYSFS_openRead(c_filename.as_ptr()),
            Mode::Write => PHYSFS_openWrite(c_filename.as_ptr())
        }};

        if raw.is_null() {
            Err(physfs_error_as_io_error())
        }
        else {
            Ok(File{raw: raw, mode: mode, context: context})
        }
    }

    /// Closes a file handle.
    fn close(&self) -> Result<()> {
        match unsafe {
            PHYSFS_close(self.raw)
        } {
            0 => Err(physfs_error_as_io_error()),
            _ => Ok(())
        }
    }

    /// Checks whether eof is reached or not.
    pub fn eof(&self) -> bool {
        let ret = unsafe {
            PHYSFS_eof(self.raw)
        };

        ret != 0
    }

    /// Determine length of file, if possible
    pub fn len(&self) -> Result<u64> {
        let len = unsafe { PHYSFS_fileLength(self.raw) };

        if len >= 0 {
            Ok(len as u64)
        } else {
            Err(physfs_error_as_io_error())
        }
    }

    /// Determines current position within a file
    pub fn tell(&self) -> Result<u64> {
        let ret = unsafe {
            PHYSFS_tell(self.raw)
        };

        match ret {
            -1 => Err(physfs_error_as_io_error()),
            _ => Ok(ret as u64)
        }
    }
}

impl<'f> Read for File<'f> {
    /// Reads from a file
    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
        let ret = unsafe {
            PHYSFS_read(
                self.raw,
                buf.as_ptr() as *mut c_void,
                mem::size_of::<u8>() as PHYSFS_uint32,
                buf.len() as PHYSFS_uint32
            )
        };

        match ret {
            -1 => Err(physfs_error_as_io_error()),
            _ => Ok(ret as usize)
        }
    }
}

impl<'f> Write for File<'f> {
    /// Writes to a file.
    /// This code performs no safety checks to ensure
    /// that the buffer is the correct length.
    fn write(&mut self, buf: &[u8]) -> Result<usize> {
        let ret = unsafe {
            PHYSFS_write(
                self.raw,
                buf.as_ptr() as *const c_void,
                mem::size_of::<u8>() as PHYSFS_uint32,
                buf.len() as PHYSFS_uint32
            )
        };

        match ret {
            -1 => Err(physfs_error_as_io_error()),
            _ => Ok(ret as usize)
        }
    }

    /// Flushes a file if buffered; no-op if unbuffered.
    fn flush(&mut self) -> Result<()> {
        let ret = unsafe {
            PHYSFS_flush(self.raw)
        };

        match ret {
            0 => Err(physfs_error_as_io_error()),
            _ => Ok(())
        }
    }
}

impl<'f> Seek for File<'f> {
    /// Seek to a new position within a file
    fn seek(&mut self, pos: SeekFrom) -> Result<u64> {
        let seek_pos = match pos {
            SeekFrom::Start(n) => n as i64,
            SeekFrom::End(n) => {
                let len = try!(self.len());
                n + len as i64
            }
            SeekFrom::Current(n) => {
                let curr_pos = try!(self.tell());
                n + curr_pos as i64
            }
        };

        let result = unsafe {
            PHYSFS_seek(
                self.raw,
                seek_pos as PHYSFS_uint64
            )
        };

        if result == -1 {
            return Err(physfs_error_as_io_error());
        }

        self.tell()
    }
}

impl<'f> Drop for File<'f> {
    fn drop(&mut self) {
        let _ = self.close();
    }
}