public class EconomyService implements Economy {

    @Override
    public boolean isEnabled() {
        return true;
    }

    @Override
    public String getName() {
        return "MoConomy";
    }

    @Override
    public boolean hasBankSupport() {
        return false;
    }

    @Override
    public int fractionalDigits() {
        return 2;
    }

    @Override
    public String format(double v) {
        return new DecimalFormat("#,##0.00").format(v);
    }

    @Override
    public String currencyNamePlural() {
        return MoConomy.config.getProperty("currencyName").toString();
    }

    @Override
    public String currencyNameSingular() {
        return MoConomy.config.getProperty("currencyName").toString();
    }

    @Override
    public boolean hasAccount(String s) {
        return MoConomy.db.hasPlayer(s);
    }

    @Override
    public boolean hasAccount(OfflinePlayer offlinePlayer) {
        return MoConomy.db.hasPlayer(offlinePlayer.getUniqueId());
    }

    @Override
    public boolean hasAccount(String s, String s1) {
        return MoConomy.db.hasPlayer(s);
    }

    @Override
    public boolean hasAccount(OfflinePlayer offlinePlayer, String s) {
        return MoConomy.db.hasPlayer(offlinePlayer.getUniqueId());
    }

    @Override
    public double getBalance(String s) {
        final UUID uuid = MoConomy.uuidFetcher.getUUID(s);
        if(uuid != null && MoConomy.playerCache.containsKey(uuid))
            return MoConomy.playerCache.get(uuid).getBalance().doubleValue();
        else
            return MoConomy.db.getBalance(s).get().doubleValue();
    }

    @Override
    public double getBalance(OfflinePlayer offlinePlayer) {
        final UUID uuid = offlinePlayer.getUniqueId();
        if(uuid != null && MoConomy.playerCache.containsKey(uuid))
            return MoConomy.playerCache.get(uuid).getBalance().doubleValue();
        else
            return MoConomy.db.getBalance(uuid).get().doubleValue();
    }

    @Override
    public double getBalance(String s, String s1) {
        final UUID uuid = MoConomy.uuidFetcher.getUUID(s);
        if(uuid != null && MoConomy.playerCache.containsKey(uuid))
            return MoConomy.playerCache.get(uuid).getBalance().doubleValue();
        else
            return MoConomy.db.getBalance(s).get().doubleValue();
    }

    @Override
    public double getBalance(OfflinePlayer offlinePlayer, String s) {
        final UUID uuid = offlinePlayer.getUniqueId();
        if(uuid != null && MoConomy.playerCache.containsKey(uuid))
            return MoConomy.playerCache.get(uuid).getBalance().doubleValue();
        else
            return MoConomy.db.getBalance(uuid).get().doubleValue();
    }

    @Override
    public boolean has(String s, double v) {
        return getBalance(s) >= v;
    }

    @Override
    public boolean has(OfflinePlayer offlinePlayer, double v) {
        return getBalance(offlinePlayer) >= v;
    }

    @Override
    public boolean has(String s, String s1, double v) {
        return getBalance(s) >= v;
    }

    @Override
    public boolean has(OfflinePlayer offlinePlayer, String s, double v) {
        return getBalance(offlinePlayer) >= v;
    }

    @Override
    public EconomyResponse withdrawPlayer(String s, double v) {
        final UUID uuid = MoConomy.uuidFetcher.getUUID(s);
        if(uuid != null && MoConomy.playerCache.containsKey(uuid)) {
            MoConomy.playerCache.get(uuid).decreaseBalance(BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(s), EconomyResponse.ResponseType.SUCCESS, "Success");
        } else {
            MoConomy.db.decreaseBalance(s, BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(s), EconomyResponse.ResponseType.SUCCESS, "Success");
        }
    }

    @Override
    public EconomyResponse withdrawPlayer(OfflinePlayer offlinePlayer, double v) {
        final UUID uuid = offlinePlayer.getUniqueId();
        if(MoConomy.playerCache.containsKey(uuid)) {
            MoConomy.playerCache.get(uuid).decreaseBalance(BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(offlinePlayer), EconomyResponse.ResponseType.SUCCESS, "Success");
        } else {
            MoConomy.db.decreaseBalance(uuid, BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(offlinePlayer), EconomyResponse.ResponseType.SUCCESS, "Success");
        }
    }

    @Override
    public EconomyResponse withdrawPlayer(String s, String s1, double v) {
        final UUID uuid = MoConomy.uuidFetcher.getUUID(s);
        if(uuid != null && MoConomy.playerCache.containsKey(uuid)) {
            MoConomy.playerCache.get(uuid).decreaseBalance(BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(s), EconomyResponse.ResponseType.SUCCESS, "Success");
        } else {
            MoConomy.db.decreaseBalance(s, BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(s), EconomyResponse.ResponseType.SUCCESS, "Success");
        }
    }

    @Override
    public EconomyResponse withdrawPlayer(OfflinePlayer offlinePlayer, String s, double v) {
        final UUID uuid = offlinePlayer.getUniqueId();
        if(MoConomy.playerCache.containsKey(uuid)) {
            MoConomy.playerCache.get(uuid).decreaseBalance(BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(offlinePlayer), EconomyResponse.ResponseType.SUCCESS, "Success");
        } else {
            MoConomy.db.decreaseBalance(uuid, BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(offlinePlayer), EconomyResponse.ResponseType.SUCCESS, "Success");
        }
    }

    @Override
    public EconomyResponse depositPlayer(String s, double v) {
        final UUID uuid = MoConomy.uuidFetcher.getUUID(s);
        if(uuid != null && MoConomy.playerCache.containsKey(uuid)) {
            MoConomy.playerCache.get(uuid).increaseBalance(BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(s), EconomyResponse.ResponseType.SUCCESS, "Success");
        } else {
            MoConomy.db.increaseBalance(s, BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(s), EconomyResponse.ResponseType.SUCCESS, "Success");
        }
    }

    @Override
    public EconomyResponse depositPlayer(OfflinePlayer offlinePlayer, double v) {
        final UUID uuid = offlinePlayer.getUniqueId();
        if(MoConomy.playerCache.containsKey(uuid)) {
            MoConomy.playerCache.get(uuid).increaseBalance(BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(offlinePlayer), EconomyResponse.ResponseType.SUCCESS, "Success");
        } else {
            MoConomy.db.increaseBalance(uuid, BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(offlinePlayer), EconomyResponse.ResponseType.SUCCESS, "Success");
        }
    }

    @Override
    public EconomyResponse depositPlayer(String s, String s1, double v) {
        final UUID uuid = MoConomy.uuidFetcher.getUUID(s);
        if(uuid != null && MoConomy.playerCache.containsKey(uuid)) {
            MoConomy.playerCache.get(uuid).increaseBalance(BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(s), EconomyResponse.ResponseType.SUCCESS, "Success");
        } else {
            MoConomy.db.increaseBalance(s, BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(s), EconomyResponse.ResponseType.SUCCESS, "Success");
        }
    }

    @Override
    public EconomyResponse depositPlayer(OfflinePlayer offlinePlayer, String s, double v) {
        final UUID uuid = offlinePlayer.getUniqueId();
        if(MoConomy.playerCache.containsKey(uuid)) {
            MoConomy.playerCache.get(uuid).increaseBalance(BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(offlinePlayer), EconomyResponse.ResponseType.SUCCESS, "Success");
        } else {
            MoConomy.db.increaseBalance(uuid, BigDecimal.valueOf(v));
            return new EconomyResponse(v, getBalance(offlinePlayer), EconomyResponse.ResponseType.SUCCESS, "Success");
        }
    }

    @Override
    public EconomyResponse createBank(String s, String s1) {
        return null;
    }

    @Override
    public EconomyResponse createBank(String s, OfflinePlayer offlinePlayer) {
        return null;
    }

    @Override
    public EconomyResponse deleteBank(String s) {
        return null;
    }

    @Override
    public EconomyResponse bankBalance(String s) {
        return null;
    }

    @Override
    public EconomyResponse bankHas(String s, double v) {
        return null;
    }

    @Override
    public EconomyResponse bankWithdraw(String s, double v) {
        return null;
    }

    @Override
    public EconomyResponse bankDeposit(String s, double v) {
        return null;
    }

    @Override
    public EconomyResponse isBankOwner(String s, String s1) {
        return null;
    }

    @Override
    public EconomyResponse isBankOwner(String s, OfflinePlayer offlinePlayer) {
        return null;
    }

    @Override
    public EconomyResponse isBankMember(String s, String s1) {
        return null;
    }

    @Override
    public EconomyResponse isBankMember(String s, OfflinePlayer offlinePlayer) {
        return null;
    }

    @Override
    public List<String> getBanks() {
        return null;
    }

    @Override
    public boolean createPlayerAccount(String s) {
        return MoConomy.db.createAccount(s);
    }

    @Override
    public boolean createPlayerAccount(OfflinePlayer offlinePlayer) {
        return MoConomy.db.createAccount(offlinePlayer.getUniqueId());
    }

    @Override
    public boolean createPlayerAccount(String s, String s1) {
        return MoConomy.db.createAccount(s);
    }

    @Override
    public boolean createPlayerAccount(OfflinePlayer offlinePlayer, String s) {
        return MoConomy.db.createAccount(offlinePlayer.getUniqueId());
    }

}