package me.sabbertran.infectedutils;

import com.sk89q.worldedit.bukkit.WorldEditPlugin;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import me.sabbertran.infectedutils.commands.HubCommand;
import me.sabbertran.infectedutils.commands.InfectedCommand;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scoreboard.DisplaySlot;
import org.bukkit.scoreboard.Objective;
import org.bukkit.scoreboard.Score;
import org.bukkit.scoreboard.Scoreboard;

public class InfectedUtils extends JavaPlugin
{

    private Logger log = Bukkit.getLogger();

    private WorldEditPlugin worldedit = (WorldEditPlugin) getServer().getPluginManager().getPlugin("WorldEdit");

    private HashMap<Player, Location> loc1, loc2;
    private HashMap<Player, Integer> scanningTasks;
    private HashMap<Player, Location> hologramLocations;
    private HashMap<String, ArrayList<String>> schematics;
    private HashMap<Player, Date> lastChange;

    private HashMap<Player, Boolean> hubCommandMoved;

    private File schematicsFolder = new File("plugins/InfectedUtils/schematics/");

    //TPS
    private InfectedUtils main;
    private long starttime = 0;
    private long endTime = 0;
    private ArrayList<String> serverOrder;
    private HashMap<String, String[]> serverInfo;
    private HashMap<String, String> serverStatus;

    private ArrayList<String> serverInfoSql;
    private Connection serverInfoSql_Connection;

    @Override
    public void onDisable()
    {
        for (Map.Entry<String, ArrayList<String>> entry : schematics.entrySet())
        {
            System.out.println(entry.getKey());
            try
            {
                File f = new File("plugins/InfectedUtils/schematics/" + entry.getKey() + ".yml");
                if (f.exists())
                {
                    f.delete();
                }
                f.createNewFile();
                PrintWriter pw = new PrintWriter(f);
                for (String s : entry.getValue())
                {
                    pw.println(s);
                }
                pw.close();
            } catch (IOException ex)
            {
                Logger.getLogger(InfectedUtils.class.getName()).log(Level.SEVERE, null, ex);
            }
        }

        try
        {
            serverInfoSql_Connection.close();
        } catch (SQLException ex)
        {
            Logger.getLogger(InfectedUtils.class.getName()).log(Level.SEVERE, null, ex);
        }

        log.info("InfectedUtils disabled");
    }

    @Override
    public void onEnable()
    {
        main = this;

        loc1 = new HashMap<Player, Location>();
        loc2 = new HashMap<Player, Location>();
        scanningTasks = new HashMap<Player, Integer>();
        hologramLocations = new HashMap<Player, Location>();
        schematics = new HashMap<String, ArrayList<String>>();
        lastChange = new HashMap<Player, Date>();
        hubCommandMoved = new HashMap<Player, Boolean>();

        getServer().getPluginManager().registerEvents(new Events(this), this);

        getCommand("infected").setExecutor(new InfectedCommand(this));
        getCommand("hub").setExecutor(new HubCommand(this));

        getConfig().addDefault("InfectedUtils.ServerInfo.SQL", new String[]
        {
            "Adress", "Port", "Database", "User", "Password"
        });
        getConfig().options().copyDefaults(true);
        saveConfig();

        if (!schematicsFolder.exists())
        {
            schematicsFolder.mkdirs();
        }
        for (File f : schematicsFolder.listFiles())
        {
            BufferedReader read = null;
            try
            {
                String name = f.getName().substring(0, f.getName().length() - 4);
                read = new BufferedReader(new FileReader(f));
                ArrayList<String> temp = new ArrayList<String>();
                String line;
                while ((line = read.readLine()) != null)
                {
                    temp.add(line);
                }
                schematics.put(name, temp);
                read.close();
            } catch (FileNotFoundException ex)
            {
                Logger.getLogger(InfectedUtils.class.getName()).log(Level.SEVERE, null, ex);
            } catch (IOException ex)
            {
                Logger.getLogger(InfectedUtils.class.getName()).log(Level.SEVERE, null, ex);
            }
        }

        getServer().getMessenger().registerOutgoingPluginChannel(this, "BungeeCord");

        getServer().getScheduler().scheduleSyncRepeatingTask(this, new Runnable()
        {
            @Override
            public void run()
            {
                getServer().dispatchCommand(getServer().getConsoleSender(), "save-all");
            }
        }, 0, 12000);

        getServer().getScheduler().scheduleAsyncRepeatingTask(this, new TickTask(this), 0L, 20L);

        PMessageListener listener = new PMessageListener(this);
        getServer().getMessenger().registerOutgoingPluginChannel(this, "InfectedUtils");
        getServer().getMessenger().registerIncomingPluginChannel(this, "InfectedUtils", listener);

        serverInfo = new HashMap<String, String[]>();
        serverStatus = new HashMap<String, String>();
        serverOrder = new ArrayList<String>();
        serverOrder.add("Hub");
        serverOrder.add("Genesis");
        serverOrder.add("Deathmatch");
        serverOrder.add("ZombieInvasion");
        serverOrder.add("HideAndSeek");
        serverOrder.add("Splegg");
        serverOrder.add("Build");

        serverInfoSql = new ArrayList<String>();

        serverInfoSql = (ArrayList<String>) this.getConfig().getStringList("InfectedUtils.ServerInfo.SQL");

        try
        {
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql://" + serverInfoSql.get(0) + ":" + serverInfoSql.get(1) + "/" + serverInfoSql.get(2);
            serverInfoSql_Connection = DriverManager.getConnection(url, serverInfoSql.get(3), serverInfoSql.get(4));
            serverInfoSql_Connection.createStatement().execute("CREATE TABLE IF NOT EXISTS `serverinfo` (`name` varchar(50), `tps` varchar(50), `players` varchar(50), `lastupdate` varchar(50))");

            log.info("SQL Connection established.");
        } catch (ClassNotFoundException | SQLException ex)
        {
            Logger.getLogger(InfectedUtils.class.getName()).log(Level.SEVERE, null, ex);
        }

        getServer().getScheduler().scheduleSyncRepeatingTask(this, new Runnable()
        {
            @Override
            public void run()
            {
                try
                {
                    serverInfoSql_Connection.close();
                    Class.forName("com.mysql.jdbc.Driver");
                    String url = "jdbc:mysql://" + serverInfoSql.get(0) + ":" + serverInfoSql.get(1) + "/" + serverInfoSql.get(2);
                    serverInfoSql_Connection = DriverManager.getConnection(url, serverInfoSql.get(3), serverInfoSql.get(4));

                    log.info("SQL Connection renewed.");
                } catch (ClassNotFoundException | SQLException ex)
                {
                    Logger.getLogger(InfectedUtils.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }, 72000L, 72000L);

        log.info("InfectedUtils enabled");
    }

    public void scanSurroundings(final Player p)
    {
        p.sendMessage("Scanning surroundings...");
        Scoreboard s = getServer().getScoreboardManager().getNewScoreboard();
        Objective o = s.registerNewObjective(ChatColor.GOLD + "Scanning...", "dummy");
        o.setDisplaySlot(DisplaySlot.SIDEBAR);
        o.setDisplayName(ChatColor.GOLD + "Scanning...");
        final Score sc = o.getScore("Progress (%)");
        p.setScoreboard(s);
        scanningTasks.put(p, getServer().getScheduler().scheduleSyncRepeatingTask(this, new Runnable()
        {
            int i = 0;

            @Override
            public void run()
            {
                sc.setScore(i);
                if (i == 100)
                {
                    Location l = p.getLocation();
                    boolean b = validLocation(l);
                    p.setScoreboard(getServer().getScoreboardManager().getNewScoreboard());
                    getServer().getScheduler().cancelTask(scanningTasks.get(p));
                    scanningTasks.remove(p);
                    if (b)
                    {
                        p.sendMessage("PIKACHU, PLACE HOUSE!");
                        sendHologram("test", p);
                    } else
                    {
                        p.sendMessage("You need be on a flat grass area to use these special pokemon powers.");
                    }
                }
                i++;
            }
        }, 1L, 1L));
    }

    public boolean validLocation(Location l)
    {
        for (int x = -15; x <= 15; x++)
        {
            for (int z = -15; z < 15; z++)
            {
                Location l1 = new Location(l.getWorld(), l.getX() + x, l.getY() - 1, l.getZ() + z);
                if (l1.getBlock().getType() != Material.GRASS)
                {
                    return false;
                }
                for (int y = 0; y < 15; y++)
                {
                    Location l2 = new Location(l.getWorld(), l.getX() + x, l.getY() + y, l.getZ() + z);
                    if (l2.getBlock().getType() != Material.AIR)
                    {
                        return false;
                    }
                }
            }
        }
        return true;
    }

    public void sendHologram(String name, Player p)
    {
        for (String s : schematics.get(name))
        {
            String[] split = s.split("; ");
            Location l = new Location(p.getWorld(), p.getLocation().getBlockX() + Integer.parseInt(split[0]), p.getLocation().getBlockY() + Integer.parseInt(split[1]), p.getLocation().getBlockZ() + Integer.parseInt(split[2]));
            p.sendBlockChange(l, Material.getMaterial(Integer.parseInt(split[3])), Byte.parseByte(split[4]));
        }
        hologramLocations.put(p, p.getLocation());
    }

    public void removeBlockChanges(String name, Player p)
    {
        Location l = hologramLocations.get(p);
        for (String s : schematics.get(name))
        {
            String[] split = s.split("; ");
            Location l1 = new Location(p.getWorld(), l.getBlockX() + Integer.parseInt(split[0]), l.getBlockY() + Integer.parseInt(split[1]), l.getBlockZ() + Integer.parseInt(split[2]));
            if (p.getLocation().getY() - 1 == l1.getY())
            {
                Location l2 = new Location(p.getWorld(), p.getLocation().getX(), p.getLocation().getY() - 1, p.getLocation().getZ());
                p.sendBlockChange(l1, l2.getBlock().getType(), l2.getBlock().getData());
            } else
            {
                p.sendBlockChange(l1, Material.AIR, (byte) 0);
            }
        }
        hologramLocations.remove(p);
    }

    public void pasteSchematic(String name, Player p)
    {
        if (hologramLocations.containsKey(p))
        {
            Location l = hologramLocations.get(p);
            for (String s : schematics.get(name))
            {
                String[] split = s.split("; ");
                Location l1 = new Location(l.getWorld(), l.getBlockX() + Integer.parseInt(split[0]), l.getBlockY() + Integer.parseInt(split[1]), l.getBlockZ() + Integer.parseInt(split[2]));
                l1.getBlock().setType(Material.getMaterial(Integer.parseInt(split[3])));
                l1.getBlock().setData(Byte.parseByte(split[4]));
            }
        }
    }

    public void updateServerInfo(String server, String status, String newTps, String newPlayers)
    {
        serverInfo.put(server, new String[]
        {
            newTps, newPlayers
        });
        serverStatus.put(server, status);
    }

    public void updateScoreboards()
    {
        Scoreboard board = getServer().getScoreboardManager().getNewScoreboard();
        Objective serverInfo = board.registerNewObjective("Server Info", "dummy");
        serverInfo.setDisplaySlot(DisplaySlot.SIDEBAR);
        serverInfo.setDisplayName(ChatColor.AQUA + "" + ChatColor.UNDERLINE + getServer().getMotd());
        int i = this.serverInfo.size() * 2;
        int j = 1;
        Score empty = serverInfo.getScore("");
        empty.setScore(i + 1);
        for (int k = 0; k < serverOrder.size(); k++)
        {
            String name = serverOrder.get(k);
            String status = serverStatus.get(name);
            if (status != null)
            {
                if (status.equals("Online"))
                {
                    String stps = this.serverInfo.get(name)[0];
                    String player = this.serverInfo.get(name)[1];
                    double tps;
                    if (stps.equals("--.--"))
                    {
                        tps = 0;
                    } else
                    {
                        tps = Double.parseDouble(stps);
                    }

                    if (tps == 0 || tps >= 15)
                    {
                        Score s = serverInfo.getScore(ChatColor.GREEN + name);
                        s.setScore(i);
                    } else if (tps >= 10)
                    {
                        Score s = serverInfo.getScore(ChatColor.YELLOW + name);
                        s.setScore(i);
                    } else
                    {
                        Score s = serverInfo.getScore(ChatColor.RED + name);
                        s.setScore(i);
                    }
                    Score s1 = serverInfo.getScore(j + ") " + stps + " | " + player);
                    s1.setScore(i - 1);
                } else
                {
                    Score s = serverInfo.getScore(ChatColor.DARK_RED + name);
                    s.setScore(i);
                    Score s1 = serverInfo.getScore(j + ") " + "Offline");
                    s1.setScore(i - 1);
                }
            }

            i = i - 2;
            j++;
        }

        for (Player p : getServer().getOnlinePlayers())
        {
            if (p.hasPermission("infected.admin.serverinfo"))
            {
                p.setScoreboard(board);
            } else
            {
                p.setScoreboard(getServer().getScoreboardManager().getNewScoreboard());
            }
        }
    }

    public void sendServerInfo()
    {
        try
        {
            ByteArrayOutputStream b = new ByteArrayOutputStream();
            DataOutputStream out = new DataOutputStream(b);
            out.writeUTF("Info");
            out.writeUTF("Online");
            out.writeUTF(getServer().getMotd());
            double endstart = endTime - starttime;
            double dtps = 20000 / endstart;
            if (dtps > 20)
            {
                dtps = 20;
            }
            DecimalFormat df = new DecimalFormat("00.00");
            String tps = df.format(dtps);
            out.writeUTF("" + tps);
            String players = getServer().getOnlinePlayers().length + "/" + getServer().getMaxPlayers();
            out.writeUTF(players);
            getServer().sendPluginMessage(this, "InfectedUtils", b.toByteArray());

            serverInfoSql_Connection.createStatement().execute("UPDATE serverinfo SET tps = '" + tps + "' WHERE name = '" + getServer().getMotd() + "'");
            serverInfoSql_Connection.createStatement().execute("UPDATE serverinfo SET players = '" + players + "' WHERE name = '" + getServer().getMotd() + "'");
            serverInfoSql_Connection.createStatement().execute("UPDATE serverinfo SET lastupdate = '" + new Date().getTime() + "' WHERE name = '" + getServer().getMotd() + "'");
        } catch (IOException | SQLException ex)
        {
            Logger.getLogger(InfectedUtils.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void setStartTime(long startTime)
    {
        this.starttime = startTime;
    }

    public void setEndTime(long endTime)
    {
        this.endTime = endTime;
    }

    public HashMap<Player, Integer> getScanningTasks()
    {
        return scanningTasks;
    }

    public HashMap<Player, Location> getHologramLocations()
    {
        return hologramLocations;
    }

    public HashMap<Player, Location> getLoc1()
    {
        return loc1;
    }

    public HashMap<Player, Location> getLoc2()
    {
        return loc2;
    }

    public HashMap<String, ArrayList<String>> getSchematics()
    {
        return schematics;
    }

    public WorldEditPlugin getWorldedit()
    {
        return worldedit;
    }

    public HashMap<Player, Date> getLastChange()
    {
        return lastChange;
    }

    public HashMap<Player, Boolean> getHubCommandMoved()
    {
        return hubCommandMoved;
    }

    public HashMap<String, String[]> getServerInfo()
    {
        return serverInfo;
    }

    public HashMap<String, String> getServerStatus()
    {
        return serverStatus;
    }

}