package chopper.script;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.GradientPaint;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Polygon;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.DefaultComboBoxModel;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

import org.vinsert.bot.script.Script;
import org.vinsert.bot.script.ScriptContext;
import org.vinsert.bot.script.ScriptManifest;
import org.vinsert.bot.script.api.Area;
import org.vinsert.bot.script.api.GameObject;
import org.vinsert.bot.script.api.GroundItem;
import org.vinsert.bot.script.api.Item;
import org.vinsert.bot.script.api.Model;
import org.vinsert.bot.script.api.Path;
import org.vinsert.bot.script.api.Player;
import org.vinsert.bot.script.api.Tile;
import org.vinsert.bot.script.api.Widget;
import org.vinsert.bot.script.api.generic.Filters;
import org.vinsert.bot.script.api.tools.Game;
import org.vinsert.bot.script.api.tools.Game.Tabs;
import org.vinsert.bot.script.api.tools.Inventory;
import org.vinsert.bot.script.api.tools.Navigation.NavigationPolicy;
import org.vinsert.bot.script.api.tools.Skills;
import org.vinsert.bot.util.Filter;
import org.vinsert.bot.util.Perspective;
import org.vinsert.bot.util.Vec3;

import chopper.misc.Condition;
import chopper.misc.Miscellaneous;

//public static final String COMPILED_DIR = System.clearProperty("user.home") + File.separator + "workspace" + File.separator + "vInsert Scripts" + File.separator + "bin";

@ScriptManifest(name = "Chopper", authors = { "infor42" }, description = "infor's AIO Chopper", version = 2.1)
public class Chopper extends Script {

    private Player me;
    private Miscellaneous misc;
    private ScriptContext ctx;

    private final double MOUSESPEED = 0.8D;
    public final int[] axes = new int[] { 1360, 1351, 1352, 1349, 1350, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 3063, 6740 };
    public final int[] ents = new int[] { 1740, 1731, 1735, 1736, 1739, 1737, 1734 };
    public final int[] nests = new int[] { 5071, 5072, 5073, 5074, 5075, 5070, 7413, 5076, 304 };

    public boolean isStarted = false;
    public boolean chopping = false;
    public boolean moved = false;
    public boolean powerChop = false;


    public int bankBooth;
    public int[] treeID;
    public int treeItemId;
    public double treeXP;
    public Path[] paths = new Path[2];
    public Path runPath;
    public Tile treeLoc1;
    public Tile treeLoc2;
    public Tile bankLoc;
    public Area bankArea;
    public Area treeArea;
    public Area treeArea1;
    public Area treeArea2;

    public GameObject tree;


    //#### paint variables ####
    private String status;
    private long lastAntiBan;
    private long antiBanInterval;
    private long startTime;
    private long antibanCountDown;
    private long runningTime;
    private String formattedTime;

    private String fTimeTillLevel = "00:00:00";
    private long timeTillLevel = 0L;
    private double percentToLevel = 0.0D;
    private double expPerHour = 0.0D;
    private double progressBar = 0.0D;
    private int logsInInventory;
    private int logsCut = 0;
    private int logsTillLevel;
    private int startingExp;
    private int expGained = 0;
    private Color color1 = new Color(63, 44, 242, 173);
    private Color color2 = new Color(204, 204, 204);
    private DecimalFormat percents = new DecimalFormat("###.##");
    private DecimalFormat doubles = new DecimalFormat("#");


    public String treeToCut;
    public String location;
    public boolean waitingForGui;
    public Gui gui;


    @Override
    public void close() {
        log("Stopping Script");
        this.isStarted = false;
        this.getContext().getBot().popScript();
    }

    @Override
    public boolean init() {
        this.waitingForGui = true;
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                try {
                    gui = new Gui(2.0);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        while(this.waitingForGui) {
            if(status == null) {
                status = "Waiting for Gui";
                log(status);
            }
            sleep(1000);
        }
        initVariables();

        this.ctx = this.getContext();
        this.misc = new Miscellaneous(ctx);
        this.me = this.players.getLocalPlayer();
        this.isStarted = true;

        this.lastAntiBan = 0L;
        this.antiBanInterval = (new Random().nextInt(40) + 10 * 1000L);
        this.startTime = 0L;
        this.antibanCountDown = (this.antiBanInterval / 1000L);
        this.runningTime = 0L;
        this.formattedTime = "00:00:00";

        this.logsInInventory = inventory.getCount(false, this.treeItemId);
        this.startingExp = skills.getExperience(Skills.WOODCUTTING);

        mouse.setSpeed(MOUSESPEED);
        camera.adjustPitch(100);
        misc.waitFor(new Condition() {
            @Override
            public boolean validate() {
                Chopper.this.camera.adjustPitch(100);
                return false;
            }

        }, 1000L);
        return this.isStarted;
    }

    @Override
    public int pulse() {
        this.runFromCombat();
        this.pickUpNest();
        if(!this.me.isAnimating()) {
            this.chopping = false;
        } else {
            chopping = true;
        }

        if(inventory.isFull() && !bankArea.contains(me) && !me.isMoving()) {
            if(powerChop) {
                this.dropAllExcept(new Filter<Item>() {
                    public boolean accept(Item i) {
                        return misc.contains(axes, i.getId());
                    }
                });
            } else {
                if(this.treeArea.contains(me)) {
                    this.paths[0].reset();
                }
                if(me.getLocation().distanceTo(bankLoc) >= 15) {
                    this.walkToBank();
                } else if(me.getLocation().distanceTo(bankLoc) < 15) {
                    navigation.navigate(bankLoc, NavigationPolicy.MINIMAP);
                }
            }
        }
        if(!this.treeArea.contains(this.me.getLocation()) && !me.isMoving() && !inventory.isFull()) {
            if(this.bankArea.contains(me)) {
                this.paths[1].reset();
            }
            if(me.getLocation().distanceTo(treeLoc1) >= 15 && inventory.freeSpace() >= 27 && this.bankArea.contains(me)) {
                this.walkToTrees();
            } else if(me.getLocation().distanceTo(treeLoc1) < 15) {
                navigation.navigate(treeLoc1, NavigationPolicy.MINIMAP);
            }
        }
        if(inventory.freeSpace() <= 27 && this.bankArea.contains(me) && !this.me.isMoving()) {
            this.bank();
        }
        if(!inventory.isFull() && this.treeArea.contains(this.me.getLocation()) && !this.me.isAnimating() && !this.chopping) {
            if(chop() && me.isAnimating()) {
                this.moveMouseOffScreen();
                sleep(1000, 1200);
            }

        }
        this.antiBan();
        return random(200, 300);
    }

    public void walkToOtherTree() {
        if(this.treeArea1.contains(me.getLocation())) {
            this.navigation.navigate(this.treeLoc2, NavigationPolicy.MINIMAP);
        } else if(this.treeArea2.contains(me.getLocation())) {
            this.navigation.navigate(this.treeLoc1, NavigationPolicy.MINIMAP);
        }
    }

    public boolean chop() {
        if(me.isAnimating() || me.isMoving()) {
            return false;
        }

        if(!this.chopping) {
            this.tree = this.getTree(this.treeID);
            if(!misc.contains(this.treeID, tree.getId()) || !treeArea.contains(tree)) {
                tree = null;
            }
        }

        if(tree != null && misc.isVisible(tree) && !me.isAnimating()) {
            this.status = "Chopping Tree";
            misc.interact(tree, "Chop");
            if(menu.getChoices().contains("Use")) {
                game.openTab(Game.Tabs.INVENTORY);
                misc.interact(tree, "Chop");
            }
            this.chopping = true;
            this.moved = false;
            return this.chopping;
        }

        if(tree == null && !me.isAnimating() && !this.chopping && !this.moved) {
            this.status = "Waiting for tree";
            this.walkToOtherTree();
            this.moved = true;
        } else if(tree != null && !misc.isVisible(tree) && !me.isAnimating() && !this.chopping){
            this.status = "Tree found";
            this.walkToOtherTree();
            misc.waitFor(new Condition() {
                public boolean validate() {
                    camera.rotateToObject(tree);
                    camera.adjustPitch(100);
                    return true;
                }
            }, 1000L);
            this.moved = false;
        }
        return this.chopping;
    }

    private GameObject getTree(final int[] treeID) {
        return objects.getNearest(new Filter<GameObject>() {
            @Override
            public boolean accept(GameObject obj) {
                return misc.contains(treeID, obj.getId());
            }
        });
    }

    public boolean walkToBank() {
        this.status = "Walking to bank";
        this.navigation.navigate(this.paths[0], 2, NavigationPolicy.MINIMAP);
        sleep(1000, 2000);
        return inventory.isFull();
    }

    public boolean walkToTrees() {
        this.status = "Walking to trees";
        this.navigation.navigate(this.paths[1], 2, NavigationPolicy.MINIMAP);
        sleep(1000, 2000);
        return !inventory.isFull();
    }

    public void dropAllExcept(final Filter<Item> toKeep) {
        mouse.setSpeed(.5);
        if(!widgets.get(Inventory.INVENTORY_ID, 0).isValid()) {
            game.openTab(Game.Tabs.INVENTORY);
        }
        Filter<Item> toDrop = new Filter<Item>() {
            public boolean accept(Item i) {
                return !toKeep.accept(i);
            }
        };
        List<Item> items = getItems(toDrop);
        while(items.size() > 0) {
            for(Item i : items) {
                inventory.dropItem(i);
            }
            items = getItems(toDrop);
        }
        mouse.setSpeed(MOUSESPEED);
    }

    public List<Item> getItems(Filter<Item> filter) {
        Widget inventory = widgets.get(Inventory.INVENTORY_ID, 0);
        List<Item> items = new ArrayList<>();
        if (inventory == null) return items;

        int[] ids = inventory.getSlotContents();
        int[] stacks = inventory.getSlotSizes();
        if (ids == null || stacks == null) return null;

        for (int i = 0; i < ids.length; i++) {
            if(ids[i] != 0 && stacks[i] != 0) {
                Item item = new Item(ctx, ids[i], stacks[i]);
                if (filter == null || filter.accept(item)) {
                    items.add(item);
                }
            }
        }
        return items;
    }

    public boolean bank() {
        GameObject bankBooth = objects.getNearest(new Filter<GameObject>() {
            public boolean accept(GameObject element) {
                return element.getId() == Chopper.this.bankBooth;
            }
        });
        camera.rotateToObject(bankBooth);
        if(camera.isVisible(bankBooth) && !bank.isOpen()) {
            misc.interact(bankBooth, "Bank");
            if(menu.getChoices().contains("Use")) {
                game.openTab(Tabs.INVENTORY);
                misc.interact(bankBooth, "Bank");
            }
            sleep(900, 1100);
        }
        if(bank.isOpen()) {
            mouse.setSpeed(.6);
            bank.depositAllExcept(new Filter<Item>() {
                public boolean accept(Item item) {
                    return misc.contains(axes, item.getId());
                }
            });
            mouse.setSpeed(MOUSESPEED);
        }
        this.logsInInventory = 0;
        return inventory.freeSpace() >= 27;
    }

    public void runFromCombat() {
        if(me.isInCombat()) {
            log("Running from combat");
            misc.waitFor(new Condition() {
                public boolean validate() {
                    navigation.navigate(runPath, 2, NavigationPolicy.MINIMAP);
                    return !me.isInCombat();
                }
            }, 20000L);
            navigation.navigate(this.treeLoc1, NavigationPolicy.MINIMAP);
        }
    }

    public void pickUpNest() {
        List<GroundItem> nests = groundItems.getAll(new Filter<GroundItem>() {
            public boolean accept(GroundItem gi) {
                return misc.contains(Chopper.this.nests, gi.getId()) && treeArea.contains(gi);
            }
        });
        for(GroundItem nest : nests) {
            if(nest != null && !inventory.isFull() && treeArea.contains(nest)) {
                pickup(nest);
                sleep(500, 1000);
                if(inventory.contains(Filters.itemId(nest.getId()+1))) {
                    int slot = inventory.getSlot(new Item(ctx, nest.getId()+1, 1));
                    inventory.interact(slot, "Search");
                }
                sleep(1000, 1500);
            }
        }

    }

    public void pickup(GroundItem item) {
        Tile loc = item.getLocation();
        Rectangle bounds = loc.getPolygon(ctx).getBounds();
        Point p = new Point(bounds.x + bounds.width/2, bounds.y + bounds.height/2);
        mouse.move(p.x, p.y);
        if(menu.getChoices().contains("Take")) {
            mouse.click();
        }
    }

    public void antiBan() {
        if ((System.currentTimeMillis() > this.lastAntiBan + this.antiBanInterval) && (!this.me.isMoving())) {
            int r = new java.util.Random().nextInt(12) +1;
            this.antiBanInterval = (random(10, 50) * 1000L);
            this.lastAntiBan = System.currentTimeMillis();
            this.antibanCountDown = (this.antiBanInterval / 1000L);
            if(this.chopping && me.isAnimating() && !this.me.isMoving() && treeArea.contains(me)) {
                switch (r) {
                case 1:
                    this.status = "Antiban: Check Exp";
                    this.game.openTab(Game.Tabs.STATS);
                    if(widgets.get(320, 144) != null) {
                        mouse.move(widgets.get(320, 144).getClickPoint().x, widgets.get(320, 144).getClickPoint().y);
                        sleep(3500, 5500);
                    }
                    this.game.openTab(Game.Tabs.INVENTORY);
                    this.mouseMovement();
                    break;
                case 2:
                    this.status = "Antiban: Mouse movement";
                    this.mouseMovement();
                    break;
                case 3:
                    this.mouseShake();
                    break;
                case 4:
                    List<Player> visiblePlayers = this.players.getPlayers(new Filter<Player>() {
                        public boolean accept(Player p) {
                            return camera.isVisible(p);
                        }
                    });
                    Player toInspect = visiblePlayers.get(random(visiblePlayers.size()));
                    if ((camera.isVisible(toInspect)) && (!toInspect.getName().equalsIgnoreCase(this.me.getName()))) {
                        this.status = "Antiban: Inspect Player";
                        mouse.move(toInspect.hullPoint(toInspect.hull()).x, toInspect.hullPoint(toInspect.hull()).y);
                        mouse.click(true);
                        sleep(1200, 1800);
                        this.mouseMovement();
                    } else {
                        this.status = "Antiban: Skip";
                    }
                    break;
                case 5:
                    this.status = "Antiban: Check Exp";
                    this.game.openTab(Game.Tabs.STATS);
                    if(widgets.get(320, 144) != null) {
                        mouse.move(widgets.get(320, 144).getClickPoint().x, (widgets.get(320, 144).getClickPoint().y));
                        sleep(3500, 5500);
                    }
                    this.game.openTab(Game.Tabs.INVENTORY);
                    this.mouseMovement();
                    break;
                case 6:
                    this.status = "Antiban: Camera Angle";
                    camera.rotateAngleTo(random(10, 175));
                    break;
                case 7:
                    this.status = "Antiban: Camera Angle";
                    camera.rotateAngleTo(random(10, 175));
                    break;
                case 11:
                    this.status = "Antiban: Mouse Offscreen";
                    moveMouseOffScreen();
                    break;
                case 12:
                    this.status = "Antiban: Mouse movement";
                    this.mouseMovement();
                    break;
                default:
                    this.status = "Antiban: Skip";
                }
            }
        }
    }

    public void moveMouseOffScreen() {
        switch (random(0,3)) {
        case 0:
            mouse.move(-10, random(1, 510));
            break;
        case 1:
            mouse.move(770, random(1, 510));
            break;
        case 2:
            mouse.move(random(1, 760), 510);
        }
    }

    public void mouseMovement() {
        mouse.move(random(7, 750), random(7, 400));
    }

    public void mouseShake() {
        this.status = "Antiban: Mouse Shake";
        for (int i = 0; i < random(4, 7); i++)
            mouse.move(random(10, 490), random(10, 250));
    }

    //########## Paint & GUI methods ##########//

    public void updateTimeData()
    {
        if (System.currentTimeMillis() >= this.startTime + 1000L) {
            this.runningTime += 1L;
            if (this.antibanCountDown > 0L) {
                this.antibanCountDown -= 1L;
            }
            this.startTime = System.currentTimeMillis();
        }
        int mins = 0; int hours = 0; int seconds = 0;
        seconds = (int)this.runningTime;
        mins = seconds / 60;
        hours = mins / 60;

        seconds -= mins * 60;
        mins -= hours * 60;

        DecimalFormat format = new DecimalFormat("00");

        this.formattedTime = (format.format(hours) + ":" + format.format(mins) + ":" + format.format(seconds));
    }

    public String formatClock(int s) {
        int mins = 0; int hours = 0; int seconds = 0;
        seconds = s;
        mins = seconds / 60;
        hours = mins / 60;

        seconds -= mins * 60;
        mins -= hours * 60;

        DecimalFormat format = new DecimalFormat("00");

        return format.format(hours) + ":" + format.format(mins) + ":" + format.format(seconds);
    }

    public void updatePaintData() {
        updateTimeData();
        if (inventory.getCount(false, this.treeItemId) > this.logsInInventory) {
            this.logsCut++;
            this.logsInInventory = inventory.getCount(false, this.treeItemId);
        }
        int myExp = this.skills.getExperience(Skills.WOODCUTTING);
        int expOfCurrent = Skills.EXPERIENCE_TABLE[skills.getLevel(Skills.WOODCUTTING)];
        int expOfNext = Skills.EXPERIENCE_TABLE[skills.getLevel(Skills.WOODCUTTING) + 1];
        int expTillNext = skills.getExperienceToNextLevel(Skills.WOODCUTTING);

        this.expGained = (myExp - this.startingExp);
        this.logsTillLevel = (int)((expTillNext) / this.treeXP) + 1;
        this.percentToLevel = (double)(myExp - expOfCurrent) / (expOfNext - expOfCurrent) * 100.0D;
        this.expPerHour = (this.expGained / (this.runningTime / 3600.0D));
        this.progressBar = (this.percentToLevel * 0.01D * 512.0D);
        this.timeTillLevel = (long) ((expTillNext / this.expPerHour * 3600.0D));
        this.fTimeTillLevel = formatClock((int)this.timeTillLevel);
    }


    @Override
    public void render(Graphics2D g) {
        updatePaintData();
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        if ((tree != null) && this.treeArea.contains(tree.getLocation()) && this.treeArea.contains(me)) {
            this.drawTree(g, tree, this.color1);
        }

        this.drawCursor(g, mouse.getPosition());

        Rectangle r = new Rectangle(5, 322, 511, 15);
        GradientPaint p = new GradientPaint(r.getLocation().x, r.getLocation().y, new Color(0x336A96), r.getLocation().x, (float) (r.getLocation().y + r.getHeight() +9), Color.black);
        g.setColor(new Color(201, 201, 201));
        g.fill(r);
        g.setPaint(p);
        g.fillRect(r.getLocation().x, r.getLocation().y, (int)this.progressBar, (int) r.getHeight());
        g.setColor(Color.black);
        g.drawRect(4, 321, 512, 16);
        g.drawString(this.percents.format(this.percentToLevel) + "% to " + (skills.getLevel(Skills.WOODCUTTING) + 1), 240, 335);

        g.setColor(this.color2);
        g.drawString("Time: ", 8, 256);
        g.drawString("Status: ", 8, 270);
        g.drawString("Logs Cut: ", 8, 284);
        g.drawString("Experience: ", 8, 298);
        g.drawString("Exp/Hour: ", 8, 312);
        g.setColor(Color.white);
        g.drawString(this.formattedTime, 43, 256);
        g.drawString(this.status, 49, 270);
        g.drawString(this.logsCut + " | " + this.logsTillLevel, 65, 284);
        g.drawString(""+this.expGained, 80, 298);
        g.drawString(this.doubles.format(this.expPerHour) + " | " + this.fTimeTillLevel, 70, 312);
    }

    public void drawCursor(Graphics2D g, Point p) {
        g.setColor(Color.white);
        g.drawLine(p.x + 15, p.y, p.x - 15, p.y);
        g.drawLine(p.x, p.y - 15, p.x, p.y +15);
    }

//  public void drawGroundItem(Graphics2D g) {
//      for(GroundItem obj : groundItems.getAll(null, this.treeArea)) {
//          if (!Perspective.on_screen(getContext().getClient(), obj.getLocation()))
//              continue;
//          Point point = Perspective.trans_tile_screen(getContext().getClient(), obj.getLocation(), 0.5, 0.5, 1);
//          g.setColor(Color.GREEN);
//          g.fillOval(point.x - 2, point.y - 2, 4, 4);
//          g.setColor(Color.WHITE);
//          g.drawString(""+obj.getId(), point.x +15, point.y +15);
//      }
//  }

//  public void drawTile(Graphics2D g) {
//      for(Tile t : pa.getTiles()) {
//          if (!Perspective.on_screen(getContext().getClient(), t))
//              continue;
//          Point point = Perspective.trans_tile_screen(getContext().getClient(), t, 0.5, 0.5, 1);
//          g.setColor(Color.GREEN);
//          g.fillOval(point.x - 2, point.y - 2, 4, 4);
//          g.setColor(Color.WHITE);
//          g.drawString(""+t.toString(), point.x +5, point.y +5);
//      }
//      g.drawString("" + pa.contains(me), 20, 40);
//  }

    public void drawTree(Graphics2D graphics, GameObject obj, Color color) {
        Model model = obj.getModel();
        if ((model == null) || (!model.isValid())) {
            return;
        }

        Vec3[][] vectors = model.getVectors();

        graphics.setColor(color);

        int gx = obj.getLocation().getGx();
        int gy = obj.getLocation().getGy();
        for (Vec3[] points : vectors) {
            Vec3 pa = points[0];
            Vec3 pb = points[1];
            Vec3 pc = points[2];

            Point a = Perspective.trans_tile_cam(getContext().getClient(), gx + (int)pa.x, gy + (int)pc.x, 0 - (int)pb.x);
            Point b = Perspective.trans_tile_cam(getContext().getClient(), gx + (int)pa.y, gy + (int)pc.y, 0 - (int)pb.y);
            Point c = Perspective.trans_tile_cam(getContext().getClient(), gx + (int)pa.z, gy + (int)pc.z, 0 - (int)pb.z);

            if ((a.x >= 0) && (b.x >= 0) && (c.x >= 0)) {
                Polygon poly = new Polygon(new int[] { a.x, b.x, c.x }, new int[] { a.y, b.y, c.y }, 3);

                graphics.drawPolygon(poly);
            }
        }
    }

    private class Gui extends JFrame implements ActionListener {

        private static final long serialVersionUID = 1L;
        private JComboBox<String> locationBox;
        private JComboBox<String> treeBox;
        private String[] trees = { "Willows", "Maples", "Yews", "Tower Magics", "Magics" };
        private String[] locations = { "Seers", "Draynor", "Catherby" };
        private JButton start;
        private JButton cancel;
        private JLabel locationLabel;
        private JLabel treeLabel;
        private JCheckBox powerChop;


        @SuppressWarnings({ "rawtypes", "unchecked" })
        public Gui(double ver) {
            super("Chopper " + ver);
            this.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
            JPanel contentPane = (JPanel)this.getContentPane();
            contentPane.setLayout(new BoxLayout(this.getContentPane(), BoxLayout.Y_AXIS));

            JPanel row1 = new JPanel();
            JPanel row2 = new JPanel();

            row1.setLayout(new BoxLayout(row1, BoxLayout.X_AXIS));
            row2.setLayout(new BoxLayout(row2, BoxLayout.X_AXIS));

            locationLabel = new JLabel("Location:");
            treeLabel = new JLabel("Tree:");

            locationBox = new JComboBox<>();
            locationBox.setModel(new DefaultComboBoxModel(locations));
            locationBox.setMaximumSize(new Dimension(locationBox.getPreferredSize().width + 50, locationBox.getPreferredSize().height));
            locationBox.addActionListener(this);

            treeBox = new JComboBox<>();
            treeBox.setModel(new DefaultComboBoxModel(trees));
            treeBox.setMaximumSize(new Dimension(treeBox.getPreferredSize().width + 50, treeBox.getPreferredSize().height));

            powerChop = new JCheckBox("Power Chop");
            powerChop.setSelected(false);
            powerChop.addActionListener(this);

            start = new JButton("Start");
            start.addActionListener(this);
            cancel = new JButton("Cancel");
            cancel.addActionListener(this);

            row1.add(Box.createHorizontalStrut(10));
            row1.add(locationLabel);
            row1.add(Box.createHorizontalStrut(5));
            row1.add(locationBox);
            row1.add(Box.createHorizontalStrut(10));
            row1.add(treeLabel);
            row1.add(Box.createHorizontalStrut(5));
            row1.add(treeBox);
            row1.add(Box.createHorizontalStrut(10));
            row2.add(start);
            row2.add(Box.createHorizontalStrut(10));
            row2.add(cancel);
            row2.add(Box.createHorizontalStrut(10));
            row2.add(powerChop);

            contentPane.add(row1);
            contentPane.add(Box.createVerticalStrut(30));
            contentPane.add(row2);
            contentPane.add(Box.createVerticalStrut(10));
            this.pack();
            this.setResizable(false);
            this.setLocationRelativeTo(null);
            this.pack();
            this.setLocationRelativeTo(Chopper.this.getContext().getBot().getWindow().getFrame());
            this.setVisible(true);
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            Chopper.this.powerChop = this.powerChop.isSelected();
            if(e.getSource().equals(this.start)) {
                Chopper.this.treeToCut = treeBox.getSelectedItem().toString();
                Chopper.this.location = locationBox.getSelectedItem().toString();
                Chopper.this.waitingForGui = false;
                this.setVisible(false);
            } else if(e.getSource().equals(this.locationBox)) {
                switch(this.locationBox.getSelectedItem().toString()) {
                case "Seers":
                    treeBox.removeAllItems();
                    treeBox.addItem("Willows");
                    treeBox.addItem("Maples");
                    treeBox.addItem("Yews");
                    treeBox.addItem("Tower Magics");
                    treeBox.addItem("Magics");
                    break;
                case "Draynor":
                    treeBox.removeAllItems();
                    treeBox.addItem("Willows");
                    break;
                case "Catherby":
                    treeBox.removeAllItems();
                    treeBox.addItem("Yews");
                    break;
                }
            } else if(e.getSource().equals(cancel)) {
                Chopper.this.close();
                this.dispose();
            }
        }
    }

    public void initVariables() {
        if(this.treeToCut == null || this.location == null) {
            log("Tree and location were not selected");
            this.close();
        }

        log("Starting Script: cutting " + this.treeToCut + " at " + this.location);

        if(treeToCut.equals("Yews")) {
            this.treeID = new int[1];
            this.treeID[0] = 1309;
            this.treeItemId = 1516;
            this.treeXP = 175;

            if(location.equalsIgnoreCase("Seers")) {
                this.bankBooth = 25808;
                this.bankLoc = new Tile(2725, 3492);
                this.bankArea = new Area(new Tile(2721, 3490), new Tile(2730, 3493));
                this.treeArea = new Area(new Tile(3082, 3226), new Tile(3091, 3239));
                this.treeLoc1 = new Tile(2714, 3462);
                this.treeLoc2 = new Tile(2707, 3462);
                this.treeArea = new Area(new Tile(2704, 3459), new Tile(2716, 3467));
                this.treeArea1 = new Area(new Tile(2711, 3459), new Tile(2716, 3464));
                this.treeArea2 = new Area(new Tile(2704, 3459), new Tile(2709, 3466));
                this.runPath = new Path(new Tile(2717, 3462), new Tile(2728, 3464));
                this.paths[0] = new Path(new Tile(2720, 3467), new Tile(2726, 3477), new Tile(2725, 3491));
                this.paths[1] = new Path(new Tile(2720, 3484), new Tile(2718, 3470), new Tile(2713, 3463));
            }

            if(location.equalsIgnoreCase("Catherby")) {
                this.bankBooth = 2213;
                this.bankLoc = new Tile(2810, 3440);
                this.bankArea = new Area(new Tile(2806, 3438), new Tile(2812, 3441));
                this.treeArea = new Area(new Tile(2754, 3426), new Tile(2773, 3440));
                this.treeArea1 = this.treeArea;
                this.treeArea2 = this.treeArea;
                this.treeLoc1 = new Tile(2763, 3434);
                this.treeLoc2 = new Tile(2758, 3431);
                this.runPath = new Path(new Tile(2751, 3419));
                this.paths[0] = new Path(new Tile(2769, 3432), new Tile(2781, 3432), new Tile(2795, 3433), new Tile(2807, 3433), new Tile(2810, 3440));
                this.paths[1] = new Path(new Tile(2800, 3432), new Tile(2788, 3432), new Tile(2775, 3433), new Tile(2763, 3430));
            }
        }
        if(treeToCut.equalsIgnoreCase("Tower Magics")) {
            this.treeID = new int[1];
            this.treeID[0] = 1306;
            this.treeItemId = 1514;
            this.treeXP = 200;

            this.bankBooth = 25808;
            this.bankLoc = new Tile(2725, 3492);
            this.bankArea = new Area(new Tile(2721, 3490), new Tile(2730, 3493));
            this.treeArea = new Area(new Tile(3082, 3226), new Tile(3091, 3239));
            this.treeLoc1 = new Tile(2703, 3398);
            this.treeLoc2 = this.treeLoc1;
            this.treeArea = new Area(new Tile(2697, 3394), new Tile(2706, 3464));
            this.treeArea1 = this.treeArea;
            this.treeArea2 = this.treeArea;
            this.runPath = new Path(new Tile(2701, 3387));
            this.paths[0] = new Path(new Tile(2715, 3399), new Tile(2716, 3412), new Tile(2707, 3424), new Tile(2709, 3437), new Tile(2712, 3450), new Tile(2721, 3459), new Tile(2720, 3467), new Tile(2726, 3477), new Tile(2725, 3491));
            this.paths[1] = new Path(new Tile(2720, 3484), new Tile(2718, 3470), new Tile(2719, 3457), new Tile(2710, 3450), new Tile(2710, 3437), new Tile(2717, 3426), new Tile(2716, 3413), new Tile(2716, 3400), new Tile(2708, 3391), new Tile(2702, 3398));
        }
        if(treeToCut.equalsIgnoreCase("Magics")) {
            this.treeID = new int[1];
            this.treeID[0] = 1306;
            this.treeItemId = 1514;
            this.treeXP = 200;

            if(location.equalsIgnoreCase("Seers")) {
                this.bankBooth = 25808;
                this.bankLoc = new Tile(2725, 3492);
                this.bankArea = new Area(new Tile(2721, 3490), new Tile(2730, 3493));
                this.treeArea = new Area(new Tile(3082, 3226), new Tile(3091, 3239));
                this.treeArea = new Area(new Tile(2688, 3422), new Tile(2698, 3430));
                this.treeArea1 = this.treeArea;
                this.treeArea2 = this.treeArea;
                this.treeLoc1 = new Tile(2694, 3424);
                this.treeLoc2 = new Tile(2692, 3426);
                this.runPath = new Path(new Tile(2711, 2422));
                this.paths[0] = new Path(new Tile(2707, 3432), new Tile(2708, 3444), new Tile(2715, 3454), new Tile(2721, 3462), new Tile(2724, 3475), new Tile(2724, 3484), new Tile(2725, 3490));
                this.paths[1] = new Path(new Tile(2720, 3484), new Tile(2718, 3470), new Tile(2719, 3457), new Tile(2711, 3450), new Tile(2708, 3437), new Tile(2703, 3429), new Tile(2694, 3425));
            }
        }
        if(this.treeToCut.equalsIgnoreCase("Willows")) {
            this.treeID = new int[4];
            this.treeID[0] = 1308;
            this.treeID[1] = 5551;
            this.treeID[2] = 5552;
            this.treeID[3] = 5553;
            this.treeItemId = 1520;
            this.treeXP = 67.5;

            if(this.location.equalsIgnoreCase("Seers")) {
                this.bankBooth = 25808;
                this.bankLoc = new Tile(2725, 3492);
                this.bankArea = new Area(new Tile(2721, 3490), new Tile(2730, 3493));
                this.treeArea = new Area(new Tile(2703, 3504), new Tile(2714, 3517));
                this.treeArea1 = this.treeArea;
                this.treeArea2 = this.treeArea;
                this.treeLoc1 = new Tile(2708, 3508);
                this.treeLoc2 = this.treeLoc1;
                this.runPath = new Path(new Tile(2702, 3498));
                this.paths[0] = new Path(new Tile(2716, 3498), new Tile (2726, 3492));
                this.paths[1] = new Path(new Tile(2717, 3497), new Tile(2709, 3508));
            }

            if(this.location.equalsIgnoreCase("Draynor")) {
                this.bankBooth = 2213;
                this.bankLoc = new Tile(3093, 3243);
                this.bankArea = new Area(new Tile(3092, 3240), new Tile(3097, 3246));
                this.treeArea = new Area(new Tile(3082, 3226), new Tile(3091, 3239));
                this.treeArea1 = this.treeArea;
                this.treeArea2 = this.treeArea;
                this.treeLoc1 = new Tile(3089, 3230);
                this.treeLoc2 = new Tile(3090, 3230);
                this.runPath = new Path(new Tile(3100, 3234));
                this.paths[0] = new Path(new Tile(3093, 3242));
                this.paths[1] = new Path(this.treeLoc1);
            }
        }
        if(treeToCut.equalsIgnoreCase("Maples")) {
            this.treeID = new int[1];
            this.treeID[0] = 1307;
            this.treeItemId = 1518;
            this.treeXP = 100;

            if(this.location.equalsIgnoreCase("Seers")) {
                this.bankBooth = 25808;
                this.bankLoc = new Tile(2725, 3492);
                this.bankArea = new Area(new Tile(2721, 3490), new Tile(2730, 3493));
                this.treeArea = new Area(new Tile(2677, 3520), new Tile(2687, 3531));
                this.treeArea1 = this.treeArea;
                this.treeArea2 = this.treeArea;
                this.treeLoc1 = new Tile(2682, 3525);
                this.treeLoc2 = this.treeLoc1;
                this.runPath = new Path(new Tile(2675, 3521));
                this.paths[0] = new Path(new Tile(2686, 3517), new Tile(2694, 3510), new Tile(2702, 3508), new Tile(2714, 3507), new Tile(2716, 3498), new Tile(2726, 3492));
                this.paths[1] = new Path(new Tile(2718, 3500), new Tile(2707, 3508), new Tile(2694, 3511), new Tile(2685, 3518), new Tile(2683, 3525));
            }
        }
    }
}