use super::openfile::OpenFile;


pub const MAX_OF_TABLE_ENTRY : i32 = 500;

pub struct OpenFileTableEntry {
    name : String,
    pub file : Option<OpenFile>,
    pub num_thread : i32,//number of threads havng that file open
    //lock : Lock,
    pub to_be_deleted : bool,//si mis a true, quand ce fichier n'est plus ouvert par aucun thread, il doit etre supprimé
    pub sector : i32,//secteur disque ou se situe le header de ce fichier
}

pub struct OpenFileTable{
    table : Vec<Option<OpenFileTableEntry>>,
    nb_entry : i32//numero du prochain fichier ouvert/prochaine entrée
}

impl OpenFileTableEntry {
    
    pub fn new() -> OpenFileTableEntry {

        OpenFileTableEntry {
            name : String::new(),
            file : None,
            num_thread : 1,
            to_be_deleted : false,
            sector : -1
        }
    }
}

impl OpenFileTable{

    pub fn open(oft : &mut OpenFileTable, name : String)-> Option<OpenFile>{

        let mut num : i32;
        let mut sector : i32;
        let mut dirsector : i32;
        let mut file_name = String::new();

        //Impl le trait copy sur open file
        num = OpenFileTable::findl(oft, &name);

        //no error
        if num != -1 {
            //the file is opened by another thread
            match oft.table[num as usize] {

                Some(e) => {

                    if !e.to_be_deleted{
                        e.num_thread += 1;

                        let new_file : OpenFile = OpenFile::open_file(e.sector);
                        new_file.name = name.clone();

                        return Some(new_file);
                    }
                    else {
                        return None;
                    }

                }

                None => {
                    println!("OpenFileTale :: open :: Error opening {}", name);
                    return None;
                }
            }
        }

        //file is not opened yet
        else {
            if(oft.nb_entry != -1){
                //il reste de la place
                let mut new_entry : OpenFileTableEntry = OpenFileTableEntry::new();
                let mut open_file : OpenFile;
                let mut new_file : OpenFile;
                //on va creer, si fichier present sur disque, deux objet open_file, 
                //open_file ira dans la table
                //new_file sera renvoyé

            }
            
            
            
            


        }

        return None;

    }

    pub fn close(name : String){

    }

    pub fn file_lock(name : String){

    }

    pub fn file_release(name : String){

    }

    pub fn remove(name : String)-> i32{
        0
    }

    pub fn next_entry(oft : &mut OpenFileTable)-> i32{
        let mut i = 0;

        for entry in oft.table.iter(){
            match entry {
                None => {
                    return i;
                }

                _ => {
                    i+=1;
                }
            }
        }
        0
    }

    pub fn findl(oft : &mut OpenFileTable, name : &String)-> i32{
        let mut i = 0;

        for entry in oft.table.iter(){

            match entry {

                Some(e) => {
                    if e.name.eq(name){
                        return i;
                    }
                }

                _ => {}
            }

            i+=1
        }
        
        -1
    }

}