import javax.swing.*;

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.List;

import org.rsbot.event.events.*;
import org.rsbot.event.listeners.*;
import org.rsbot.bot.*;
import org.rsbot.script.wrappers.*;
import org.rsbot.script.*;

@ScriptManifest(authors = {"lord_qaz"}, name = "yewMurder", version = 2.3, description = "<html><body><b>Chops yews at GE</b></body></html>")
public class yewMurder extends Script implements PaintListener, MessageListener
{
    final double cVer = getClass().getAnnotation(ScriptManifest.class).version();
    final String cName = getClass().getAnnotation(ScriptManifest.class).name();
    
    int trainStat;
    int style = 0;
    int startStatLvl;
    int startXp;
    int logs = 0;
    
    String status = "Starting up";

    long startTime = System.currentTimeMillis();
    
    int yewTreeIDs[] = {1309};
    int yewTreeStumpID = 7402;
    
    RSTile bankTile = new RSTile(3168, 3489);
    RSTile yewTiles[] = {new RSTile(3205, 3504), new RSTile(3210, 3504), new RSTile(3222, 3503)};
    RSTile waitTiles[] = {new RSTile(3207, 3503), new RSTile(3208, 3503), new RSTile(3221, 3501)};
    
    RSTile yewTile = yewTiles[0];
    
    int hatchetID[] = {1351,1349,1361,1355,1357,1359,1353,6739};
    
    int currentTree;
    boolean noHatchet = false;
    boolean kill = false;
    
    boolean treeSwitch = false;
    
    long treeTimer[] = new long[yewTiles.length];
    
    enum treeStatus
    {
        GREEN, BROWN, RED
    }
    
    treeStatus yewPositions[] = new treeStatus[yewTiles.length];

    public boolean onStart() 
    {
        log("Starting yewMurder");
        trainStat = skills.getIndex("woodcutting");
        
        startStatLvl = skills.getCurrentLevel(trainStat);
        startXp = skills.getCurrentExp(trainStat);
				
        for (int i = 0; i < yewTiles.length; i++)
        {
            yewPositions[i] = treeStatus.GREEN;
        }

        return true;
    }
    
    public void onRepaint(Graphics g) 
    {
        if (game.isLoggedIn()) 
        {
            double millis = System.currentTimeMillis() - startTime;
            
            int levelChange = skills.getCurrentLevel(trainStat) - startStatLvl;
            int xpChange = skills.getCurrentExp(trainStat) - startXp;
            int clvl = skills.getCurrentLevel(trainStat);
            int xpPerHour = (int)((xpChange / millis) * (1000 * 3600));
            int lpH = (int)((logs / millis) * (1000 * 3600));
            
            String time = formatTime((int)(millis/1000));
            String tTL = (xpChange != 0 && millis != 0) ? formatTime((int)((skills.getExpToNextLevel(trainStat) / (xpChange / millis)) / 1000)) : formatTime(0);
            String pTL = "" + skills.getPercentToNextLevel(trainStat);
        
            //paint
            g.setColor(Color.WHITE);
            g.setFont(new Font("Arial", Font.BOLD, 14));
            g.drawString(cName + " v" + cVer + " ", 334, 33);
            
            g.setFont(new Font("Arial", Font.PLAIN, 11));
            //draw green trees
            for (int i = 0;i < yewTiles.length;i++)
            {
                if (yewPositions[i] == treeStatus.GREEN)
                {
                    g.setColor(new Color(80,225,100));
                    g.fillOval(334 + i*20, 44, 16,16);
                }
                else if (yewPositions[i] == treeStatus.BROWN)
                {
                    g.setColor(new Color(85,60,60));
                    g.fillOval(334 + i*20, 44, 16,16);
                    
                    g.setColor(Color.WHITE);
                    int temp = (int)((System.currentTimeMillis() - treeTimer[i])/1000);                
                    drawCenteredString(temp + "", 334 + i*20 + 9, 56,g);
                }
                else if (yewPositions[i] == treeStatus.RED)
                {
                    g.setColor(Color.RED);
                    g.fillOval(334 + i*20, 44, 16,16);
                }
                
                if (i == currentTree)
                {
                    if (treeSwitch && yewPositions[i] != treeStatus.BROWN)
                    {        
                        g.setColor(Color.CYAN);
                    }
                    else
                    {
                        g.setColor(Color.YELLOW);
                    }
                    
                    g.drawOval(334 + i*20, 44, 16,16);
                }
            }
            
            g.setFont(new Font("zurich ex bt", Font.BOLD, 11));
            
            g.setColor(new Color(255,255,255,255));
            g.drawString("Status: " + status, 334, 78);
            g.setFont(new Font("zurich ex bt", Font.PLAIN, 11));
            g.setColor(Color.ORANGE);
            
            g.drawString("clvl: " + clvl + " lvl+: " + levelChange, 334, 89);
            g.drawString("xp+: " + xpChange + " xp/h:  " + xpPerHour, 334, 100);
            g.drawString("ttL: " + tTL + " %tL: " + pTL + "%", 334, 111);
            g.drawString("logs: " + logs + " logs/h: " + lpH, 334,122);
            g.setColor(Color.YELLOW);
            
            g.setFont(new Font("zurich ex bt", Font.BOLD, 11));
            g.drawString("Runtime: " + time, 334, 144);
        
        }
    }
    
    String formatTime(int seconds)
    {
        return (((int)seconds / 3600 < 10 ? "0" : "") + (int)seconds / 3600 + ":" + ((int)seconds / 60 % 60 < 10 ? "0" : "") + (int)seconds / 60 % 60 + ":" + ((int)seconds % 60 < 10 ? "0" : "") + (int)seconds % 60);
    }
        
    public void drawCenteredString(String s, int x, int y, Graphics g) 
    {
        FontMetrics fm = g.getFontMetrics();
        int xN = x - fm.stringWidth(s) / 2;
        g.drawString(s, xN, y);
    }
    
    int runControl() 
    {
        if (!walking.isRunEnabled() && (walking.getEnergy() > random(20, 30)))
        {
            walking.setRun(true);
            return 500;
        }
        return 10;
    }
    
    public void onFinish() 
    {
        log("Exiting...");
    }
    
    public int walkTileMMDirect(RSTile tt)
    {
        final int x1 = getMyPlayer().getLocation().getX();
        final int y1 = getMyPlayer().getLocation().getY();
        final int x = tt.getX() - x1;
        final int y = tt.getY() - y1;
        double angle = Math.atan2(y, x);
        
        int d = Math.min(calc.distanceTo(tt), random(9,20));
        
        RSTile tile = new RSTile(getMyPlayer().getLocation().getX() + (int)(d * Math.cos(angle)), getMyPlayer().getLocation().getY() + (int)(d * Math.sin(angle)));
        walking.walkTileMM(tile);
        return 200;
    }


    public int useBank() 
    {
        try
        {
            if (bank.isOpen()) 
            {
                status = "Depositing";
                if (inventory.containsOneOf(hatchetID))
                {
                    bank.depositAllExcept(hatchetID);
                }
                else
                {
                    bank.depositAll();
                }
            }
            else
            {
                status = "Opening bank";
                //bank.open(); //damn thing sucks
				if (random(1,3) == 2)
				{
	                RSNPC banker = npcs.getNearest(6533);
	                
	                if (banker != null)
	                {
	                    banker.doAction("bank bank");
	                }
				}
				else
				{
					bank.open();
				}
			}
        }
        catch (Exception e)
        {
            log("useBank() error");
            e.printStackTrace();
        }
        return 1200;
    }

    public int goYews()
    {
        //(3190,3488)
        if (getMyPlayer().getLocation().getX() < 3186)
        {
            walkTileMMDirect(new RSTile(3193, 3488));
        }
        else
        {
            walkTileMMDirect(yewTiles[0]);
        }

        return 200;
    }
    
    public boolean atYews()
    {
        for (treeStatus tr : yewPositions)
        {
            if (tr == treeStatus.RED)
            {
                return false;
            }
        }
        return true;
    }
            
    public boolean atBank()
    {
        return calc.distanceTo(bankTile) < 3;
    }
    
    public int goBank()
    {
        walkTileMMDirect(bankTile);
        return 300;
    }
    
    public int chopYews()
    {
        try
        {
            if (calc.tileOnScreen(yewTiles[currentTree]) && calc.distanceTo(yewTiles[currentTree]) < 5)
            {
                if (yewPositions[currentTree] == treeStatus.GREEN)
                {
                    if (getMyPlayer().getAnimation() == -1 || treeSwitch == true)
                    {
                        status = "Clicking tree";
                        tiles.doAction(yewTiles[currentTree],"chop");
                        treeSwitch = false;
                        return 400;
                    }
                    else
                    {
                        status = "Chopping";
                        return runControl();
                    }
                }
                else
                {
                    //wait
                    status = "Waiting for spawn";
                    return 100;
                }
            }
            else
            {
                status = "Moving to tree";
                walkTileMMDirect(waitTiles[currentTree]);
                return 400;
            }
            
        }
        catch (final Exception e)
        {
            log("chopYews() error, caught.");
            e.printStackTrace();
        }   
        return 600;
    }
                    
    public int loop() 
    {
        if (noHatchet)
        {
            log("No usable hatchet equiped or in inventory");
            return -1;
        }
        
        if (kill)
        {
            log("Shutdown message recieved");
            return -1;
        }
        
        getTreeStatus();
        int newTree = getCurrentTree();
        
        if (currentTree != newTree)
        {
            treeSwitch = true;
            currentTree = newTree;
        }
        
        if(atBank())
        {
            if(!inventory.isFull())
            {
                status = "Walking to yews";
                return goYews();
            }
            else
            {
                status = "Using bank";
                return useBank();
            }
        }
        else
        {
            if(!inventory.isFull())
            {
                if (!atYews())
                {
                    return goYews();
                }
                return chopYews();
            }
            else
            {
                status = "Moving to bank";
                return goBank();
            } 
        }
    }
    
    boolean checkIfTreeID(int id)
    {
        for (int i : yewTreeIDs)
        {
            if (id == i)
            {
                return true;
            }
        }
        return false;
    }
    
    void getTreeStatus()
    {
        for (int i = 0;i < yewTiles.length;i++)
        {
        
            if (calc.distanceTo(yewTiles[i]) < 24)
            {
                RSObject obj = objects.getTopAt(yewTiles[i]);
                if (obj != null)
                {
                    if (checkIfTreeID(obj.getID()))
                    {
                        yewPositions[i] = treeStatus.GREEN;
                    }
                    else if(obj.getID() == yewTreeStumpID)
                    {
                        if (yewPositions[i] == treeStatus.GREEN)
                        {
                            treeTimer[i] = System.currentTimeMillis();
                        }                    
                        yewPositions[i] = treeStatus.BROWN;
                        
                    }
                }
                else
                {
                    yewPositions[i] = treeStatus.RED;
                }                
            }
            else
            {
                yewPositions[i] = treeStatus.RED;
            }
        }
    }
    
    int getCurrentTree()
    {
        //don't change if current tree is fine
        if (yewPositions[currentTree] == treeStatus.GREEN)
        {
            return currentTree;
        }
        
        //find a green tree first
        int lowestDist = -1;
        for (int i = 0;i < yewTiles.length; i++)
        {
            if (yewPositions[i] == treeStatus.GREEN)
            {
                lowestDist = i;
            }
        }
        
        if (lowestDist != -1)
        {
            //use GREEN ones first
            for (int i = 0;i < yewTiles.length; i++)
            {
                if (yewPositions[i] == treeStatus.GREEN)
                {
                    if (calc.distanceTo(yewTiles[i]) < calc.distanceTo(yewTiles[lowestDist]))
                    {
                        lowestDist = i;
                    }
                }
            }
            
            return lowestDist;
        }
        
        //then check for highest timer.NO GREEN TREES SHOULD BE LEFT
        int highestTimer = 0;
        for (int i = 0;i < yewTiles.length; i++)
        {
            long time = System.currentTimeMillis() - treeTimer[i];
            long htime = System.currentTimeMillis() - treeTimer[highestTimer];
            if (time > htime)
            {
                highestTimer = i;
            }
        }
        
        return highestTimer;
    }
    
    public void messageReceived(MessageEvent e)
    {
		//Server messages only
		if (e.getID() != MessageEvent.MESSAGE_CHAT)
		{
	        String message = e.getMessage();
	        if (message.contains("do not have a hatchet"))
	        {
	            noHatchet = true;
	        }
	        
	        if (message.contains("some yew logs"))
	        {
	            logs++;
	        }
	        
	        if (message.contains("too full"))
	        {
	            if (inventory.getCount() == 0 && inventory.isFull() == false)
	            {
	                log("Rsbot is miscounting inventory, exiting");
	                kill = true;
	            }
	        }
		}
    }
}