package com.dev.costela.database.client;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;

import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
import org.bukkit.event.player.AsyncPlayerPreLoginEvent.Result;
import org.bukkit.event.player.PlayerLoginEvent;

import com.dev.costela.Main;
import com.dev.costela.database.SQLWriter;
import com.google.common.collect.Maps;

/*
 * The Client is a pre loaded version of GamePlayer that loads before JoinEvent is called.
 * While the client data is loading the thread is locked.
 *
 * Clients shutdowns (saving important informations like encrypted player's password) to database on OverlandsClientLoginEvent,
 * this event is called after PlayerJoinEvent > after /register or /login command. Otherwise client will be removed after a timeout.
 */
public class ClientCore implements Listener {

	private Map<UUID, Client> users;
	private Map<String, Object> lockMap;
	private Object lock = new Object();
	private AtomicInteger clientsConnecting;
	private AtomicInteger clientsProcessing;

	public ClientCore() {
		users = Collections.synchronizedMap(Maps.newHashMap());
		lockMap = Collections.synchronizedMap(Maps.newHashMap());
		clientsProcessing = new AtomicInteger(0);
		clientsConnecting = new AtomicInteger(0);
	}

	@EventHandler(priority = EventPriority.LOWEST)
	public void connectAndProcessClient(AsyncPlayerPreLoginEvent event) {

		try {
			clientsConnecting.incrementAndGet(); //Client's connecting.
			try {
				while (clientsProcessing.get() >= 5) { //Thread must do a quick sleep to avoid over processing.
					Thread.sleep(30); //Thread sleep, login locked during 30ms
				}
			} catch (InterruptedException ex) {
				ex.printStackTrace();
			}
			try {
				clientsProcessing.incrementAndGet(); //Client's processing.
				Main.clientManager.addPlayer(event.getUniqueId());
				if(!load(addClient(event.getUniqueId()), event.getName(), event.getUniqueId(), event.getAddress().getHostAddress())) {
					event.disallow(Result.KICK_OTHER, "§cTente reconectar em 3 segundos.");
				}
			} catch (Exception ex) {
				event.disallow(Result.KICK_OTHER, "§cErro ao carregar data, tente novamente.");
			} finally {
				clientsProcessing.decrementAndGet();
			}
		} finally {
			clientsConnecting.decrementAndGet();
		}
	}

	@EventHandler(priority = EventPriority.MONITOR)
	public void processLogin(PlayerLoginEvent e) {
		synchronized (lock) {
			if (!users.containsKey(e.getPlayer().getUniqueId())) {
				users.put(e.getPlayer().getUniqueId(), new Client(e.getPlayer().getUniqueId()));
			}
		}

		Client client = get(e.getPlayer().getUniqueId());
		if (client == null || client.getRank() == null) {
			e.disallow(PlayerLoginEvent.Result.KICK_OTHER, "§cErro ao carregar data, tente reconectar.");
			return;
		}

		client.setPlayer(e.getPlayer());
		client.setName(e.getPlayer().getName());

		/*if (client.isBanned()) {
			e.disallow(PlayerLoginEvent.Result.KICK_OTHER, MessageUtil.color("&cVocê está banido do servidor. "
					+ "\n" + client.getBanReason() + "\n" +
					" \n" +
					"&fTempo restante: &c" + getBanManager().getTimeLeft(client.getBanEnd())));

			delete(client.getUuid());
			return;
		}*/

		Main.get().getLogger().info("Client with name " +  e.getPlayer().getName() + " was loaded.");

	}

	public boolean load(Client client, String name, UUID uuid, String ip) {
		long operationStart = System.currentTimeMillis();

		lockMap.put(name, new Object());

		new SQLWriter() {
			int accountId = -1;
			ResultSet resultSet = null;
			PreparedStatement preparedStatement = null;
			PreparedStatement preparedStatementInfo = null;
			@Override
			public void onWrite() throws SQLException {
				try {
					if(!Main.getDataManager().checkPlayer(uuid.toString())) {
			            preparedStatementInfo = Main.get().getDB().getConnection().get().prepareStatement("INSERT INTO `players` (`id`, `uuid`, `playername`) VALUES (NULL, ?, ?);");
			            preparedStatementInfo.setString(1, uuid.toString());
			            preparedStatementInfo.setString(2, name);
			            preparedStatementInfo.executeUpdate();
					}
					String SELECT_QUERY = "SELECT `id`, `rank` FROM `players` WHERE `uuid` = ? LIMIT 1;";
					preparedStatement = Main.get().getDB().getConnection().get().prepareStatement(SELECT_QUERY);
					preparedStatement.setString(1, uuid.toString());
					resultSet = preparedStatement.executeQuery();
					if(resultSet != null && resultSet.next()) {
						accountId = resultSet.getInt(1);
						client.setRank(resultSet.getString("rank"));
					}
					client.setAccountId(accountId);
					lockMap.remove(name);
				}finally {
					if(preparedStatement != null)
						preparedStatement.close();
					if(preparedStatementInfo != null)
						preparedStatementInfo.close();
					if(resultSet != null)
						resultSet.close();
				}
			}
		}.writeOperation(Main.get().getDB().getExecutor(), Main.get().getLogger(), "Erro ao carregar dados de " + name);

		//Sleeps the thread with a timeout of 15s util loading Thread is finished.
		while (lockMap.containsKey(client.getName()) && System.currentTimeMillis() - operationStart < 15000) {
			try {
				Thread.sleep(2);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		if(lockMap.containsKey(client.getName())) {
			Main.get().getLogger().severe("SQL DEMOROU MUITO PARA RESPONDER.");
		}

		return !lockMap.containsKey(client.getName());

	}

	public void flushAndDelete(UUID uuid) {
		new SQLWriter() {
			PreparedStatement preparedStatement = null;
			@Override
			public void onWrite() throws SQLException {
				String query = "UPDATE `players` WHERE `uuid` = ?;";
				try {
					preparedStatement = Main.get().getDB().getConnection().get().prepareStatement(query.toString());
					preparedStatement.setString(1, uuid.toString());
					preparedStatement.executeUpdate();
				}finally {
					delete(uuid);
				}
			}

		}.writeOperation(Main.get().getDB().getExecutor(), Main.get().getLogger(), "Erro ao salvar client UUID " + uuid.toString());
	}

	public Client addClient(UUID uuid) {
		Client newClient = new Client(uuid);
		Client oldClient = null;
		synchronized (lock) {
			oldClient = users.put(uuid, newClient);
		}
		if (oldClient != null) {
			oldClient.close();
		}
		return newClient;
	}

	public void delete(UUID uuid) {
		synchronized (lock) {
			if (users.containsKey(uuid)) {
				get(uuid).close();
				users.remove(uuid);
			}
		}
	}

	public Client get(String name) {
		synchronized (lock) {
			return users.values().stream().filter(cur -> cur.getName().equalsIgnoreCase(name)).findFirst()
					.orElseGet(null);
		}
	}

	public Client get(UUID uuid) {
		synchronized (lock) {
			return users.get(uuid);
		}
	}

	public Client get(Player p) {
		synchronized (lock) {
			return users.get(p.getUniqueId());
		}
	}

	public Collection<Client> getClients() {
		return users.values();
	}

}