package wFramework;

import java.util.Vector;

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.location.Criteria;
import javax.microedition.location.Location;
import javax.microedition.location.LocationException;
import javax.microedition.location.LocationListener;
import javax.microedition.location.LocationProvider;
import javax.microedition.location.QualifiedCoordinates;

import org.kxml2.io.KXmlParser;

public class Map extends Canvas implements LocationListener, ProviderStatusListener, TimerListener, QueryListener
{
	private int x, y;
	private int tilex, tiley;
	private int userx, usery;
	
	private int maxtiles = 100;
	
	private TimerHit timer;
	private boolean donePending;

	private int tilesize;
	private int tilesize_real[];
	private int zoomlevel = 0;
	private int maxzoom;
	private int mapid;
	private int maxWest, maxEast, maxNorth, maxSouth;
	
	private MapListener listener;
	private Vector keyListeners;
	
	private int dxWorld, dyWorld;
	private int dxViewport, dyViewport;
	private int cxViewport, cyViewport;
	
	private int cursorStep = 10;
	private MapOverlay cursorSelected;
	private Point cursorPos;
	private Image cursor;
	private boolean cursorEnabled;

	private LocationProvider locationProvider;
	private int locationProviderStatus;
	private int locationProviderMethod;
	private Image lpOnline, lpOffline, lpWait;
	
	private String gpslog;
	private boolean gpsdebug = false;
	
	private Vector tiles;
	private Vector overlays;
	private wFramework wf;
			
	Map(String mapname, int x, int y, wFramework wf)
	{
		timer = new TimerHit(this, 25);
		donePending = true;

		gpslog = "";
		this.setFullScreenMode(true);
		this.locationProviderStatus = LocationProvider.OUT_OF_SERVICE;
		cursorEnabled = true;
		
		try
		{
			cursor = Image.createImage("/wFramework/images/cursor.png");
			lpOnline = Image.createImage("/wFramework/images/gpsonline.png");
			lpOffline = Image.createImage("/wFramework/images/gpsoffline.png");
			lpWait = Image.createImage("/wFramework/images/gpswait.png");
		}
		catch (Exception e)
		{
			System.out.println("Failed to load images");
		}
		
		this.keyListeners = new Vector();
		this.listener = null;
		this.x = x;
		this.y = y;
		userx = x;
		usery = y;
		this.cxViewport = getWidth();
		this.cyViewport = getHeight();
		
		cursorPos = new Point(cxViewport / 2, cyViewport / 2);
		cursorSelected = null;
		
		tiles = new Vector();
		overlays = new Vector();
		this.wf = wf;
		
		ResultSet rs = wf.executeQuery("SELECT * FROM public.map WHERE name='"+mapname+"';");
		if (rs.next())
		{
			mapid = rs.getInt("id");
			maxWest = rs.getInt("max_west");
			maxEast = rs.getInt("max_east");
			maxNorth = rs.getInt("max_north");
			maxSouth = rs.getInt("max_south");
			maxzoom = rs.getInt("zoomlevels");
			tilesize = rs.getInt("tilesize_pixels");
			
			tilesize_real = new int[maxzoom];	
			int z = 0;
			int s = 0;
			String real = rs.getString("tilesize_meters");
			for (int i = 0; i < real.length(); i++)
			{
				if (real.charAt(i) == ',')
				{
					tilesize_real[z++] = Integer.parseInt(real.substring(s, i));
					s = i + 1;
				}
				else if (i == real.length() - 1)
					tilesize_real[z++] = Integer.parseInt(real.substring(s));					
			}
		}
		
		this.setPosition(x, y);
		
		/*
		 * Set-up Location Provider
		 */		
		if (ConfigProvider.isLocationApiSupported())
			ConfigProvider.getInstance().autoSearch(this);

		rs.close();
		updateTiles();
	}
	
	public void resetOverlays()
	{
		overlays.removeAllElements();
	}
	
	public void removeOverlay(MapOverlay overlay)
	{
		overlays.removeElement(overlay);
		repaint();
	}
	
	public void addOverlay(MapOverlay overlay)
	{
		overlays.addElement(overlay);
		repaint();
	}
	
	public void setListener(MapListener listener)
	{
		this.listener = listener;
	}
	
	public void addKeyListener(MapInputListener listener)
	{
		this.keyListeners.addElement(listener);
	}
	
	public void removeKeyListener(MapInputListener listener)
	{
		this.keyListeners.removeElement(listener);
	}
	
	public void paint(Graphics g)
	{
		g.setColor(0xffffff);
		g.fillRect(0, 0, getWidth(), getHeight());
	
		for (int i = 0; i < tiles.size(); i++)
		{
			MapTile mt = (MapTile)tiles.elementAt(i);
			if (mt.isVisible())
				mt.paint(g, dxViewport + tilesize * (mt.getX() - tilex), dyViewport +  tilesize * (mt.getY() - tiley));
		}

		for (int i = 0; i < overlays.size(); i++)
			((MapOverlay)overlays.elementAt(i)).paint(g);

		int y = 2;
		g.setColor(0x0);
		if (this.locationProviderStatus == LocationProvider.AVAILABLE)
			g.drawImage(lpOnline, getWidth() - 2, y, Graphics.RIGHT | Graphics.TOP);
		else if (this.locationProviderStatus == LocationProvider.TEMPORARILY_UNAVAILABLE)
			g.drawImage(lpWait, getWidth() - 2, y, Graphics.RIGHT | Graphics.TOP);
		else if (this.locationProviderStatus == LocationProvider.OUT_OF_SERVICE)
			g.drawImage(lpOffline, getWidth() - 2, y, Graphics.RIGHT | Graphics.TOP);
		
		// draw zoom state and draw cursor
		if (cursorEnabled)
		{
			int yzoom = (int)(((float)this.zoomlevel / (float)this.maxzoom) * 50.0f);
			g.setColor(0x000000);
			g.fillRect(2, 2, 6, 53);
			g.setColor(0xC0C0C0);
			g.fillRect(3, yzoom + 3, 4, 8);
			
			g.drawImage(cursor, cursorPos.x - 3, cursorPos.y - 3, Graphics.TOP | Graphics.LEFT);
		}
		
		if (XMLConnection.numPending > 0)
		{
			y = getHeight() - 10;
			// draw progressbar
			int xdone = (int)((1.0f / (float)(XMLConnection.numPending + 1)) * 150.0f);
			g.setColor(0x000000);
			g.fillRect(getWidth() / 2 - 75, y, 152, 8);
			g.setColor(0xC0C0C0);
			g.fillRect(getWidth() / 2 - 74, y + 1, xdone, 6);
		}

		if (gpsdebug)
		{			
			g.setColor(0x00);
			
			y = 2;
			int i = gpslog.length();
			int e = gpslog.length();
			while (i > 0)
			{
				for (int q = i - 1; q >= 0; q--)
				{
					if (gpslog.charAt(q) == '\n' || q == 0)
					{
						i = q;
						break;
					}
				}
				g.drawSubstring(gpslog, i, e - i, 10, y, Graphics.LEFT | Graphics.TOP);
				y += g.getFont().getHeight();
				e = i;
			}
		}
	}
	
	private void computeVisibility()
	{
		for (int i = 0; i < tiles.size(); i++)
		{
			MapTile mt = (MapTile)tiles.elementAt(i);
			mt.setVisibility(false);			
			if (mt.getZoom() == zoomlevel)
			{			
				int x = dxViewport + tilesize * (mt.getX() - tilex);
				int y = dyViewport + tilesize * (mt.getY() - tiley);

				if (x >= -tilesize && x <= cxViewport && y >= -tilesize && y <= cyViewport)
					mt.setVisibility(true);
			}
		}
	}
	
	public void hitTimer() 
	{
		if (XMLConnection.numPending > 0 || (!donePending && XMLConnection.numPending == 0))
		{
			this.repaint();
			if (XMLConnection.numPending > 0)
				donePending = false;
			else
				donePending = true;
		}
	}

	private MapTile getOldMapTile()
	{
		MapTile old = null;
		for (int i = 0; i < tiles.size(); i++)
		{
			MapTile mt = (MapTile)tiles.elementAt(i);
			if (mt.getZoom() != zoomlevel && mt.getRR() >= 0)
			{
				if (old == null)
					old = mt;
				else if (mt.getRR() < old.getRR())
					old = mt;
			}
		}
		if (old == null)
		{
			for (int i = 0; i < tiles.size(); i++)
			{
				MapTile mt = (MapTile)tiles.elementAt(i);
				if (!mt.isVisible() && mt.getRR() >= 0)
				{
					if (old == null)
						old = mt;
					else if (mt.getRR() < old.getRR())
						old = mt;
				}
			}
		}
		return old;
	}
	
	private MapTile addMapTile(int filehandle, int x, int y, int zoomlevel)
	{
		if (checkFilehandle(filehandle))
			return null;
		
		MapTile mt = null;
		if (tiles.size() < maxtiles)
		{
			mt = new MapTile(this, filehandle, x, y, zoomlevel, wf);
			tiles.addElement(mt);
		}
		else
		{
			mt = getOldMapTile();
			if (mt != null)
				mt.setParams(filehandle, x, y, zoomlevel);
		}
		return mt;
	}
	
	private boolean checkMapTile(int x, int y, int zoomlevel)
	{
		for (int i = 0; i < tiles.size(); i++)
		{
			MapTile mt = (MapTile)tiles.elementAt(i);
			if (mt.getX() == x && mt.getY() == y && mt.getZoom() == zoomlevel && mt.getImage() != null)
				return true;
		}
		return false;
	}

	private boolean checkFilehandle(int filehandle)
	{
		for (int i = 0; i < tiles.size(); i++)
		{
			MapTile mt = (MapTile)tiles.elementAt(i);
			if (mt.getFilehandle() == filehandle)
				return true;
		}
		return false;
	}
	
	private boolean checkCurrentTiles()
	{
		int fromx = tilex - 1;
		int fromy = tiley - 1;
		int tox = tilex + 2;
		int toy = tiley + 2;
		
		boolean mismatch = false;		
		for (int x = fromx; x <= tox; x++)
		{
			for (int y = fromy; y <= toy; y++)
			{
				if (!checkMapTile(x, y, this.zoomlevel))
				{
					mismatch = true;
					break;
				}
			}
			if (mismatch)
				break;
		}
		
		return (!mismatch);
	}
	
	private void updateTiles()
	{
		// first check to see if all tiles are in the cache..
		int fromx = tilex - 1;
		int fromy = tiley - 1;
		int tox = tilex + 2;
		int toy = tiley + 2;
		
		String screenTest = "(x >= " + fromx + " AND x <= " + tox;
		screenTest += " AND y >= " + fromy + " AND y <= " + toy + ")";		
		wf.executeQueryAsync("SELECT x, y, filehandle FROM public.maptiles WHERE mapid="+this.mapid+" AND zoomlevel="+(this.zoomlevel + 1)+" AND " + screenTest + ";", this);
	}

	public void setZoom(int z)
	{
		int newzoomlevel = Math.max(Math.min(z, maxzoom - 1), 0);
		if (newzoomlevel != zoomlevel)
		{
			if (newzoomlevel < zoomlevel)
			{
				zoomlevel = newzoomlevel;
				updateViewport();
				Point cursorWorld = pixelToWorld(cursorPos);
				setPosition(cursorWorld.x, cursorWorld.y);
			}
			else
			{
				zoomlevel = newzoomlevel;
				updateViewport();
			}
		}
	}
	
	public void move(int dx, int dy)
	{
		setPosition(x + dx, y + dy);
	}
	
	public int getX()
	{
		return x;
	}
	
	public int getY()
	{
		return y;
	}
	
	private void updateViewport()
	{
		dxWorld = x - maxWest;
		dyWorld = (maxNorth - maxSouth) - (y - maxSouth);
		float dx = (float)dxWorld / (float)tilesize_real[zoomlevel];
		float dy = (float)dyWorld / (float)tilesize_real[zoomlevel];
		tilex = (int)dx;
		tiley = (int)dy;
		// using fractions..
		dxViewport = tilesize - (int)((dx - (float)tilex) * (float)tilesize);
		dyViewport = tilesize - (int)((dy - (float)tiley) * (float)tilesize);
		
		if (!checkCurrentTiles())
			updateTiles();

		computeVisibility();
		repaint();
	}
	
	public void sizeChanged(int width, int height)
	{
		this.cxViewport = width;
		this.cyViewport = height;
		updateViewport();
	}
	
	private boolean sameSign(int i0, int i1)
	{
		if (i0 <= 0 && i1 <= 0)
			return true;
		else if (i0 >= 0 && i1 >= 0)
			return true;
		else
			return false;
		
	}
	
	public void moveCursor(int dx, int dy)
	{
		if (!cursorEnabled) return;
		
		Point old = new Point(cursorPos.x, cursorPos.y);
		Point cursorWorld = this.pixelToWorld(new Point(cursorPos.x + (dx / 2), cursorPos.y + (dy / 2)));
		
		// check to see if there are any overlays in this direction...
		// computes the closest matching using half the step size