import Cartographer from './cartographer.js';

import {sqrt3, extend} from './utils.js';

import Hex from './hex.js';
import Point from './point.js';

export default class CartographerXYZ extends Cartographer {
	constructor(settings) {
		super(settings);

		[
			'maxWidth',
			'minWidth',

			'maxDistance',
			'minDistance',

			'getCellWidth',
			'getCellHeight',

			'getHorzDistance',
			'getVertDistance',

			'tileToPixel',
			'pixelToTile',
			'boundingBox',
		].map(method => this[method] = this[method].bind(this));

		this.pointyTop = settings.pointyTop;

		// in pixels
		this.originX = 0;
		this.originY = 0;

		// in pixels
		this.scale = 25;
		this.scaleMin = 10;
		this.scaleMax = 250;

		// in cells
		this.width = 0;
		this.height = 0;

		extend(this, settings);

		this.originX = parseInt(this.originX);
		this.originY = parseInt(this.originY);

		this.width = parseInt(this.width);
		this.height = parseInt(this.height);
	}

	maxWidth() {
		return this.scale * 2;
	}

	minWidth() {
		return this.maxWidth() * sqrt3;
	}

	maxDistance() {
		return this.maxWidth() * (3/4);
	}

	minDistance() {
		return this.minWidth();
	}

	getCellWidth() {return this.pointyTop ? this.minWidth() : this.maxWidth();}
	getCellHeight() {return this.pointyTop ? this.maxWidth() : this.minWidth();}

	getHorzDistance() {return this.pointyTop ? this.minDistance() : this.maxDistance();}
	getVertDistance() {return this.pointyTop ? this.maxDistance() : this.minDistance();}

	tileToPixel(hex) {
		let scale = this.scale;

		function minWidth(a, b) {
			return scale * sqrt3 * (a + (b / 2))
		};

		function maxWidth(a) {
			return scale * 3/2 * a
		};

		let pixelX = this.pointyTop ? minWidth(hex.getQ(), hex.getR()) : maxWidth(hex.getQ());
		let pixelY = this.pointyTop ? maxWidth(hex.getR()) : minWidth(hex.getR(), hex.getQ());

		pixelX += this.originX;
		pixelY += this.originY;

		return new Point(pixelX, pixelY);
	}

	pixelToTile(point) {
		let scale = this.scale;

		function radiusLong(a, b) {
			return ((a * (sqrt3 / 3)) - (b / 3)) / scale;
		};

		function radiusShort(a) {
			return (a * (2 / 3)) / scale;
		};

		let pixelX = point.getX() - this.originX;
		let pixelY = point.getY() - this.originY;

		let q = this.pointyTop ? radiusLong(pixelX, pixelY) : radiusShort(pixelX);
		let r = this.pointyTop ? radiusShort(pixelY) : radiusLong(pixelY, pixelX);

		return new Hex(q, r);
	}

	boundingBox(upperLeftPoint, lowerRightPoint) {
		let hexagons = [];
		let upperRightPoint = new Point(lowerRightPoint.getX(), upperLeftPoint.getY());

		// push out by a 1 axially to account for interlocking hexagons
		// possibly return hexagons not within bounds
		let upperLeftTile = this.pixelToTile(upperLeftPoint).moveAxial({q: 0, r: -1});
		let lowerRightTile = this.pixelToTile(lowerRightPoint).moveAxial({q: 0, r: 1});
		let upperRightTile = this.pixelToTile(upperRightPoint).moveAxial({q: 1, r: -1});

		let height = lowerRightTile.getR() - upperRightTile.getR();
		let width = upperRightTile.getQ() - upperLeftTile.getQ();

		if (this.pointyTop) {
			for (let row = 0; row <= height; row++) {
				hexagons[row] = [];
				let r = upperLeftTile.getR() + row;
				let qOffset = upperLeftTile.getQ() - Math.floor(row / 2);

				for (let q = qOffset; q <= qOffset + width; q++) {
					hexagons[row].push(new Hex(q, r));
				}
			}
		}
		else {
			for (let col = 0; col <= width; col++) {
				hexagons[col] = [];
				let q = upperLeftTile.getQ() + col;
				let rOffset = upperLeftTile.getR() - Math.floor(col / 2);

				for (let r = rOffset; r <= rOffset + height; r++) {
					hexagons[col].push(new Hex(q, r));
				}
			}
		}

		return hexagons;
	}
}

//	function getCoordinates(canvasX, canvasY) {
//		var hexWidth = sqrt3 * scale;
//		var graphY = Math.round((originY + (scale/2) - canvasY) / (1.5*scale));
//		var mapY =  height ? graphY % height : graphY;
//		mapY = mapY < 0 ? mapY + height : mapY;
//		var graphX = Math.round(((canvasX - originX) / hexWidth) - (graphY/2));
//		var mapX = width ? graphX % width : graphX;
//		mapX = mapX < 0 ? (width + mapX) : mapX;
//		var mapZ = -(mapX + mapY);
//
//		return {x:mapX, y:mapY, z:mapZ}
//	}
//
//	var ExWhyZee = {
//		boundingBox: function(upperLeftPoint, lowerRightPoint, contained) {
//			var hexagons = [];
//			var upperRightPoint = Point(lowerRightPoint.getX(), upperLeftPoint.getY());
//
//			// push out by a 1 axially to account for interlocking hexagons
//			// possibly return hexagons not within bounds
//			var upperLeftHex = this.pixelToHex(upperLeftPoint).moveAxial({q: 0, r: -1});
//			var lowerRightHex = this.pixelToHex(lowerRightPoint).moveAxial({q: 0, r: 1});
//			var upperRightHex = this.pixelToHex(upperRightPoint).moveAxial({q: 1, r: -1});
//
//			var height = lowerRightHex.getR() - upperLeftHex.getR();
//			var width = upperRightHex.getQ() - upperLeftHex.getQ();
//
//			for (var row = 0; row <= height; row++) {
//				hexagons[row] = [];
//				var r = upperLeftHex.getR() + row;
//				var qOffset = upperLeftHex.getQ() - Math.floor(row / 2);
//
//				for (var q = qOffset; q <= qOffset + width; q++) {
//					hexagons[row].push(Hex(q, r));
//				}
//			}
//
//			return hexagons;
//		},
//
//		cellDistance: function(hex1, hex2) {
//			return Math.max(
//				Math.abs(hex1.getX() - hex2.getX()),
//				Math.abs(hex1.getY() - hex2.getY()),
//				Math.abs(hex1.getZ() - hex2.getZ())
//			);
//		},
//
//		setNeighbors: function(distance) {
//			if (!neighbors[distance - 1]) {
//				var length = 6 * distance;
//				for (var i=0; i<distance; i++) {
//					// each of the six directions
//					neighbors[(0 * distance) + i] = Hex(      distance, (i - distance),             -i);
//					neighbors[(2 * distance) + i] = Hex((distance - i),              i,             -i);
//					neighbors[(3 * distance) + i] = Hex(            -i,       distance, (i - distance));
//					neighbors[(4 * distance) + i] = Hex(     -distance, (distance - i),              i);
//					neighbors[(5 * distance) + i] = Hex((i - distance),             -i,       distance);
//					neighbors[(6 * distance) + i] = Hex(             i,      -distance, (distance - i));
//				}
//			}
//		},
//
//		getNeighborRing: function(hex, distance) {
//			if (!neighbors[distance]) {
//				ExWhyZee.setNeighbors(distance);
//			}
//
//			return _.map(neighbors[distance], function(neighbor) {
//				return Hex(hex.getQ() + neighbor.getQ(), hex.getR() + neighbor.getR());
//			});
//		},
//
//		getNeighbors: function getNeighbors(hex, distance) {
//			if (distance) {
//				return ExWhyZee.getNeighborRing().concat(getNeighbors(hex, distance - 1));
//			}
//		},
//
//// 		getNeighbors: function(x,y, distance) {
//// 			var neighbors = [];
////
//// 			for (var curX=x-distance; curX<=x+distance; curX++) {
//// 				for (var curY=y-distance; curY<=y+distance; curY++) {
////
//// 					if (cellDistance(x,y, curX,curY) <= distance) {
//// 						if ((curX !== x) || (curY !== y)) {
//// 							var tempX = curX < 0 ? curX + map.width : curX;
//// 							tempX = tempX >= map.width ? tempX - map.width : tempX;
//// 							var tempY = curY < 0 ? curY + map.height : curY;
//// 							tempY = tempY >= map.height ? tempY - map.height : tempY;
////
//// 							neighbors.push({'x':tempX, 'y':tempY, 'z':-(tempX+tempY)});
//// 						}
//// 					}
//// 				}
//// 			}
////
//// 			return neighbors;
//// 		},
//
//		hexToPixel: function(hex) {
//			var minWidth = function(a, b) {
//				return scale * sqrt3 * (a + (b / 2))
//			};
//
//			var maxWidth = function(a) {
//				return scale * 3/2 * a
//			};
//
//			var pixelX = pointyTop ? minWidth(hex.getQ(), hex.getR()) : maxWidth(hex.getQ());
//			var pixelY = pointyTop ? maxWidth(hex.getR()) : minWidth(hex.getR(), hex.getQ());
//
//			pixelX += originX;
//			pixelY += originY;
//
//			return Point(pixelX, pixelY);
//		},
//
//		pixelToHex: function(point) {
//			var radiusLong = function(a, b) {
//				return ((a * (sqrt3 / 3)) - (b / 3)) / scale;
//			};
//
//			var radiusShort = function(a) {
//				return (a * (2 / 3)) / scale;
//			};
//
//			var pixelX = point.getX() - originX;
//			var pixelY = point.getY() - originY;
//
//			var q = pointyTop ? radiusLong(pixelX, pixelY) : radiusShort(pixelX);
//			var r = pointyTop ? radiusShort(pixelY) : radiusLong(pixelY, pixelX);
//
//			return Hex(q, r);
//		},
//
//		move: function(event) {
//			if (event.deltaX) {
//
//				originX = Math.floor((originX*1000) + (event.deltaX*1000)) / 1000;
//			}
//
//			if (event.deltaY) {
//
//				originY = Math.floor((originY*1000) + (event.deltaY*1000)) / 1000;
//			}
//		},
//
//		zoom: function(event) {
//			var scaleOrig = scale;
//
//			var scaleTemp = parseInt((scaleOrig + (event.deltaY / 10)) * 1000) / 1000;
//
//			// make sure 'scale' doesn't get too small nor too big
//			if (scaleTemp < scaleMin)
//				scaleTemp = scaleMin;
//			else if (scaleTemp > scaleMax)
//				scaleTemp = scaleMax;
//
//			if (scaleOrig != scaleTemp) {
//
//				scale = scaleTemp;
//
//				// zoom to the current mouse location
//				this.move({
//					deltaX: (((event.offsetX - originX) / scaleOrig) * (scaleOrig - scaleTemp)),
//					deltaY: (((event.offsetY - originY) / scaleOrig) * (scaleOrig - scaleTemp))
//				});
//			}
//		}
//	};
//
//	return ExWhyZee;
//};