use std::io::{self, Read};
use std::mem;
use std::str;
use std::ops::Range;
use std::slice;
use num_traits::ToPrimitive;
use file::FileDb;
use object::Object;
use types;

#[derive(Debug,Clone)]
#[repr(C)]
struct Header<AddressType>{
    code: [u8; 4],
    size: i32,
    address: AddressType,
    sdna_index: i32,
    count: i32,
}

#[derive(Debug,Clone)]
#[repr(C)]
pub struct FileBlock{
    pub code: [u8; 4],
    pub size: i32,
    pub address: u64,
    pub sdna_index: i32,
    pub count: i32,
    pub data: Vec<u8>,
}


fn read_struct<T, R: Read>(read: &mut R) -> io::Result<T> {
    let num_bytes = ::std::mem::size_of::<T>();
    unsafe {
        let mut s = ::std::mem::uninitialized();
        let buffer = slice::from_raw_parts_mut(&mut s as *mut T as *mut u8, num_bytes);
        match read.read_exact(buffer) {
            Ok(()) => Ok(s),
            Err(e) => {
                ::std::mem::forget(s);
                Err(e)
            }
        }
    }
}

impl FileBlock{
    pub fn parse<R: Read>(file: &mut R, pointer_size: u8) -> io::Result<Option<FileBlock>>{
        if pointer_size == 32{
            FileBlock::parse_::<u32,R>(file)
        }else{
            FileBlock::parse_::<u64,R>(file)
        }
    }

    fn parse_<AddressType: ToPrimitive, R: Read>(file: &mut R) -> io::Result<Option<FileBlock>>{
        let header: io::Result<Header<AddressType>> = read_struct(file);
        match header{
            Ok(header) =>
                match FileBlock::read_data(header, file){
                    Ok(block) => Ok(Some(block)),
                    Err(err) => Err(err)
                },
            Err(_) => Ok(None),
        }
    }

    fn read_data<AddressType: ToPrimitive, R: Read>(header: Header<AddressType>, file: &mut R) -> io::Result<FileBlock>{
        let mut data = Vec::with_capacity(header.size as usize); //vec![0; header.size as usize];
        unsafe{ data.set_len(header.size as usize) };
        file.read_exact(&mut data)?;
        Ok(FileBlock{
             code: header.code,
             size: header.size,
             address: header.address.to_u64().unwrap(),
             sdna_index: header.sdna_index,
             count: header.count,
             data: data,
        })
    }

    pub fn code(&self) -> &str{
        str::from_utf8(&self.code).unwrap()
    }

    pub fn object<'a>(&'a self, file_db: FileDb<'a>) -> Object{
        Object::new(file_db, self)
    }

    pub fn slice<'a>(&'a self, dim: usize, file_db: FileDb<'a>) -> Vec<Object>{
        Range{ start: 0, end: dim }
            .map(|i| Object::new_with_index(file_db.clone(), self, i))
            .collect()
    }

    pub fn data_slice<T>(&self, len: usize) -> types::Result<&[T]>{
        if len * mem::size_of::<T>() > self.data.len(){
            Err(types::Error::from(format!("Size of data slice {} * {} = {} is more than block size {}", len, mem::size_of::<T>(), len * mem::size_of::<T>(), self.data.len())))
        }else{
            Ok(unsafe{slice::from_raw_parts(mem::transmute(self.data.as_ptr()), len)})
        }
    }

    pub fn size(&self) -> usize{
        self.size as usize
    }

    pub fn data(&self) -> &[u8]{
        &self.data
    }

    pub fn cast<T>(&self) -> types::Result<&T>{
        if mem::size_of::<T>() > self.data.len() {
            Err(types::Error::from(format!("Size of type {} is more than block size {}", mem::size_of::<T>(), self.data.len())))
        }else{
            Ok(unsafe{ mem::transmute(self.data.as_ptr()) })
        }
    }
}