package mvc.model;

import java.util.Collection;
import java.util.Iterator;

import java.util.Observable;



import model.GameEngineImpl;
import model.SimplePlayer;
import model.enumeration.BetType;
import model.interfaces.Coin;

import model.interfaces.GameEngine;
import model.interfaces.Player;
import mvc.app.SpinPlayerThread;
import mvc.app.SpinSpinnerThread;
import mvc.view.GameEngineCallbackGUI;
import view.GameEngineCallbackImpl;
import view.interfaces.GameEngineCallback;


public class Model extends Observable{

	private static Model singletonInstance = new Model();
	private Player selectedPlayer;
	private Coin currentCoin;
	private Player addedPlayer;
	private Player removedPlayer;
	private final GameEngine gameEngine;
	private final GameEngineCallback gameCallbackGUI;
	public static final int PLAYER_ADDED = 1;
	public static final int PLAYER_REMOVED = 2;
	public static final int PLAYER_COIN_UPDATE = 3;
	public static final int SPINNER_COIN_UPDATE = 4;
	public static final int SPIN_START = 5;
	public static final int SPIN_FINISH = 6;
	public static final int SPINNER_START= 7;
	public static final int SPINNER_FINISH = 8;
	public static final int BET_UPDATE = 9;
	public static final int SELECTED_PLAYER_UPDATE = 10;

	private Thread playerThread;
	private Thread spinnerThread;
	boolean isPlayerSpinning;
	boolean isSpinnerSpinning;

	private Model() {
		gameEngine = new GameEngineImpl();
		gameCallbackGUI = new GameEngineCallbackGUI(this);
		gameEngine.addGameEngineCallback(new GameEngineCallbackImpl());
		gameEngine.addGameEngineCallback(gameCallbackGUI);
		isPlayerSpinning  = false;
		isSpinnerSpinning = false;

	}

	public void playerCoinPairChanged(Coin coin, Player player) {
	   if(player == selectedPlayer) {
		   currentCoin = coin;
		   notify(PLAYER_COIN_UPDATE);
	   }
	}
	public void spinnerCoinPairChanged(Coin coin) {
			currentCoin = coin;
		   notify(SPINNER_COIN_UPDATE);

	}

	public Coin getCurrentCoin() {
		return currentCoin;
	}

	public void spinPlayer() {
		if(selectedPlayer != null) {
			System.out.println("Player Spinned " + selectedPlayer.getPlayerId());
			playerThread = new Thread(new SpinPlayerThread(gameEngine, selectedPlayer));
			isPlayerSpinning = true;
			playerThread.start();
			notify(SPIN_START);

		}

	}
	public void spinSpinner() {
		isSpinnerSpinning = true;
		spinnerThread = new Thread(new SpinSpinnerThread(gameEngine));
		spinnerThread.start();
		notify(SPINNER_START);

	}

	public void clearBet() {
		selectedPlayer.resetBet();
		selectedPlayer.setBetType(BetType.NO_BET);
		gameEngine.addPlayer(selectedPlayer);
		notify(BET_UPDATE);
	}

	public void clearAllBets() {
		Iterator<Player> it = gameEngine.getAllPlayers().iterator();
		while(it.hasNext()) {
			it.next().resetBet();
		}
		notify(BET_UPDATE);
	}

	public static Model getSingletonInstance() {
		return singletonInstance;

	}

	public void addPlayer(Player player) {
		player.setBetType(BetType.NO_BET);
		gameEngine.addPlayer(player);
		addedPlayer = player;
		notify(PLAYER_ADDED);

	}

	private void notify(int type) {
		setChanged();
		notifyObservers(type);
	}

	public Boolean removePlayer(Player player) {

		if(gameEngine.removePlayer(player)) {
			removedPlayer = player;
			notify(PLAYER_REMOVED);
			return true;
		}else {
			return false;
		}

	}

	public Player getSelectedPlayer() {
		return selectedPlayer;
	}

	public void setSelectedPlayer(String playerID) {
		if(playerID != null) {

		if(gameEngine.getPlayer(playerID) != null) {
			this.selectedPlayer = gameEngine.getPlayer(playerID);
			System.out.println("Selected Player Changed to " + this.selectedPlayer.getPlayerName());
			notify(SELECTED_PLAYER_UPDATE);
			}
		}
	}

	public Player getAddedPlayer() {
		return addedPlayer;
	}

	public Player getRemovedPlayer() {
		return removedPlayer;
	}

	public Boolean addNewPlayer(String id, String playerName, int points) {

		if(gameEngine.getPlayer(id) != null) {
			return false;
		}else {
			System.out.println(id + playerName + points);
			Player player = new SimplePlayer(id, playerName, points);
			player.setBetType(BetType.NO_BET);
			addPlayer(player);
			return true;
		}
	}
	public boolean getisPlayerSpinning() {
		return isPlayerSpinning;
	}
	public boolean getisSpinnerSpinning() {
		return isSpinnerSpinning;
	}
	public Boolean isFinishedSpinning() {
		if(isPlayerSpinning && isSpinnerSpinning) {
			return true;
		}else {
			return false;

		}
	}

	public BetType getBetType() {
		return selectedPlayer.getBetType();
	}

	public void setBet(int bet) {
		System.out.println("SET BET");
		gameEngine.getPlayer(selectedPlayer.getPlayerId()).setBet(bet);
		notify(BET_UPDATE);
	}

	public void setBetType(BetType betType) {
		System.out.println("SET BET TYPE");

		gameEngine.getPlayer(selectedPlayer.getPlayerId()).setBetType(betType);
		notify(BET_UPDATE);
	}


	public int getSelectedPlayerBet() {
		return selectedPlayer.getBet();
	}


	public void spinPlayerFinished() {
		System.out.println("Spin Player Finished");
		playerThread.interrupt();
		isPlayerSpinning = false;
		notify(SPIN_FINISH);
		if(allPlayersSpinned()) {
			spinSpinner();
		}
	}
	public void spinSpinnerFinished() {
		isSpinnerSpinning = false;
		notify(SPINNER_FINISH);
		clearAllBets();
		spinnerThread.interrupt();
	}

	private Boolean allPlayersSpinned() {
		Iterator<Player> players = gameEngine.getAllPlayers().iterator();
		while(players.hasNext()) {
			Boolean playerSpinned = players.next().getPlayerSpinned();
			if(!playerSpinned) {
				return false;
			}
		}
		return true;

	}

	public Collection<Player> getAllCurrentPlayers() {
		return gameEngine.getAllPlayers();
	}




}