public class MySQL implements Store {

    public static List<String> mysqlurl;
    private final String host;
    private final String user;
    private final String pass;
    private final String name;
    private final String prefix;
    private final int port;
    private static Connection conn;
    private long time;
    private Executor executor;
    private AtomicInteger ai;

    public void checkTable() {
        connect();
        final StringBuilder sb = new StringBuilder();
        sb.append("create table if not exists drop_users(");
        sb.append("name varchar(16) not null,");
        sb.append("uuid char(36) not null,");
        sb.append("points int not null,");
        sb.append("neededpoints int not null,");
        sb.append("level int not null,");
        sb.append("stone int not null,");
        sb.append("obsidian int not null,");
        sb.append("primary key(name));");
        try {
            MySQL.conn.createStatement().executeUpdate(sb.toString());
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
        disconnect();
    }

    public void loadData() throws SQLException {
        connect();
        int i = 0;
        final ResultSet rs = MySQL.conn.createStatement().executeQuery("SELECT * FROM `drop_users`");
        while (rs.next()) {
            final User u = User.get(UUID.fromString(rs.getString("uuid")));
            u.setName(rs.getString("name"));
            u.setUniqueId(UUID.fromString(rs.getString("uuid")));
            u.setPoints(rs.getInt("points"));
            u.setNeededPoints(rs.getInt("neededpoints"));
            u.setLevel(rs.getInt("level"));
            u.setStone(rs.getInt("stone"));
            u.setObsidian(rs.getInt("obsidian"));
            ++i;
        }
        System.out.println("Loaded " + i + " users!");
        disconnect();
    }

    public void saveData() throws SQLException {
    	connect();
        for (final User u : UserManager.getUsers()) {
            final StringBuilder sb = new StringBuilder();
            sb.append("INSERT INTO drop_users (name, uuid, points, neededpoints, level, stone, obsidian) VALUES (");
            sb.append("'" + u.getName() + "',");
            sb.append("'" + u.getUniqueId().toString() + "',");
            sb.append("'" + u.getPoints() + "',");
            sb.append("'" + u.getNeededPoints() + "',");
            sb.append("'" + u.getLevel() + "',");
            sb.append("'" + u.getStone() + "',");
            sb.append("'" + u.getObsidian() + "'");
            sb.append(") ON DUPLICATE KEY UPDATE ");
            sb.append("name='" + u.getName() + "',");
            sb.append("uuid='" + u.getUniqueId() + "',");
            sb.append("points='" + u.getPoints() + "',");
            sb.append("neededpoints='" + u.getNeededPoints() + "',");
            sb.append("level='" + u.getLevel() + "',");
            sb.append("stone='" + u.getStone() + "',");
            sb.append("obsidian='" + u.getObsidian() + "';");
            conn.createStatement().executeUpdate(sb.toString());
        }
        disconnect();
    }

    public MySQL(String host, int port, String user, String pass, String name, String prefix) {
        this.host = host;
        this.port = port;
        this.user = user;
        this.pass = pass;
        this.name = name;
        this.prefix = prefix;
        this.executor = Executors.newSingleThreadExecutor();
        this.time = System.currentTimeMillis();
        this.ai = new AtomicInteger();
        new BukkitRunnable() {
            public void run() {
                if (System.currentTimeMillis() - time > Time.SECOND.getTime(30)) {
                    update(false, "DO 1");
                }
            }
        }.runTaskTimer(Main.getInstance(), 600L, 600L);
    }

    public void setMysqlurl(List<String> s) {
        mysqlurl = s;
    }

    public boolean connect(){
        Main.getInstance().getLogger().info("Connecting to MySQL server...");
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection("jdbc:mysql://" + this.host + ":" + this.port + "/" + this.name, this.user, this.pass);
            Main.getInstance().getLogger().info("Connection established! Ping ");
            return true;
        } catch (ClassNotFoundException e) {
            Main.getInstance().getLogger().warning("JDBC driver not found!");
            Main.getInstance().getLogger().warning("Error: " + e.getMessage());
            e.printStackTrace();
        } catch (SQLException e) {
            Main.getInstance().getLogger().warning("Can not connect to a MySQL server!");
            Main.getInstance().getLogger().warning("Error: " + e.getMessage());
            e.printStackTrace();
        }
        return false;
    }

    public void update(boolean now, final String update) {
        this.time = System.currentTimeMillis();
        Runnable r = new Runnable() {
            public void run() {
                try {
                    conn.createStatement().executeUpdate(update.replace("{P}", prefix));
                } catch (SQLException e) {
                    Main.getInstance().getLogger().warning("Error: " + e.getMessage());
                    Main.getInstance().getLogger().info("Reconnecting...");
                    reconnect();
                }
            }
        };
        if (now) {
            r.run();
        } else {
            this.executor.execute(r);
        }
    }

    public ResultSet update(String update) {
        try {
            Statement statement = conn.createStatement();
            statement.executeUpdate(update.replace("{P}", this.prefix), 1);
            ResultSet rs = statement.getGeneratedKeys();
            if (rs.next()) {
                return rs;
            }
        } catch (SQLException e) {
            Main.getInstance().getLogger().warning("Error: " + e.getMessage());
            Main.getInstance().getLogger().info("Reconnecting...");
            reconnect();
        }
        return null;
    }

    public void disconnect() {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                Main.getInstance().getLogger().warning("Can not close the connection to the MySQL server!");
                Main.getInstance().getLogger().warning("Error: " + e.getMessage());
                e.printStackTrace();
            }
        }
    }

    public void reconnect(){
        connect();
    }

    public boolean isConnected() {
        try {
            return (!conn.isClosed()) || (conn == null);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return false;
    }

    public ResultSet query(String query) {
        try {
            return conn.createStatement().executeQuery(query.replace("{P}", this.prefix));
        } catch (SQLException e) {
            Main.getInstance().getLogger().warning("An error occurred with given query '" + query.replace("{P}", this.prefix) + "'!");
            Main.getInstance().getLogger().warning("Error: " + e.getMessage());
            e.printStackTrace();
        }
        return null;
    }

    public void query(final String query, final Callback<ResultSet> cb) {
        new Thread(new Runnable() {
            public void run() {
                try {
                    ResultSet rs = conn.createStatement().executeQuery(query.replace("{P}", prefix));
                    cb.done(rs);
                } catch (SQLException e) {
                    Main.getInstance().getLogger().warning("An error occurred with given query '" + query.replace("{P}", prefix) + "'!");
                    Main.getInstance().getLogger().warning("Error: " + e.getMessage());
                    cb.error(e);
                    e.printStackTrace();
                }
            }
        }, "MySQL Thread #" + this.ai.getAndIncrement()).start();
    }

    public Connection getConnection(){
        return conn;
    }

    public StoreMode getStoreMode(){
        return StoreMode.MYSQL;
    }
}