import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.util.Vector;

import org.rsbot.event.listeners.PaintListener;
import org.rsbot.script.Script;
import org.rsbot.script.ScriptManifest;
import org.rsbot.script.methods.Skills;
import org.rsbot.script.wrappers.RSObject;
import org.rsbot.script.wrappers.RSTile;

/**
 * AIO fire maker that generates lanes at any spot so no need to be at a specific spot to run
 */
@ScriptManifest(authors = { "Battleguard" }, version = 0.01, keywords = { "AIO Firemaker 3" }, description = "AIO Firemaker 3, by Battleguard", name = "AIO firemaker 3")
public class firemaker3 extends Script implements PaintListener {

	// SCRIPT GOALS
	// -- NO GLOBAL VARIABLES
	// -- LOOK VERY SIMILAR TO RSBOTS SOURCE CODE METHODS
	//

	Vector<fireLane> allLanes = new Vector<fireLane>();
	Vector<fireLane> goodLanes = new Vector<fireLane>();
	fireLane bestLane = null;
	RSTile startLocation;
	boolean atLane = false;
	boolean newRow = true;
	public static final int TINDERBOX_ID = 590, WILLOW_ID = 1519;

	public boolean onStart() {
		log("Calculating all lanes please give it 30 seconds");
		startLocation = getMyPlayer().getLocation();
		allLanes = getAllLanes(45, 27, startLocation);
		allLanes = getAllGoodLanes(allLanes, startLocation);
		log("All " + allLanes.size() + " lanes have been calculated StartUp complete");
		return true;
	}

	@Override
	public int loop() {
		if (inventory.getCount(WILLOW_ID) > 0) {
			if (!atLane) {
				walkToFireSpot();
			} else {
				lightFires();
			}
		} else {
			bank();
		}

		return 50;
	}

	void bank() {
		log("banking");
		if (atBank()) {
			log("we are at bank");
			doBank();
		} else {
			log("we are not at bank");
			walking.walkTo(startLocation);
			sleep(1000);
		}
	}

	private final boolean atBank() {
		RSObject bank = objects.getNearest(11758);
		if (bank != null && bank.isOnScreen()) {

			return true;
		}
		return false;
	}

	private final void doBank() {
		if (bank.isOpen()) {
			bank.depositAllExcept(TINDERBOX_ID);
			bank.withdraw(WILLOW_ID, 0);
			sleep(800, 1200);
			bank.close();
			sleep(800, 1200);
			// SET STARTING VARIABLES FOR LIGHTING FIRES PART
			bestLane = null;
			atLane = false;
			newRow = true;
		} else {
			bank.open();
			sleep(1800, 2200);
		}
	}

	/**
	 * walk to starting position of fireLane
	 */
	void walkToFireSpot() {
		try {
			if (bestLane == null) {
				// CALCULATE BEST LANE
				Vector<fireLane> goodLanes = new Vector<fireLane>();
				goodLanes = noFiresOnTop(allLanes);
				bestLane = this.bestLane(goodLanes);
			} else {
				// WALK TO FIRELANE
				if (!players.getMyPlayer().getLocation().equals(bestLane.getStart())) {
					walking.walkTileOnScreen(bestLane.getStart());
					log("walking to tile");
					sleep(1000);
				} else {
					atLane = true;
					newRow = true;
				}
			}
		} catch (Exception e) {
			log("error walking to start location");
		}
	}

	private RSTile oldLoc;

	/**
	 * lights fires till out of logs
	 */
	private void lightFires() {
		log("lighting fires now");
		if (newRow) {
			oldXP = skills.getCurrentExp(Skills.FIREMAKING);
			timer = System.currentTimeMillis();
		}

		if ((inventory.contains(WILLOW_ID) && !getMyPlayer().getLocation().equals(oldLoc)) || newRow) {
			newRow = false;
			oldLoc = players.getMyPlayer().getLocation();
			if (!inventory.isItemSelected()) {
				inventory.getItem(WILLOW_ID).doClick(true);
				log("preClick");
				sleep(500);
			}
			int numOfLogs = inventory.getCount(WILLOW_ID);
			inventory.getItem(TINDERBOX_ID).doClick(true);
			while (numOfLogs == inventory.getCount(WILLOW_ID)) {
				sleep(50);
			}
			if (inventory.contains(WILLOW_ID)) {
				inventory.getItem(WILLOW_ID).doClick(true);
				mouse.move(inventory.getItem(TINDERBOX_ID).getPoint());
			}
			sleep(100);
		}
		checkXP();
	}

	// CHECK TO MAKE SURE THAT NOTHING HAS INTERUPTED LIGHTING FIRES
	// IF SOMETHING WRONG HAPPENS FIND A NEW LANE AND RESTART
	private int oldXP = 0;
	private long timer = 0;

	private void checkXP() {
		int currentXP = skills.getCurrentExp(Skills.FIREMAKING);
		if (currentXP != oldXP) {
			oldXP = currentXP;
			timer = System.currentTimeMillis();
			return;
		}
		if (currentXP == oldXP && (timer + 10000) < System.currentTimeMillis()) {
			bestLane = null;
			atLane = false;
			newRow = true;
		}
	}

	/**
	 * Makes a vector of all good RSTiles around person and returns vector
	 * @param rad radius of the square we will be making around centLoc
	 * @param laneSize size of lanes that we want to make
	 * @param centLoc location of the square
	 * @return Vector of all possible starting lane positions
	 */
	private Vector<fireLane> getAllLanes(int rad, int laneSize, RSTile centLoc) {
		Vector<fireLane> allPossibleLanes = new Vector<fireLane>();
		for (int y = -rad; y <= rad; y++) {
			for (int x = -rad + (laneSize - 1); x <= rad; x++)
				allPossibleLanes.add(new fireLane(new RSTile(centLoc.getX() + x, centLoc.getY() + y), laneSize));
		}
		return allPossibleLanes;
	}

	/**
	 * get all fire lanes that are reachable
	 * @param allLanes AllLanes that we need to check
	 * @param startT Tile that we are starting from
	 * @return all good fire lanes
	 */
	private Vector<fireLane> getAllGoodLanes(Vector<fireLane> lanes, RSTile startT) {
		Vector<fireLane> goodLanes = new Vector<fireLane>();
		for (int i = 0; i < lanes.size(); i++) {
			if (lanes.get(i).isLanePossible(startT))
				goodLanes.add(lanes.get(i));
		}
		return goodLanes;
	}

	/**
	 * gets all lanes that do not currently have a burning fire in them
	 * @param allLanes: all fire lanes to check for fires
	 * @returns all lanes that do not have fires on them
	 */
	private Vector<fireLane> noFiresOnTop(Vector<fireLane> lanes) {
		Vector<fireLane> goodLanes = new Vector<fireLane>();
		for (int i = 0; i < lanes.size(); i++) {
			if (lanes.get(i).noFires()) {
				goodLanes.add(lanes.get(i));
			}
		}
		return goodLanes;
	}

	/**
	 * gets the fire lane that has the closest walking distance
	 * @param lanes: lanes to check for closest distance
	 * @returns closest fire lane
	 */
	private fireLane bestLane(Vector<fireLane> lanes) {
		fireLane bestLane = null;
		double dist = 10000;
		for (int i = 0; i < lanes.size(); i++) {
			if (lanes.get(i).getDist() < dist) {
				bestLane = lanes.get(i);
				dist = bestLane.getDist();
			}
		}
		return bestLane;
	}

	/**
	 * fireLane class that stores all tiles in a fire lane and dist from starting location
	 */
	class fireLane {
		private Vector<RSTile> fireLaneTiles = new Vector<RSTile>();
		private double dist = 10000;

		/**
		 * Constructor that makes a fire lane
		 * @param startT: tile that a player would start lighting fires at
		 * @param laneSize: size of fire lane (typically 27)
		 */
		fireLane(RSTile startT, int laneSize) {
			for (int shift = 0; shift < laneSize; shift++) {
				fireLaneTiles.add(new RSTile(startT.getX() - shift, startT.getY()));
			}
		}

		/**
		 * Checks to see if lane has any objects on top of it and is of no father walking distance than 20 tiles
		 * @param curLoc: Location of player
		 * @returns true is goodLane false if badLane
		 */
		boolean isLanePossible(RSTile curLoc) {
			for (int i = 0; i < fireLaneTiles.size(); i++) {
				double tempDist = calc.pathLengthBetween(curLoc, fireLaneTiles.get(i), false);
				if (tempDist == -1) {
					return false;
				} else {
					if (tempDist < dist)
						dist = tempDist;
				}
			}
			if (dist > 20)
				return false;
			return true;
		}

		/**
		 * checks to see if the lane is currently clear of fires
		 * @returns true if no fires in lane
		 */
		boolean noFires() {
			try {
				for (int i = 0; i < fireLaneTiles.size(); i++) {
					if (objects.getTopAt(fireLaneTiles.get(i)) != null)
						return false;
				}
			} catch (Exception e) {
				log("error in doing objects.getTopAt");
				return false;
			}
			return true;
		}

		/**
		 * @returns start position of fireLane
		 */
		RSTile getStart() {
			return fireLaneTiles.get(0);
		}

		/**
		 * @returns distance to fireLane
		 */
		double getDist() {
			return dist;
		}
	}

	// DRAW TILE ON SCREEN
	public void drawTile(Graphics g, RSTile tile, Color color) {
		if (isTileOnScreen(tile)) {
			final Point pn = calc.tileToScreen(tile, 0, 0, 0);
			final Point px = calc.tileToScreen(new RSTile(tile.getX() + 1, tile.getY()), 0, 0, 0);
			final Point py = calc.tileToScreen(new RSTile(tile.getX(), tile.getY() + 1), 0, 0, 0);
			final Point pxy = calc.tileToScreen(new RSTile(tile.getX() + 1, tile.getY() + 1), 0, 0, 0);
			g.setColor(Color.black);
			g.drawPolygon(new int[] { py.x, pxy.x, px.x, pn.x }, new int[] { py.y, pxy.y, px.y, pn.y }, 4);
			g.setColor(color);
			g.fillPolygon(new int[] { py.x, pxy.x, px.x, pn.x }, new int[] { py.y, pxy.y, px.y, pn.y }, 4);
		}
	}

	// CHECKS TO SEE IF TILE IS ON SCREEN
	public boolean isTileOnScreen(RSTile tile) {
		return calc.pointOnScreen(new Point(calc.tileToScreen(tile)))
				&& calc.pointOnScreen(new Point(calc.tileToScreen(new RSTile(tile.getX() + 1, tile.getY()))))
				&& calc.pointOnScreen(new Point(calc.tileToScreen(new RSTile(tile.getX(), tile.getY() + 1))))
				&& calc.pointOnScreen(new Point(calc.tileToScreen(new RSTile(tile.getX() + 1, tile.getY() + 1))));
	}

	@Override
	public void onRepaint(Graphics g) {
		if (this.bestLane != null) {
			for (int i = 0; i < bestLane.fireLaneTiles.size(); i++) {
				this.drawTile(g, bestLane.fireLaneTiles.get(i), Color.BLUE);
			}

		}
	}
}