package main;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import carte.CarteLieu;
import effet.Effet;
import personnage.CartePersonnage;

public class Plateau {
	
	private GestionnaireJeu gj;
	private List<Joueur> joueurs;
	private List<CarteLieu> lieux;
	

	public static final String NB_HUNTERS = "nb_hunters";
	public static final String NB_SHADOWS = "nb_shadows";
	public static final String NB_NEUTRES = "nb_neutres";
	public static final String NB_MORTS = "nb_morts";
	public static final String NB_MORTS_NEUTRAL = "nb_morts_neutral";
	public static final String NB_MORTS_HUNTER = "nb_morts_hunter";
	public static final String NB_MORTS_SHADOW = "nb_morts_shadow";
	public static final String PARTIE_FINIE = "partie_finie";
	
	private Map<String, Integer> stats;
	
	public Plateau(List<Joueur> joueurs) {
		
		
		this.lieux = new ArrayList<>();
		this.stats = new HashMap<>();
		
		joueurs.forEach(x -> x.setPlateau(this));
		this.joueurs = joueurs;
		
		
		this.stats.put(NB_MORTS, 0);
		this.stats.put(NB_MORTS_NEUTRAL, 0);
		this.stats.put(NB_MORTS_HUNTER, 0);
		this.stats.put(NB_MORTS_SHADOW, 0);
		this.stats.put(PARTIE_FINIE, 0);
		
		this.stats.put(NB_HUNTERS, 0);
		this.stats.put(NB_SHADOWS, 0);
		this.stats.put(NB_NEUTRES, 0);
	}	
	
	public void initCartePersonnage(List<CartePersonnage> cps) throws Exception {
		
		
		int nbJoueurs = this.joueurs.size();
		List<CartePersonnage> lcp = new ArrayList<>(nbJoueurs);
		
		
		System.out.println(this.joueurs);
		switch(nbJoueurs) {
		
		case 4:
			lcp = getRandomListPersonnages(cps,2,0);
			break;
		case 5:
			lcp = getRandomListPersonnages(cps,2,1);
			break;
		case 6:
			lcp = getRandomListPersonnages(cps,2,2);
			break;
		case 7:
			lcp = getRandomListPersonnages(cps,2,3);
			break;
		case 8:
			lcp = getRandomListPersonnages(cps,3,2);
			break;
		default:
			throw new Exception();
		}
		
		for(int i = 0; i< nbJoueurs; i++) {
			
			Joueur j = joueurs.get(i);
			j.setCartePersonnage(lcp.get(i));
		}
	}
	
	private List<CartePersonnage> getRandomListPersonnages(List<CartePersonnage> cps,int nbEquipeShadowHunter, int nbNeutres) {
		
		List<CartePersonnage> lcp = new ArrayList<CartePersonnage>();
		
		Collections.shuffle(cps);
		
		
		int nbShadow = nbEquipeShadowHunter;
		int nbHunter = nbEquipeShadowHunter;
		int nbNeutre = nbNeutres;
		
		
	
		for(CartePersonnage cp : cps) {
			
			
			if(nbHunter > 0 && cp.getEquipe() == CartePersonnage.Equipe.HUNTER) {
				nbHunter--;
				lcp.add(cp);
			}
			
			if(nbNeutre > 0 && cp.getEquipe() == CartePersonnage.Equipe.NEUTRE) {
				nbNeutre--;
				lcp.add(cp);
			}
			
			if(nbShadow > 0 && cp.getEquipe() == CartePersonnage.Equipe.SHADOW) {
				nbShadow--;
				lcp.add(cp);
			}
		}
		System.out.println(lcp);
		return lcp;
	}

	public void jeu() {
		
		int nbJoueurs = this.joueurs.size()-1;
		int i = 1;
		
		while(true) {
			
			Joueur currentJoueur = this.joueurs.get(nbJoueurs % i);
			deplacer(currentJoueur);
			
			if(currentJoueur.choisir()) {
				currentJoueur.utiliserEffetLieu();
			}
			
			if(currentJoueur.choisir()){
				Joueur cible = currentJoueur.choisirAdjacents();
				attaquer(currentJoueur,cible);
			}
			
			i++;
		}
	}
	
	public void deplacer(Joueur currentJoueur) {
		
		boolean attributed = false;
		
		while(!attributed) {
			int roll = sumRolls();
			for(CarteLieu cl : lieux) {
				
				if(cl.coordinatesContains(roll) && currentJoueur.getCarteLieu() != cl){
					
					currentJoueur.deplacer(cl);
					attributed = true;
					break;
				}
			}
		}
	}
	
	public void attaquer(Joueur joueur1, Joueur joueur2) {
		
		int attaque = diffRolls();
		
		if(attaque != 0) {
			
			joueur1.attaquer(joueur2,attaque);
		}
	}
	
	public Joueur selectionnerJoueur() {
		return new Joueur("0");
	}
	
	public int diffRolls() {
		return Math.abs(roll6()-roll4());	
	}
	
	public int roll4() {
		return (int) Math.floor(Math.random() * 3)+1;
	}
	
	public int roll6() {
		return (int) Math.floor(Math.random() * 5)+1;
	}
	
	public int sumRolls()
	{
		return roll6() + roll4();
	}
	
	public List<Joueur> getJoueurs() {
		return this.joueurs;
	}

	public void setStat(String key, int valeur) {
		this.stats.put(key, valeur);
	}
	
	public int getStat(String key) {
		
		if(this.stats.containsKey(key))
		{
			return this.stats.get(key);
		}else {
		
			return -1;
		}
		
	}
	
	public void shuffleLieux(){
		
		this.lieux.forEach(x -> x.setVoisin(null));
		
		if(lieux.size() % 2 == 0) {
			
			Collections.shuffle(lieux);
			
			for(int i = 0; i < lieux.size()-2; i += 2) {
				
				lieux.get(i).setVoisin(lieux.get(i+2));
				lieux.get(i+2).setVoisin(lieux.get(i));
			}
			
		}else {
			
		}
	}
	
	public void setLieux(List<CarteLieu> lieux) {
		this.lieux = lieux;
		shuffleLieux();
	}

	public boolean choisir(Joueur joueur) {
		return gj.choisir(joueur);
	}

	public Joueur choisirAdjacents(Joueur joueur) {
		List<Joueur> joueurs = new ArrayList<Joueur>();
		CarteLieu cl = joueur.getCarteLieu();
		
		joueurs.addAll(cl.getJoueurs());
		joueurs.remove(joueur);
		joueurs.addAll(cl.getJoueursAdjacents());
		
		return gj.choisirAdjacents(joueur, joueurs);
			
		}

	public Effet choisirEffet(Joueur joueur, Effet[] effets) {
		return gj.choisirEffet(joueur,effets);
	}

	public Joueur choisirParmisTous(Joueur joueur) {
		List<Joueur> joueurs = this.getJoueurs();
		return gj.choisirParmisTous(joueur,joueurs);
	}
}
