import java.util.*;

public class Contenant extends Entite{
	
	private Entite objet=new Entite();
	private Entite objet2=new Entite();
	
	private String modele=new String();
	
	private boolean ouvert=false;
	private boolean casse=false;
	
	private boolean verrouillable=false;
	private boolean unlocked=false;
	private int complexiteSerrure=0;
	
	private boolean visible=true;
	
	private String tileStrFerme=new String();
	private String tileStrOuvert=new String();
	
	private String sonOuverture=new String();
	private String sonFermeture=new String();
	
	private Vector contenu=new Vector();
	
	private int poids=0;

	private String nom=new String();
	//private String nomEquipement=new String();
	
	private int resistanceMat=0;
	private int structureMat=0;
	
	private int nbrObjets=0;
	
	private int niveau=0;
	
	private String nomE=new String();
	
	public String getNomE(){
		return nomE;
	}
	
	public Contenant(Catalog cat,Monde monde,boolean randomIn,boolean lockable,boolean unlockedC,int complexiteSerrureC,boolean ouv,boolean brok,String modeleC,String name,String nameE,boolean visibleC,String tileFerme,String tileOuvert,String sndOuvert,String sndFerm){
		
		//niveau=Math.round((complexiteSerrureC-100)/10);
		
		verrouillable=lockable;
		modele=modeleC;
		nom=name;
		nomE=nameE;
		unlocked=unlockedC;
		complexiteSerrure=complexiteSerrureC;
		ouvert=ouv;
		casse=brok;
		visible=visibleC;
		tileStrFerme=tileFerme;
		tileStrOuvert=tileOuvert;
		sonOuverture=sndOuvert;
		sonFermeture=sndFerm;
		//nomEquipement=nom;
		
		
		//////////////////////////////////////////////////////////
		if(modele.compareTo("alchemytable")==0){
			
			complexiteSerrure=0;
			verrouillable=false;
			unlocked=true;
			ouvert=true;
			resistanceMat=30;
			structureMat=200;
			poids=75;
			
			if(randomIn){ //REMPLIR LE CONTENANT SELON SON MODELE
				
				ArrayList comestiblesCatalogue=cat.comestiblesCatalogue;
				
				
				if((int)(Math.abs(Math.random()*100))>50 && comestiblesCatalogue.size()>0){
				
					//Entite objet=new Entite();
					nbrObjets=(int)(Math.abs(Math.random()*3)+1);
					Vector contenu=new Vector();
					
					while(nbrObjets!=0){
					
						objet= (Entite) comestiblesCatalogue.get((int)(Math.abs(Math.random()*comestiblesCatalogue.size())));
						String tileStr=new String();
						
						if((objet.getClass().getName()).compareTo("Nourriture")==0){
						
							if(objet.getNom().compareTo("champignon")==0){
								tileStr="./images/comestible/champi"+new Integer((int)(Math.abs(Math.random()*5))+1).toString()+".gif";
							}
							
							if(objet.getNom().compareTo("ration")==0){
								tileStr="./images/comestible/ration"+new Integer((int)(Math.abs(Math.random()*3))+1).toString()+".gif";
							}
							
							if(objet.getNom().compareTo("potiron")==0){
								tileStr="./images/comestible/potiron.gif";
							}
							
							contenu.add(new Nourriture(false,objet.getModele(),objet.getNom(),objet.getNomE(),"Comestible",true,tileStr));
					
						}
						
						
						if((objet.getClass().getName()).compareTo("Boisson")==0 && objet.getModele().compareTo("fountain")!=0){
							
							tileStr="./images/comestible/potion"+new Integer((int)(Math.abs(Math.random()*4))+1).toString()+".gif";
							
							
							
							contenu.add(new Boisson(false,objet.getModele(),objet.getNom(),objet.getNomE(),"Comestible",true,tileStr));
						
						}
						
						nbrObjets--;
					}
					
					setContenu(contenu);	
				}
				
			}
			
			niveau=0;
		}
		
		
		
		
		
		
		//////////////////////////////////////////////////////////
		if(modele.compareTo("coffrestandard")==0){
		
			resistanceMat=70;
			structureMat=75;
			poids=10;
			
			
			
			if(randomIn){ //REMPLIR LE CONTENANT SELON SON MODELE
			
				//complexiteSerrure=(int)(Math.abs(Math.random()*100))+50;
				complexiteSerrure=(int)(Math.random()*monde.ipp()*20)+1;
				
				ArrayList comestiblesCatalogue=cat.comestiblesCatalogue;
				ArrayList piegesCatalogue=cat.piegesCatalogue;
				ArrayList armesCatalogue=cat.armesCatalogue;
				ArrayList armuresCatalogue=cat.armuresCatalogue;
				ArrayList outilsCatalogue=cat.outilsCatalogue;
				ArrayList ecritMagiqueCatalogue=cat.ecritMagiqueCatalogue;
				ArrayList sortCatalogue=cat.sortCatalogue;
				
				//exemple
				//Vector contenuCoffre1=new Vector();
				//contenuCoffre1.add(new Nourriture(false,"mushroom","champignon vert","Comestible",true,"./images/comestible/champivert.gif"));
				//contenuCoffre1.add(new Outil(false,"pioche","Vieille pioche",0,"Objet",true,"./images/outils/pioche.gif"));
				//setContenu(contenuCoffre1);
						
				if((int)(Math.abs(Math.random()*100))>25 && sortCatalogue.size()>0 && ecritMagiqueCatalogue.size()>0 && comestiblesCatalogue.size()>0 && piegesCatalogue.size()>0 && armesCatalogue.size()>0 && armuresCatalogue.size()>0 && outilsCatalogue.size()>0){
				
				
					nbrObjets=(int)(Math.abs(Math.random()*5)+1);
					Vector contenu=new Vector();
					
					while(nbrObjets!=0){
						String tileStr=new String();
						int genreCatalogue=(int)(Math.abs(Math.random()*6)+1);//6 = nbre de catalogues
						
						
						///////comestibles
						if(genreCatalogue==1){
							//Entite objet=new Entite();
							objet= (Entite) comestiblesCatalogue.get((int)(Math.abs(Math.random()*comestiblesCatalogue.size())));
							
							
							if((objet.getClass().getName()).compareTo("Nourriture")==0){
							
								if(objet.getNom().compareTo("champignon")==0){
									tileStr="./images/comestible/champi"+new Integer((int)(Math.abs(Math.random()*5))+1).toString()+".gif";
								}
								
								if(objet.getNom().compareTo("ration")==0){
									tileStr="./images/comestible/ration"+new Integer((int)(Math.abs(Math.random()*3))+1).toString()+".gif";
								}
								
								if(objet.getNom().compareTo("potiron")==0){
									tileStr="./images/comestible/potiron.gif";
								}
								
								
								contenu.add(new Nourriture(false,objet.getModele(),objet.getNom(),objet.getNomE(),"Comestible",true,tileStr));
						
							}
							
							
							if((objet.getClass().getName()).compareTo("Boisson")==0 && objet.getModele().compareTo("fountain")!=0){
								
								tileStr="./images/comestible/potion"+new Integer((int)(Math.abs(Math.random()*4))+1).toString()+".gif";
								
								
								
								contenu.add(new Boisson(false,objet.getModele(),objet.getNom(),objet.getNomE(),"Comestible",true,tileStr));
							
							}
						}
						
						
						///////pieges
						if(genreCatalogue==2){
							//Entite objet=new Entite();
							objet= (Entite) piegesCatalogue.get((int)(Math.abs(Math.random()*piegesCatalogue.size())));
							if(objet.getModele().compareTo("trou")!=0){
								contenu.add(new Piege(monde,true,0,0,false,0,false,objet.getModele(),objet.getNom(),objet.getNomE(),"Piege",true,objet.getTileStr(),objet.getSonActivation()));
							}	
						}
						
						/////////armes
						if(genreCatalogue==3){
							//Entite objet=new Entite();
							objet= (Entite) armesCatalogue.get((int)(Math.abs(Math.random()*armesCatalogue.size())));
				
							//int bonusM=(int)(Math.abs(Math.random()*100)-49);
							int bonusM=(int)(Math.random()*(monde.ipp()-3))+1;
							if(bonusM<0){bonusM=0;
							}
							
							contenu.add(new Arme(false,objet.getModele(),objet.getNom(),objet.getNomE(),bonusM,"Objet",true,objet.getTileStr()));
			
							
						}
						
						////////armures
						if(genreCatalogue==4){
							//Entite objet=new Entite();
							objet= (Entite) armuresCatalogue.get((int)(Math.abs(Math.random()*armuresCatalogue.size())));
				
							//int bonusM=(int)(Math.abs(Math.random()*100)-49);
							int bonusM=(int)(Math.random()*(monde.ipp()-3))+1;
							
							if(bonusM<0){bonusM=0;
							}
															
							contenu.add(new Armure(false,objet.getModele(),objet.getNom(),objet.getNomE(),bonusM,"Objet",true,objet.getTileStr()));
			
						}
						
						////////outils
						if(genreCatalogue==5){
							//Entite objet=new Entite();
							objet= (Entite) outilsCatalogue.get((int)(Math.abs(Math.random()*outilsCatalogue.size())));
				
							//int bonusM=(int)(Math.abs(Math.random()*100)-49);
							
							int bonusM=(int)(Math.random()*(monde.ipp()-3))+1;
							
							if(bonusM<0){bonusM=0;
							}
							
							
							Outil outil=new Outil(false,objet.getModele(),objet.getNom(),objet.getNomE(),bonusM,"Objet",true,objet.getTileStr());
							
							
							if(objet.getPeutEclairer()){
								
								if((int)(Math.abs(Math.random()*2))>0){outil.setAlume(false);}
								
							}
															
							contenu.add(outil);
							
						}
						
						
						if(genreCatalogue==6){
							objet= (Entite) ecritMagiqueCatalogue.get((int)(Math.abs(Math.random()*ecritMagiqueCatalogue.size())));
							objet2= (Entite) sortCatalogue.get((int)(Math.abs(Math.random()*sortCatalogue.size())));
				
							if(objet.getModele().compareTo("magicscroll")==0){
								tileStr="./images/ecritsmagiques/scroll"+new Integer((int)(Math.abs(Math.random()*2))+1).toString()+".gif";
							}
							else{
								tileStr="./images/ecritsmagiques/grim"+new Integer((int)(Math.abs(Math.random()*30))+1).toString()+".gif";
							}
							
							EcritMagique em=new EcritMagique(0,0,false,objet.getModele(),objet.getNom(),objet.getNomE(),"EcritMagique",true,tileStr,(Spell)objet2);			
							contenu.add(em);
							
							System.out.println("COFFRE AVEC ECRITS MAGIQUES");
				
						}
						
						
						
						
						nbrObjets--;
					}
					
					setContenu(contenu);	
				}
			
				//////////////////////////////////////////////////////////////////////////
				
				
				
				
			}
			
			niveau=Math.round((complexiteSerrure-95)/5);
			if(niveau<0){niveau=0;
			}
		}
		
		
		
	
		
		
		
		
		
		
		
	}
	
	
	
	//////////////////////////////////////////
	public boolean getVerrouillable(){
		return verrouillable;
	}
	
	
	public Vector getContenu(){
		return contenu;
	}
	
	public void setContenu(Vector content){
		contenu=content;
	}
	
	
	
	
	
	public int getPoids(){
		
		int poidsTotal=poids;
		//Entite objet=new Entite();
		// retourner le poids du contenu +  poids du contenant
		// faire ici une enumeration des poids des entite dans contenu
		// faire la somme de ces poids
		if(!contenu.isEmpty()){
				
			for(Enumeration e = contenu.elements();e.hasMoreElements();){
                
 				try{	
 						
 					objet=(Entite) e.nextElement();
 					
					poidsTotal=poidsTotal+objet.getPoids();
					
 				}
 				catch(NoSuchElementException exc){};
 			}
 		}
		
		return poidsTotal;
			
	}
	
	
	public void setPoids(int pds){
		poids=pds;
	}
	
	/*
	public String getNomDequipement(){
		return nomEquipement;
	}
	
	public void setNomDequipement(String nomEquip){
		nomEquipement=nomEquip;
	}*/
	
	public String getNom(){
		return nom;
	}
	
	
	public int getComplexiteSerrure(){
		return complexiteSerrure;
	}
	
	public void setComplexiteSerrure(int cs){
		complexiteSerrure=cs;
	}
	
	public void setUnlocked(boolean dever){
		unlocked=dever;
	}
	
	public boolean getUnlocked(){
		return unlocked;
	}
	
	
	
	public void setOuvert(boolean ouv){
		ouvert=ouv;
	}
	public boolean getOuvert(){
		return ouvert;
	}
	
	
	public void setCasse(boolean broken){
		casse=broken;
		if(casse==true){
		
			unlocked=true;
			ouvert=true;
		}
	}
	
	
	public boolean getCasse(){
		return casse;
	}
	
	
	
	public int getResistanceMat(){
		return resistanceMat;
	}
	
	public void setResistanceMat(int res){
		resistanceMat=res;
	}
	
	public int getStructureMat(){
		return structureMat;
	}
	
	public void setStructureMat(int struct){
		structureMat=struct;
	}
	
	public String getModele(){
		return modele;
	}
	
	
	
	public boolean getVisible(){
		return visible;
	}
	
	public void setVisible(boolean visibility){
		visible=visibility;
	}
	
	
	
	public String getTileStr(){
		
		if(getCasse()==true){
			
			if(modele.compareTo("coffrestandard")==0){return "./images/contenant/coffrecasse.gif";}
			else{return "./images/contenant/rocks.gif";}
			
			
		}
		
		
		if(ouvert==true){
			return tileStrOuvert;
		}
		else{
			return tileStrFerme;
		}
		
	}
	
	
	public void bruit(){
		if(ouvert==true){
		
			ThreadSon son=new ThreadSon(sonFermeture,0);
			son.start();
		}
		else{
			ThreadSon son=new ThreadSon(sonOuverture,0);
			son.start();
		}
		
		
	}
	
	
	public String getTileFerme(){
		return tileStrFerme;
	}
	public String getTileOuvert(){
		return tileStrOuvert;
	}
	public String getSonOuverture(){
		return sonOuverture;
	}
	public String getSonFermeture(){
		return sonFermeture;
	}
	
	public int getNiveau(){
		return niveau;
	}
	
}