import java.awt.Canvas;
import java.awt.Graphics2D;
import java.awt.BasicStroke;
import java.awt.Dimension;
import java.awt.BorderLayout;
import java.awt.GridLayout;

import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseWheelEvent;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import java.awt.image.BufferStrategy;

import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
import java.awt.geom.NoninvertibleTransformException;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;

import java.io.FileReader;
import java.io.BufferedReader;
import java.io.IOException;

// TODO: remove unused import
import com.google.gson.Gson;


public class MapScene extends Scene implements ActionListener {
	protected Map map;
	protected int panX = 0;
	protected int panY = 0;
	protected boolean panning = false;
	protected double zoom = 1;
	protected int mouseX;
	protected int mouseY;
	protected boolean zooming = false;
	protected int maxSize;
	protected AffineTransform tx = new AffineTransform();

	public MapScene(JFrame frame, Sub sub) {
		super(frame, sub);

		//this.map = new Map(new Dimension(10, 10));
	}

	@Override
	protected void render() {
		if (this.WIDTH < this.HEIGHT) {
			this.maxSize = WIDTH;
		} else {
			this.maxSize = HEIGHT;
		}

		// TODO: negate if condition and return
		if (this.map != null) {
		Graphics2D g = (Graphics2D) this.buffer.getDrawGraphics();
		//clear
		g.setColor(Palette.BLACK);
		g.fillRect(0, 0, this.WIDTH, this.HEIGHT);

		//zoom and pan
		if (this.zooming) {
			Point2D p1 = new Point2D.Double(this.mouseX, this.mouseY);
			Point2D p2 = null;
			try {
				p2 = tx.inverseTransform(p1, null);	
			} catch (NoninvertibleTransformException ex) {}
			this.tx.setToIdentity();
			this.tx.translate(p1.getX(), p1.getY());
			this.tx.scale(this.zoom, this.zoom);
			this.tx.translate(-p2.getX(), -p2.getY());
			this.zooming = false;
		}
		if (this.panning) {
			this.tx.translate(this.panX/this.zoom, this.panY/this.zoom);
			this.panning = false;
			this.panX = 0;
			this.panY = 0;
		}
		
		g.transform(this.tx);

		//draw tiles
		int tileSize = this.maxSize / 10;
		for (Tile tile : this.map.getGrid()) {
			switch (tile.getType()) {
				case CLEAR:
					continue;
				case GRASS:
					g.setColor(Palette.GREEN);
					break;
				case WATER:
					g.setColor(Palette.BLUE);
					break;
				case MOUNTAIN:
					g.setColor(Palette.BROWN);
					break;
			}

			g.fillRect(
					tileSize * tile.getX(), tileSize * tile.getY(),
					tileSize, tileSize);

			if (tile.isSelected()) {
				g.setColor(Palette.ORANGE_T);
				//g.fillRect(tileSize * tile.getX() + tileSize/4, tileSize * tile.getY() + tileSize/4,
				//		tileSize/2, tileSize/2);
				g.fillRect(
						tileSize * tile.getX(), tileSize * tile.getY(),
						tileSize, tileSize);
			}

			//TODO: set as class variables the storkes
			if (tile.cursorOnIt()) {
				BasicStroke oldStroke = (BasicStroke) g.getStroke();
				g.setStroke(new BasicStroke(
							10.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_BEVEL
							));
				g.setColor(Palette.ORANGE);
				g.drawRect(
						tileSize * tile.getX(), tileSize * tile.getY(),
						tileSize, tileSize);
				g.setStroke(oldStroke);
			}
			

			g.setPaint(Palette.BLACK);
			g.drawRect(
					tileSize * tile.getX(), tileSize * tile.getY(),
					tileSize, tileSize);
		}

		g.setColor(Palette.ORANGE);
		int maxBound = this.map.getSize()*tileSize;
		g.drawRect(0, 0, maxBound, maxBound);
		
		//draw actors
		g.setFont(g.getFont().deriveFont(g.getFont().getSize()*2.0F));
		for (Actor actor: this.map.getActors()) {
			if (actor.isEnemy()) {
				g.setColor(Palette.RED);
			} else {
				g.setColor(Palette.BLUE);
			}
			g.fillRect(tileSize * actor.getX() + tileSize/5, tileSize * actor.getY() + tileSize/5,
					3*tileSize/5, 3*tileSize/5);
			g.setColor(Palette.BLACK);
			g.drawString(actor.getName(), tileSize*actor.getX() + tileSize/5, tileSize*actor.getY()-tileSize/20);
			g.setColor(Palette.RED);
			g.fillRect(tileSize*actor.getX() + tileSize/5, tileSize*actor.getY()-tileSize/20+tileSize/30,
					(tileSize*4/5), tileSize/10);
			g.setColor(Palette.DARKGREEN);
			g.fillRect(tileSize*actor.getX() + tileSize/5, tileSize*actor.getY()-tileSize/20+tileSize/30,
					(tileSize*4/5)*actor.getHP()/10, tileSize/10);
		}

		// Restore absolute coordinates
		AffineTransform invertTx = null;
		try {
			invertTx = this.tx.createInverse();
		} catch (NoninvertibleTransformException ex) {}

		g.transform(invertTx);
		this.absoluteRender(g);

		g.dispose();
		this.buffer.show();
		}
	}

	// TODO: make abstract
	protected void absoluteRender(Graphics2D g) {

	}

	// TODO: remove this overridden method and leave abstract
	@Override
	protected void update(int deltaTime) {
	}

	@Override
	public void keyPressed(KeyEvent e) {
		int keyCode = e.getKeyCode();
		switch (keyCode) {
			case KeyEvent.VK_UP:
				this.panY += 10;
				break;
			case KeyEvent.VK_DOWN:
				this.panY -= 10;
				break;
			case KeyEvent.VK_LEFT:
				this.panX += 10;
				break;
			case KeyEvent.VK_RIGHT:
				this.panX -= 10;
				break;
		}
	}
	
	@Override
	public void mousePressed(MouseEvent e) {
		this.mouseX = e.getX();
		this.mouseY = e.getY();
	}

	@Override
	public void mouseClicked(MouseEvent e) {
	}

	@Override
	public void mouseDragged(MouseEvent e) {
		int x = e.getX();
		int y = e.getY();
		this.panX += x - this.mouseX;
		this.panY += y - this.mouseY;	
		this.mouseX = x;
		this.mouseY = y;
		this.panning = true;
	}

	@Override
	public void mouseMoved(MouseEvent e) {
	}

	@Override
	public void mouseWheelMoved(MouseWheelEvent e) {
		this.mouseX = e.getX();
		this.mouseY = e.getY();
		if (this.zoom > 0.3 || e.getWheelRotation() < 0) {
			this.zoom -= ((double) e.getWheelRotation())/5;
		}
		this.zooming = true;
	}

	@Override
	public void actionPerformed(ActionEvent e) {}
}