package io.github.mikey.TrustedGamesBattle;

import java.util.Timer;
import java.util.TimerTask;

import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.java.JavaPlugin;

import com.mewin.WGRegionEvents.events.RegionEnterEvent;
import com.mewin.WGRegionEvents.events.RegionLeaveEvent;

import io.github.mikey.TrustedGamesBattle.Backend.BackendManager;
import io.github.mikey.TrustedGamesBattle.Backend.MySQL;
import io.github.mikey.TrustedGamesBattle.Config.ConfigManager;

public class Main extends JavaPlugin implements Listener {

    ConfigManager ConfigManager;
    MySQL Connection;
    BackendManager BackendManager;
    Timer autoUpdater;

    public void onEnable()
    {
        ConfigManager = new ConfigManager(this);
        Connection = new MySQL(this, ConfigManager.getMySQLAddress(), ConfigManager.getMySQLPort(), ConfigManager.getMySQLDatabaseName(), "MySQLInventories", ConfigManager.getMySQLUsername(), ConfigManager.getMySQLPassword());
        Connection.dbConnect();
        BackendManager = new BackendManager(this, Connection);
        this.getServer().getPluginManager().registerEvents(this, this);
        autoUpdater = new Timer();
        if(!(ConfigManager.getUpdateDelay() <= 0))
        {
            startAutoUpdater(ConfigManager.getUpdateDelay());
        }
    }

    @SuppressWarnings("deprecation")
    public void onDisable()
    {
        Bukkit.getServer().getScheduler().cancelAllTasks();
        Bukkit.getServer().getScheduler().cancelTasks(this);
        autoUpdater.cancel();
        if(Bukkit.getOnlinePlayers().length > 0)
    {

    }
        }


    private void startAutoUpdater(int delay)
    {
        delay = delay * 1000;
        autoUpdater.scheduleAtFixedRate(new TimerTask() {
              @SuppressWarnings("deprecation")
            @Override
              public void run()
              {
                  if(Connection.isConnected())
                  {
                      if(Bukkit.getOnlinePlayers().length > 0)
                      {
                          for(Player p : Bukkit.getOnlinePlayers())
                          {
                              BackendManager.saveInventory(p);
                          }
                      }
                  }
                  else
                  {
                      Connection.dbConnect();
                  }
              }
        }, delay, delay);
    }

    @EventHandler
    public void onRegionEnter(RegionEnterEvent e){
        if (e.getRegion().getId().contains("battle")) {
            if(ConfigManager.getSaveOnRegionEnter())
            {
                BackendManager.saveInventory(e.getPlayer());
                e.getPlayer().getInventory().clear();
                e.getPlayer().getInventory().setArmorContents(null);
                e.getPlayer().getInventory().setLeggings(new ItemStack(Material.DIAMOND_LEGGINGS));
                e.getPlayer().getInventory().setBoots(new ItemStack(Material.DIAMOND_BOOTS));
                e.getPlayer().getInventory().setChestplate(new ItemStack(Material.DIAMOND_CHESTPLATE));
                e.getPlayer().getInventory().setHelmet(new ItemStack(Material.DIAMOND_HELMET));
                e.getPlayer().getInventory().addItem(new ItemStack(Material.DIAMOND_SWORD));
                e.getPlayer().getInventory().addItem(new ItemStack(Material.GOLDEN_APPLE,1,(short)1));
                e.getPlayer().sendMessage(ChatColor.DARK_BLUE + "" + ChatColor.BOLD + "[" + ChatColor.BLUE + "TG" + " " + "Battle" + ChatColor.DARK_BLUE + ChatColor.BOLD + "]" + ChatColor.RESET + ChatColor.RED + "Kill Your Opponent For A Reward");
                }else e.setCancelled(true);
         }
    }


    @EventHandler
    public void onRegionLeave(RegionLeaveEvent e){
        if (e.getRegion().getId().contains("battle")){
            }

    {

        BackendManager.restoreInventory(e.getPlayer());
    }
    }
    }

package io.github.mikey.TrustedGamesBattle.Backend;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitRunnable;

public class BackendManager {

    private JavaPlugin plugin;
    private MySQL connection;

    public BackendManager(JavaPlugin plugin, MySQL connection)
    {
        this.plugin = plugin;
        this.connection = connection;
    }

    public void saveInventory(Player player)
    {
        ItemStack[] contents = player.getInventory().getContents();
        ItemStack[] armor = player.getInventory().getArmorContents();
        saveInventory(player.getName(), contents, armor);
    }

    public void saveInventory(String player, ItemStack[] contents, ItemStack[] armor)
    {
        new SaveTask(player, contents, armor).runTaskAsynchronously(this.plugin);
    }

    public void restoreInventory(Player p)
    {
        p.getInventory().clear();
        p.getInventory().setArmorContents(null);
        new RestoreTask(p).runTaskAsynchronously(this.plugin);
    }

    private class SaveTask extends BukkitRunnable {

        String player;
        ItemStack[] contents;
        ItemStack[] armor;

        public SaveTask(String player, ItemStack[] contents, ItemStack[] armor)
        {
            this.player = player;
            this.contents = contents;
            this.armor = armor;
        }

        public void run()
        {
            byte[] contentsByte = Serializer.Serialize(contents);
            byte[] armorByte = Serializer.Serialize(armor);

            try {
                PreparedStatement prest1 = connection.getConnection().prepareStatement("SELECT * FROM MySQLInventories WHERE Player=?");
                prest1.setString(1, player);
                ResultSet result = prest1.executeQuery();
                if(!result.next())
                {
                    PreparedStatement prest2 = connection.getConnection().prepareStatement("INSERT INTO MySQLInventories (Player, Inventory, Armor) VALUES (?, ?, ?)");
                    prest2.setString(1, player);
                    prest2.setBytes(2, contentsByte);
                    prest2.setBytes(3, armorByte);
                    prest2.executeUpdate();
                }
                else
                {
                    PreparedStatement prest2 = connection.getConnection().prepareStatement("UPDATE MySQLInventories SET Inventory=?, Armor=? WHERE Player=?");
                    prest2.setBytes(1, contentsByte);
                    prest2.setBytes(2, armorByte);
                    prest2.setString(3, player);
                    prest2.executeUpdate();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    private class RestoreTask extends BukkitRunnable {

        Player player;

        public RestoreTask(Player player)
        {
            this.player = player;
        }

        public void run()
        {

            PreparedStatement prest1;
            try {
                prest1 = connection.getConnection().prepareStatement("SELECT * FROM MySQLInventories WHERE Player=?");
                prest1.setString(1, player.getName());
                ResultSet result = prest1.executeQuery();
                if(result.next())
                {
                    final ItemStack[] contents = Serializer.Deserialize(result.getBytes(2), false);
                    final ItemStack[] armor = Serializer.Deserialize(result.getBytes(3), true);
                    // Restore the ItemStack's using a thread-safe sync task
                    plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {
                        public void run() {
                            player.getInventory().setContents(contents);
                            player.getInventory().setArmorContents(armor);
                            player.updateInventory();
                        }
                    });
                }

            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

}

package io.github.mikey.TrustedGamesBattle.Backend;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.zip.GZIPOutputStream;

public class Compression {



    public static byte[] compress(byte[] content){
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            try{
                GZIPOutputStream gzipOutputStream = new GZIPOutputStream(byteArrayOutputStream);
                gzipOutputStream.write(content);
                gzipOutputStream.close();
            } catch(IOException e){
                throw new RuntimeException(e);
            }
            return byteArrayOutputStream.toByteArray();
        }

        public static byte[] decompress(byte[] contentBytes){
            java.io.ByteArrayInputStream bytein = new java.io.ByteArrayInputStream(contentBytes);
            java.util.zip.GZIPInputStream gzin = null;
            try {
                gzin = new java.util.zip.GZIPInputStream(bytein);
            } catch (IOException e) {
                e.printStackTrace();
            }
            java.io.ByteArrayOutputStream byteout = new java.io.ByteArrayOutputStream();

            int res = 0;
            byte buf[] = new byte[1024];
            while (res >= 0) {
                try {
                    res = gzin.read(buf, 0, buf.length);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (res > 0) {
                    byteout.write(buf, 0, res);
                }
            }
            return byteout.toByteArray();
        }





}

package io.github.mikey.TrustedGamesBattle.Backend;

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitRunnable;

public class MySQL {

    public MySQL(JavaPlugin plugin, String host, int port, String database, String table, String username, String password)
    {
        strUri = "jdbc:mysql://" + host + ":" + port + "/" + database;
        strUser = username;
        strPassword = password;
        this.plugin = plugin;
        strTable = table;
    }

    public Connection conn = null;
    public Statement stmt = null;
    public boolean dbConnSuccess = false;

    public String strUri = "jdbc:mysql://localhost:3300/database";
    public String strUser;
    public String strPassword;
    public String strTable;
    private JavaPlugin plugin;

    public void dbConnect(){
        new ConnectTask().runTaskAsynchronously(this.plugin);
    }

    public ResultSet dbStm(String s){
        ResultSet results = null;
        try {
            results = stmt.executeQuery(s);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return results;
    }

    public Connection getConnection()
    {
        return conn;
    }

    public void executeUpdate(String s){
        try {
            stmt.executeUpdate(s);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void checkConnection()
    {
        try {
            if(this.conn.isClosed())
            {
                dbConnect();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public boolean isConnected()
    {
        try {
            return !this.conn.isClosed();
        } catch (SQLException e) {
        }
        return false;
    }

    private class ConnectTask extends BukkitRunnable {
        public void run() {
            try {
                Class.forName("com.mysql.jdbc.Driver");
            } catch (ClassNotFoundException e) {
                System.out.print("[MySQLInventories] Fatal error connecting to MySQL:");
                e.printStackTrace();
                return;
            }
            try {
                conn = DriverManager.getConnection(strUri, strUser, strPassword);
            } catch (SQLException e) {
                System.out.print("[MySQLInventories] Fatal error connecting to MySQL:");
                e.printStackTrace();
                return;
            }
            try {
                stmt = conn.createStatement();
            } catch (SQLException e) {
                System.out.print("[MySQLInventories] Fatal error connecting to MySQL:");
                e.printStackTrace();
                return;
            }
            System.out.print("[MySQLInventories] Successfully connected to MySQL.");
            dbConnSuccess = true;

            try {
                DatabaseMetaData metadata = conn.getMetaData();
                ResultSet resultSet;
                resultSet = metadata.getTables(null, null, "MySQLInventories", null);
                if(!resultSet.next())
                {
                    System.out.print("[MySQLInventories] Creating new MySQL table.");
                    executeUpdate("CREATE TABLE MySQLInventories (Player VARCHAR(16), Inventory BLOB, Armor BLOB);");
                }

            } catch (SQLException e) {
                System.out.print("[MySQLInventories] Fatal error creating MySQL table:");
                e.printStackTrace();
            }

        }
    }

}


package io.github.mikey.TrustedGamesBattle.Backend;

import java.io.UnsupportedEncodingException;

import org.bukkit.configuration.InvalidConfigurationException;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.inventory.ItemStack;

public class Serializer {

    public static byte[] Serialize(ItemStack[] items)
    {
        String converted = "";
        YamlConfiguration config = new YamlConfiguration();
        if(items.length > 0)
        {
            int num = 0;
            for(ItemStack item : items)
            {
                if(item != null)
                {
                    config.set(Integer.toString(num), item);
                }
                num += 1;
            }
        }
        converted = config.saveToString();
        byte[] compressed;
        try {
            compressed = Compression.compress(converted.getBytes("ASCII"));
            return compressed;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static ItemStack[] Deserialize(byte[] data, boolean armor)
    {
        byte[] decompressed = Compression.decompress(data);
        String text = "";
        try {
            text = new String(decompressed, "ASCII");
        } catch (UnsupportedEncodingException e1) {
            e1.printStackTrace();
        }
        YamlConfiguration config = new YamlConfiguration();
        try {
            config.loadFromString(text);
        } catch (InvalidConfigurationException e) {
            e.printStackTrace();
        }
        ItemStack[] items = null;
        if(config.getKeys(false).size() > 0)
        {
            if(armor)
            {
                items = new ItemStack[4];
            }
            else
            {
                items = new ItemStack[36];
            }

            for(String key : config.getKeys(false))
            {
                items[Integer.parseInt(key)] = config.getItemStack(key);
            }
        }
        return items;
    }

}

package io.github.mikey.TrustedGamesBattle.Config;

import java.io.File;
import java.io.IOException;

import org.bukkit.plugin.java.JavaPlugin;

public class ConfigManager {

    private JavaPlugin plugin;
    private File configFile;

    public ConfigManager(JavaPlugin plugin)
    {
        this.plugin = plugin;
        if(!plugin.getDataFolder().exists())
        {
            plugin.getDataFolder().mkdir();
        }
        configFile = new File(plugin.getDataFolder() + "/config.yml");
        if(!configFile.exists())
        {
            try {
                configFile.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
            setDefaults();
            saveConfig();
        }
    }

    public void saveConfig()
    {
        try {
            this.plugin.getConfig().save(configFile);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void setDefaults()
    {
        setMySQLAddress("localhost");
        setMySQLPort(3306);
        setMySQLDatabaseName("inventories");
        setMySQLUsername("root");
        setMySQLPassword("password");
        setSaveOnRegionEnter(true);
        setUpdateDelay(300);
    }

    public void setMySQLAddress(String value)
    {
        this.plugin.getConfig().set("mysql.address", value);
    }

    public void setMySQLPort(int value)
    {
        this.plugin.getConfig().set("mysql.port", value);
    }

    public void setMySQLDatabaseName(String value)
    {
        this.plugin.getConfig().set("mysql.database", value);
    }

    public void setMySQLUsername(String value)
    {
        this.plugin.getConfig().set("mysql.username", value);
    }

    public void setMySQLPassword(String value)
    {
        this.plugin.getConfig().set("mysql.password", value);
    }

    public void setSaveOnRegionEnter(boolean value)
    {
        this.plugin.getConfig().set("save-on-quit", value);
    }

    public void setUpdateDelay(int value)
    {
        this.plugin.getConfig().set("auto-upload-delay", value);
    }

    public String getMySQLAddress()
    {
        return this.plugin.getConfig().getString("mysql.address");
    }

    public int getMySQLPort()
    {
        return this.plugin.getConfig().getInt("mysql.port");
    }

    public String getMySQLDatabaseName()
    {
        return this.plugin.getConfig().getString("mysql.database");
    }

    public String getMySQLUsername()
    {
        return this.plugin.getConfig().getString("mysql.username");
    }

    public String getMySQLPassword()
    {
        return this.plugin.getConfig().getString("mysql.password");
    }

    public boolean getSaveOnRegionEnter()
    {
        return this.plugin.getConfig().getBoolean("save-on-quit");
    }

    public int getUpdateDelay()
    {
        return this.plugin.getConfig().getInt("auto-upload-delay");
    }

}