package com.Acrobot.ChestShop.UUIDs;

import com.Acrobot.Breeze.Utils.Encoding.Base62;
import com.Acrobot.Breeze.Utils.NameUtil;
import com.Acrobot.Breeze.Collection.SimpleCache;
import com.Acrobot.ChestShop.ChestShop;
import com.Acrobot.ChestShop.Configuration.Properties;
import com.Acrobot.ChestShop.Database.Account;
import com.Acrobot.ChestShop.Database.DaoCreator;
import com.Acrobot.ChestShop.Permission;
import com.Acrobot.ChestShop.Signs.ChestShopSign;
import com.j256.ormlite.dao.Dao;

import org.apache.commons.lang.Validate;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;

import java.sql.SQLException;
import java.util.Date;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.logging.Level;

/**
 * Lets you save/cache username and UUID relations
 *
 * @author Andrzej Pomirski (Acrobot)
 */
@SuppressWarnings("UnusedAssignment") // I deliberately set the variables to null while initializing
public class NameManager {
    private static Dao<Account, String> accounts;

    private static SimpleCache<String, Account> usernameToAccount = new SimpleCache<>(Properties.CACHE_SIZE);
    private static SimpleCache<UUID, Account> uuidToAccount = new SimpleCache<>(Properties.CACHE_SIZE);
    private static SimpleCache<String, Account> shortToAccount = new SimpleCache<>(Properties.CACHE_SIZE);

    private static Account adminAccount;
    private static Account serverEconomyAccount;

    /**
     * Get account info from a UUID
     *
     * @param uuid The UUID of the player to get the account info
     * @return The account info or <tt>null</tt> if none was found
     */
    public static Account getAccount(UUID uuid) {
        try {
            return uuidToAccount.get(uuid, () -> {
                try {
                    Account account = accounts.queryBuilder().orderBy("lastSeen", false).where().eq("uuid", uuid).queryForFirst();
                    if (account != null) {
                        account.setUuid(uuid); // HOW IS IT EVEN POSSIBLE THAT UUID IS NOT SET EVEN IF WE HAVE FOUND THE PLAYER?!
                        shortToAccount.put(account.getShortName(), account);
                        usernameToAccount.put(account.getName(), account);
                        return account;
                    }
                } catch (SQLException e) {
                    ChestShop.getBukkitLogger().log(Level.WARNING, "Error while getting account for " + uuid + ":", e);
                }
                throw new Exception("Could not find account for " + uuid);
            });
        } catch (ExecutionException ignored) {
            return null;
        }
    }

    /**
     * Get account info from a non-shortened username
     *
     * @param fullName The full name of the player to get the account info
     * @return The account info or <tt>null</tt> if none was found
     * @throws IllegalArgumentException if the username is empty or null
     */
    public static Account getAccount(String fullName) {
        Validate.notEmpty(fullName, "fullName cannot be null or empty!");
        try {
            return usernameToAccount.get(fullName, () -> {
                try {
                    Account account = accounts.queryBuilder().orderBy("lastSeen", false).where().eq("name", fullName).queryForFirst();
                    if (account != null) {
                        account.setName(fullName); // HOW IS IT EVEN POSSIBLE THAT THE NAME IS NOT SET EVEN IF WE HAVE FOUND THE PLAYER?!
                        shortToAccount.put(account.getShortName(), account);
                        return account;
                    }
                } catch (SQLException e) {
                    ChestShop.getBukkitLogger().log(Level.WARNING, "Error while getting account for " + fullName + ":", e);
                }
                throw new Exception("Could not find account for " + fullName);
            });
        } catch (ExecutionException ignored) {
            return null;
        }
    }

    /**
     * Get account info from a username that might be shortened
     *
     * @param shortName The name of the player to get the account info
     * @return The account info or <tt>null</tt> if none was found
     * @throws IllegalArgumentException if the username is empty
     */
    public static Account getAccountFromShortName(String shortName) {
        Validate.notEmpty(shortName, "shortName cannot be null or empty!");
        if (shortName.length() > 15) {
            return getAccount(shortName);
        }

        try {
            return shortToAccount.get(shortName, () -> {
                try {
                    Account account = accounts.queryBuilder().where().eq("shortName", shortName).queryForFirst();
                    if (account != null) {
                        account.setShortName(shortName); // HOW IS IT EVEN POSSIBLE THAT THE NAME IS NOT SET EVEN IF WE HAVE FOUND THE PLAYER?!
                        return account;
                    }
                } catch (SQLException e) {
                    ChestShop.getBukkitLogger().log(Level.WARNING, "Error while getting account for " + shortName + ":", e);
                }
                throw new Exception("Could not find account for " + shortName);
            });
        } catch (ExecutionException ignored) {
            return null;
        }
    }

    /**
     * Get the information from the last time a player logged in that previously used the shortened name
     *
     * @param shortName The name of the player to get the last account for
     * @return The last account or <tt>null</tt> if none was found
     * @throws IllegalArgumentException if the username is not a shortened name and longer than 15 chars
     */
    public static Account getLastAccountFromShortName(String shortName) {
        Account account = getAccountFromShortName(shortName); // first get the account associated with the short name
        if (account != null) {
            return getAccount(account.getUuid()); // then get the last account that was online with that UUID
        }
        return null;
    }

    /**
     * Get the UUID from a player's (non-shortened) username
     *
     * @param username The player's username
     * @return The UUID or <tt>null</tt> if the UUID can't be found or an error occurred
     * @deprecated Use {@link NameManager#getAccount(String)}
     */
    @Deprecated
    public static UUID getUUID(String username) {
        Validate.notEmpty(username, "username cannot be null or empty!");
        Player player = Bukkit.getPlayer(username);
        if (player != null) {
            return player.getUniqueId();
        }
        Account account = getAccount(username);
        if (account != null) {
            return account.getUuid();
        }
        OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(username);
        if (offlinePlayer != null && offlinePlayer.hasPlayedBefore() && offlinePlayer.getUniqueId() != null) {
            return offlinePlayer.getUniqueId();
        }
        return null;
    }

    /**
     * Get the username from a player's UUID
     *
     * @param uuid The UUID of the player
     * @return The username that is stored or <tt>null</tt> if none was found
     * @deprecated Use {@link NameManager#getAccount(UUID)}
     */
    @Deprecated
    public static String getUsername(UUID uuid) {
        Player player = Bukkit.getPlayer(uuid);
        if (player != null) {
            return player.getName();
        }
        Account account = getAccount(uuid);
        if (account != null) {
            return account.getName();
        }
        OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(uuid);
        if (offlinePlayer != null && offlinePlayer.hasPlayedBefore() && offlinePlayer.getName() != null) {
            return offlinePlayer.getName();
        }
        return null;
    }

    /**
     * Get the full username from another username that might be shortened
     *
     * @param shortName The name of the player to get the full username for
     * @return The full username or <tt>null</tt> if none was found
     * @throws IllegalArgumentException if the username is not a shortened name and longer than 15 chars
     * @deprecated Use {@link NameManager#getAccountFromShortName(String)}
     */
    @Deprecated
    public static String getFullUsername(String shortName) {
        Account account = getLastAccountFromShortName(shortName);
        if (account != null) {
            return account.getName();
        }
        return null;
    }

    /**
     * Get the short username from a full username
     *
     * @param fullName The name of the player to get the short username for
     * @return The short username or <tt>null</tt> if none was found
     * @deprecated Use {@link NameManager#getAccount(String)}
     */
    @Deprecated
    public static String getShortUsername(String fullName) {
        Account account = getAccount(fullName);
        return account != null ? account.getShortName() : null;
    }

    /**
     * Store the username of a player into the database and the username-uuid cache
     *
     * @param player The data transfer object of the player to store
     */
    public static void storeUsername(final PlayerDTO player) {
        final UUID uuid = player.getUniqueId();

        Account latestAccount = null;
        try {
            latestAccount = accounts.queryBuilder().where().eq("uuid", uuid).and().eq("name", player.getName()).queryForFirst();
        } catch (SQLException e) {
            ChestShop.getBukkitLogger().log(Level.WARNING, "Error while searching for latest account of " + player.getName() + "/" + uuid + ":", e);
        }

        if (latestAccount == null) {
            latestAccount = new Account(player.getName(), player.getUniqueId());
            latestAccount.setShortName(getNewShortenedName(player));
        }

        latestAccount.setLastSeen(new Date());
        try {
            accounts.createOrUpdate(latestAccount);
        } catch (SQLException e) {
            ChestShop.getBukkitLogger().log(Level.WARNING, "Error while updating account " + latestAccount + ":", e);
        }

        usernameToAccount.put(latestAccount.getName(), latestAccount);
        uuidToAccount.put(uuid, latestAccount);
        shortToAccount.put(latestAccount.getShortName(), latestAccount);
    }

    /**
     * Get a new unique shortened name that hasn't been used by another player yet
     *
     * @param player The player data to get the shortened name for
     * @return A new shortened name that hasn't been used before and is a maximum of 15 chars long
     */
    private static String getNewShortenedName(PlayerDTO player) {
        String shortenedName = NameUtil.stripUsername(player.getName());

        Account account = getAccountFromShortName(shortenedName);
        if (account == null) {
            return shortenedName;
        }
        for (int id = 0; account != null; id++) {
            String baseId = Base62.encode(id);
            shortenedName = NameUtil.stripUsername(player.getName(), 15 - 1 - baseId.length()) + ":" + baseId;
            account = getAccountFromShortName(shortenedName);
        }

        return shortenedName;
    }

    public static boolean canUseName(Player player, String name) {
        if (ChestShopSign.isAdminShop(name)) {
            return Permission.has(player, Permission.ADMIN);
        }

        if (Permission.otherName(player, name)) {
            return true;
        }

        Account account = getAccountFromShortName(name);
        return account != null && (account.getUuid().equals(player.getUniqueId())
                || (!account.getName().equalsIgnoreCase(name) && Permission.otherName(player, account.getName())));
    }

    public static boolean isAdminShop(UUID uuid) {
        return adminAccount != null && uuid.equals(adminAccount.getUuid());
    }

    public static boolean isServerEconomyAccount(UUID uuid) {
        return serverEconomyAccount != null && uuid.equals(serverEconomyAccount.getUuid());
    }

    public static void load() {
        try {
            accounts = DaoCreator.getDaoAndCreateTable(Account.class);

            adminAccount = new Account(Properties.ADMIN_SHOP_NAME, Bukkit.getOfflinePlayer(Properties.ADMIN_SHOP_NAME).getUniqueId());
            accounts.createOrUpdate(adminAccount);

            if (!Properties.SERVER_ECONOMY_ACCOUNT.isEmpty()) {
                serverEconomyAccount = getAccount(Properties.SERVER_ECONOMY_ACCOUNT);
                if (serverEconomyAccount == null || serverEconomyAccount.getUuid() == null) {
                    serverEconomyAccount = null;
                    ChestShop.getBukkitLogger().log(Level.WARNING, "Server economy account setting '" + Properties.SERVER_ECONOMY_ACCOUNT + "' doesn't seem to be the name of a known player! Please log in at least once in order for the server economy account to work.");
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static Account getServerEconomyAccount() {
        return serverEconomyAccount;
    }

}