package com.kbot2.bot;

import com.kbot2.accessors.Client;
import com.kbot2.accessors.GameCanvas;
import com.kbot2.handlers.EventHandler;
import com.kbot2.handlers.ScriptHandler;
import com.kbot2.handlers.eventSystem.eventListeners.PaintListener;
import com.kbot2.handlers.eventSystem.eventListeners.ServerMessageListener;
import com.kbot2.handlers.eventSystem.eventListeners.TextPaintListener;
import com.kbot2.handlers.settings.BotConstants;
import com.kbot2.loader.Loader;
import com.kbot2.loader.StubGenerator;
import com.kbot2.out.Console;
import com.kbot2.scriptable.methods.Calculations;
import com.kbot2.scriptable.methods.Methods;
import static com.kbot2.scriptable.methods.Calculations.random;
import com.kbot2.bot.injector.Injector;

import java.applet.Applet;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.image.RasterFormatException;
import java.lang.reflect.Field;
import java.net.URL;
import java.io.File;

/**
 * Created by IntelliJ IDEA.
 * User: Jan Ove / Kosaki
 * Date: 12.mar.2009
 * Time: 18:36:38
 */
public class Bot extends Canvas implements Runnable, BotCallback {
	public final ThreadGroup botTG;
	public BotEnvironment botEnv;
	private Loader loader;
	private Thread loaderThread;
	private Thread paintThread;
	private StubGenerator stub;
	public final String botName;
	private final BufferedImage gameImage;
	public BufferedImage botImage;
	public final BufferedImage paintImage;
	private Client client; // The game's main class.
	private Applet clientApplet; // The game's applet which is the same as (Applet) client
	private ScriptHandler scriptHandler;
	private final EventHandler eventHandler;
	private InputListeners inputListeners;
	private boolean running = true;
	public String worldID;

	private Font helvetica = new Font("Helvetica", Font.BOLD, 13);
	private FontMetrics helveticaFontMetrics = getFontMetrics(helvetica);

	public boolean loading = true;
	public String loadingState = "Starting up bot";
	public int loadingPercentage = 5;
	private final String loadingStringTop = "KBot is loading - please wait...";

	public Bot(String botName) {
		final Bot self = this;
		worldID = getRandomWorld();
		setFocusable(true);
		// TODO  clean this up...
		botTG = new ThreadGroup("Bot[" + botName + "]");
		this.botName = botName;

		gameImage = new BufferedImage(765, 503, BufferedImage.TYPE_INT_RGB);
		botImage = new BufferedImage(765, 503, BufferedImage.TYPE_INT_RGB);
		paintImage = new BufferedImage(765, 503, BufferedImage.TYPE_INT_RGB);
		updateLoadingScreen();
		new Thread(new Runnable() {
			public void run() {
				Injector injector = new Injector(self);  
				File runescapeJar = injector.run();
				System.gc();
				if(runescapeJar == null)
					return;
				loadingState = "Starting loader";
				updateLoadingScreen();

				loader = new Loader(runescapeJar);
				stub = new StubGenerator(loader, worldID);
				loader.setStub(stub);
				loader.setCallBack(new Runnable() {
					public void run() {
						clientApplet = loader.getApplet();
						client = (Client) clientApplet;
						inputListeners = new InputListeners(true, client);
						addMouseListener(inputListeners);
						addMouseMotionListener(inputListeners);
						addMouseWheelListener(inputListeners);
						addKeyListener(inputListeners);
						addFocusListener(inputListeners);
						if (!hasFocus())
							requestFocus();
					}
				});
				loaderThread = new Thread(botTG, loader, "loader");
				loaderThread.start();
				loadingState = "Started game engine!";
				loadingPercentage = 100;
				updateLoadingScreen();
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {

				}
				loading = false;
			}
		}).start();		
		paintThread = new Thread(botTG, this, "paint");
		paintThread.start();

		eventHandler = new EventHandler(this);
		botEnv = new BotEnvironment(this);
		botEnv.setCPUSaving(false);
		botEnv.setCPUWait(BotConstants.saveCPUwait);
		scriptHandler = new ScriptHandler(this);

		Console.writeLine(this, "Bot[" + botName + "] started.");

	}

	private String getRandomWorld() {
		String world = BotConstants.worlds.get(random(0, BotConstants.worlds.size() - 1));
		Console.writeLine(this, "Document base is world "+world);
		return world;
	}

	public void updateLoadingScreen() {
		Graphics g = botImage.getGraphics();
		try {
			//g.drawImage(Toolkit.getDefaultToolkit().getImage(new URL("http://i29.tinypic.com/14c4sns.jpg")), 0, 0, Color.black, this);
			g.drawImage(Toolkit.getDefaultToolkit().getImage("images/YOURNAME.png"), 0, 0, Color.black, this);
		} catch (Exception e) {
		}
		g.setColor(Color.green);
		g.drawRect(230, 234, 302, 31);
		g.fillRect(232, 236, (int) (((double) loadingPercentage / 100D) * 299), 28);

		g.setFont(helvetica);
		g.setColor(Color.white);
		g.drawString(loadingStringTop, 382 - helveticaFontMetrics.stringWidth(loadingStringTop) / 2, 225);
		g.drawString(loadingState, (304 - helveticaFontMetrics.stringWidth(loadingState)) / 2 + 230, 255);
	}

	private boolean paintThreadRunning = true;

	public void run() {
		while (paintThreadRunning) {
			if (this.isShowing()) {
				try {
					repaint();
					Thread.sleep(1000 / BotConstants.paintFPS);
				} catch (InterruptedException ignored) {
				}
			} else {
				try {
					Thread.sleep(300);
				} catch (InterruptedException ignored) {
				}
			}
		}
	}

	public Calculations getCalculations() {
		return botEnv.calculations;
	}


	@Override
	public void paint(Graphics g) {
		//this.setEnabled(false);
		try {
			if (!this.isVisible())
				return;

			Rectangle r = g.getClipBounds();
			if (loading) {
				g.drawImage(botImage, r.x, r.y, r.x + r.width, r.y + r.height,
						r.x, r.y, r.x + r.width, r.y + r.height, null);
				return;
			}

			if (botImage != null) {
				paintImage.flush();

				Graphics paintGraphics = paintImage.getGraphics();
				paintGraphics.drawImage(botImage, r.x, r.y, r.x + r.width, r.y + r.height,
						r.x, r.y, r.x + r.width, r.y + r.height, null);
				final PaintListener paintListeners = eventHandler.getPaintListeners();
				if (paintListeners != null)
					paintListeners.onRepaint(paintGraphics);
				final TextPaintListener textPaintListeners = eventHandler.getTextPaintListeners();
				if (textPaintListeners != null) {
					int y = 40;
					paintGraphics.setColor(Color.cyan);
					String[] lines = textPaintListeners.onTextRepaint();
					if (lines != null) {
						for (String line : lines) {
							if (line == null)
								continue;
							paintGraphics.drawString(line, 20, y);
							y += 20;
						}
					}
				}
				if (client != null) {
					paintGraphics.setColor(Color.white);
					int x = client.getMouseX();
					int y = client.getMouseY();
					paintGraphics.drawLine(x - 5, y - 5, x + 5, y + 5);
					paintGraphics.drawLine(x - 5, y + 5, x + 5, y - 5);
					x = client.getMousePressedX();
					y = client.getMousePressedY();
					paintGraphics.setColor(Color.red);
					paintGraphics.drawLine(x - 5, y - 5, x + 5, y + 5);
					paintGraphics.drawLine(x - 5, y + 5, x + 5, y - 5);
				} else {
					paintGraphics.drawString("Client is null", 30, 40);
				}
				g.drawImage(paintImage, r.x, r.y, r.x + r.width, r.y + r.height,
						r.x, r.y, r.x + r.width, r.y + r.height, null);
				paintGraphics.dispose();
			}
		}
		catch (RasterFormatException ignored) {
		}
		//this.setEnabled(true);
	}

	public void close() {
		running = false;
		paintThreadRunning = false;
		scriptHandler.stopAllScripts();
		scriptHandler.stop();
		botEnv.notifyOnClose();
		loader.destroyLoader();
		Class c = client.getClass();
		for (Field f : c.getFields()) {
			f.setAccessible(true);
			if (!f.getType().isPrimitive()) {
				try {
					f.set(client, null);
				} catch (IllegalAccessException ignored) {

				}
			}
		}
		client = null;
		clientApplet = null;
		inputListeners.client = null;
		inputListeners = null;
		stub.close();
		stub = null;
		scriptHandler = null;
		botEnv = null;
		paintThread = null;
		loaderThread = null;
		System.gc();
	}

	@Override
	public void repaint(int x, int y, int width, int height) {
		super.repaint(0, 0, 765, 503);
	}

	@Override
	public void repaint(long tm, int x, int y, int width, int height) {
		super.repaint(tm, 0, 0, 765, 503);
	}

	@Override
	public void paintAll(Graphics g) {
		paint(g);
	}

	@Override
	public void update(Graphics g) {
		paint(g);
	}

	public BotCallback getBotCallback(GameCanvas gameCanvas) {
		if (!running)
			return null;
		final Applet applet = loader.getApplet();
		final Canvas canvas = ((Client) applet).getCanvas();
		if (canvas == null)
			return null;
		if (gameCanvas == canvas) {
			// Found our graphics
			return this;
		}
		return null;
	}

	public Loader getLoader() {
		return loader;
	}

	public boolean isInputEnabled() {
		return inputListeners == null || inputListeners.isInputEnabled();
	}

	public void setInputEnabled(boolean inputEnabled) {
		inputListeners.setInputeEnabled(inputEnabled);
	}

	public ScriptHandler getScriptHandler() {
		return scriptHandler;
	}


	public Client getClient() {
		return client;
	}

	public EventHandler getEventHandler() {
		return eventHandler;
	}

	public Graphics gamePaint() {
		if (!loading) {
			botImage.flush();
			botImage = gameImage.getSubimage(0, 0, 765, 503);

		}
		gameImage.flush();
		return gameImage.getGraphics();
	}

	public boolean useCPUWait() {
		return botEnv.isCPUSavingOn();
	}

	public int getCPUWait() {
		return botEnv.getCPUWait();
	}

	public void onServerMessage(String message) {
		final ServerMessageListener listeners = eventHandler.getServerMessageListeners();
		if (listeners != null) {
			listeners.onServerMessage(message);
		}
	}

	public Methods getMethods() {
		return botEnv.methods;
	}

	public boolean getInputEnabled() {
		if (inputListeners == null)
			return true;
		return inputListeners.isInputEnabled();
	}
}