(function(){

	var vec2, Rect, sort
	if ('window' in this) {
		vec2 = window.vec2
		Rect = window.Rect
		sort = window.sort
	}
	else {
		vec2 = require('./vec2')
		Rect = require('./rect')
		UidGenerator = require('../util/uid')
	}
	
	var Wall = function(opt){
		this.id = opt.id
		this.vec = opt.vec
		this.edge = opt.edge
		this.side = opt.side
		this.surface = opt.surface
		this.mx = opt.mx
	}
	
	Wall.prototype.toString = function(){
		return this.vec.toString()
	}

	Wall.prototype.reset = function(){
	}
	
	Wall.prototype.destroy = function(){
		this.mx.forEach(function(mx){
			mx.destroy && mx.destroy()
		})
		this.room = this.vec = this.mx = null
	}
	
	Wall.prototype.bind = function(){
		var base = this
		base.$walls = $( this.mx.map(function(mx){ return mx.el }) )
		
		this.mx.forEach(function(mx){
			$(mx.el).bind({
				mouseover: function(){
				},
				mouseenter: function(e){
					Scenery.mouse.mouseenter(e, base, mx)
				},
				mousemove: function(e){
				},
				mousedown: function(){
					// base.randomize_colors()
					// console.log(sidesToString(base.side))
					if (Scenery.nextMedia) {
					var scenery = Scenery.addNextToWall(base)
					
  					UndoStack.push({
  					  type: 'create-scenery',
  					  undo: { id: scenery.id },
              redo: scenery.serialize(),
  					})
					}
					else if (Scenery.nextWallpaper) {
						base.wallpaper()
					}
					else {
						app.controller.hideExtras()
					}
				}
			})
		})
		this.outline()
	}
	
	Wall.prototype.bounds_for = function(img, scale) {
		scale = scale || 1
		var coord = this.side & FRONT_BACK ? this.rect.x : this.rect.y
		var halfWidth = img.width/2 * scale
		var halfHeight = img.height/2 * scale

		return new Rect( new vec2( coord.a + halfWidth, coord.b - halfWidth ),
		                 new vec2( halfHeight, Rooms.list[this.room].height - halfHeight ) )
	}
	
	Wall.prototype.bounds_for_mx = function(img, scale, mx) {
		// 
	}
	Wall.prototype.fits_mx = function(img, scale, mx) {
	}
	
	Wall.prototype.fits = function(img, scale){
		if (this.side & FRONT_BACK && this.rect.x.length() < img.width * scale) {
			return false
		}
		if (this.side & LEFT_RIGHT && this.rect.y.length() < img.width * scale) {
			return false
		}
		return true
	}
	
	Wall.prototype.center = function(offset){
	
		offset = offset || 0

		var major_axis, minor_axis
		if (this.side & FRONT_BACK) {
			major_axis = this.rect.x
			minor_axis = this.rect.y
		}
		else {
			major_axis = this.rect.y
			minor_axis = this.rect.x
		}
		
		switch (this.side) {
			case FRONT:
				x = major_axis.midpoint()
				z = minor_axis.a + painting_distance_from_wall + offset
				break
			case BACK:
				x = major_axis.midpoint()
				z = minor_axis.b - painting_distance_from_wall + offset
				break
			case LEFT:
				x = minor_axis.a + painting_distance_from_wall + offset
				z = major_axis.midpoint()
				break
			case RIGHT:
				x = minor_axis.b - painting_distance_from_wall + offset
 				z = major_axis.midpoint()
				break
		}
		
		return new vec2 (x, z)
	}
	
	Wall.prototype.color = function(color){
		this.$walls && this.$walls.css("background-color", color)
	}
	
	Wall.prototype.wallpaper = function(){
		var useX = this.side & FRONT_BACK
		var shouldFlip = this.side & (LEFT | BACK)
		this.siblings().forEach(function(w){
			w.mx.forEach(function(mx){
				
				var partitionOffset = useX ? mx.x : mx.z
				if (shouldFlip) partitionOffset *= -1
				partitionOffset += mx.width/2
				var floorOffset = mx.y + mx.height/2

				mx.el.style.backgroundImage = Scenery.nextWallpaper
				mx.el.style.backgroundPosition = (~~partitionOffset) + "px " + (~~floorOffset) + "px"
			})
		})
	}
	
	Wall.prototype.outline = function(){
		var canvas = document.createElement("canvas")
		var ctx = canvas.getContext('2d')
		var useX = this.side & FRONT_BACK
		var shouldFlip = this.side & (LEFT | BACK)
		var mx = this.mx

		// console.log( sidesToString(this.side), mx.length )
		if (! shouldFlip) {
			mx = mx.reverse()
		}

		var len = this.mx.length
		
		zz = window.zz || 0

		mx.forEach(function(mx, i){
			if (mx.outlined) return
			mx.outlined = true
			canvas.width = mx.width
			canvas.height = mx.height
			ctx.fillStyle = "rgba(255,255,255,0.95)"
			ctx.fillRect(0, 0, canvas.width, canvas.height)
			ctx.fillStyle = "rgba(0,0,0,1.0)"

			// all walls get bottom lines
			ctx.fillRect(0, 0, canvas.width, 1)
			
			// all walls get top lines
			ctx.fillRect(0, canvas.height-1, canvas.width, 1)
			
			// walls on initial sides get left lines
			// if their left edge lines up with the rect edge
			if (i == 0) {
 				ctx.fillRect(0, 0, 1, canvas.height)
			}
			
			// walls on terminal sides get right lines....
			// if their right edge lines up with the rect edge
			if (i == len-1) {
				ctx.fillRect(canvas.width-1, 0, 1, canvas.height)
			}
			var dataUrl = canvas.toDataURL()

			mx.el.style.backgroundImage = "url(" + dataUrl + ")"
		})
	}
	
	Wall.prototype.siblings = function(){
		return this
// 		var base = this
// 		var match = base.side | base.half_side
// 		var walls = Rooms.list[this.room].walls.filter(function(w){
// 			return (w.side | w.half_side) & match && w.$walls
// 		})
// 		return walls
	}

	Wall.prototype.randomize_colors = function(){
		var color = window.grayColors[ this.side | this.half_side ]
		this.color(color)
	}

	Wall.prototype.stroke_colors = function(){
		var color = "#fff"
		var siblings = this.siblings()
		siblings.forEach(function(w, i){
			if (! w.$walls) return
			w.color(color)
			if (i == 0) {
				w.$walls.css("border-left", "1px solid #000")
			}
			if (i == siblings.length-1) {
				w.$walls.css("border-right", "1px solid #000")
			}
			w.$walls.css("border-top", "1px solid #000")
			w.$walls.css("border-bottom", "1px solid #000")
		})
	}
	
	if ('window' in this) {
		window.Wall = Wall
	}
	else {
		module.exports = Wall
	}


})()