const hexRadius = 10;
const hexLineWeight = 2;
const hexMargin = 2;
const antSize = 5;
const drawHex = true;
const drawPoints = false;
const drawStraightLines = false;
const drawCurves = true;
const drawAnts = true;
const frameUpdate = 5;

const xenoSway = 0.2;

let hexHeight, hexWidth, columns, rows;
let hexagons = [];
let ants = [];
let antCount;

function setup() {
	// calculate width and height of hexagons
  hexWidth = hexRadius * 2;
  hexHeight = Math.sqrt(3)*hexRadius;
	
	// set rows and columns to overlap page edge
  columns = Math.ceil(window.innerWidth / (hexRadius * 3));
  rows = Math.ceil(window.innerHeight / (hexHeight / 2)) + 1;
	antCount = Math.ceil(columns * rows * 0.01);
  
	// set up canvas
  createCanvas((columns + 1/4) * (hexRadius * 3), (rows + 1) * (hexHeight / 2));
  frameRate(120);
  fill(255, 100);
  stroke(255);
  strokeWeight(5);
  noStroke();
  
  // initialise 2D array of hexagons
  for (let x = 0; x < columns; x++) {
    hexagons.push([]);
    for (let y = 0; y < rows; y++) {
      hexagons[x].push(new Hex(x, y));
    }
  }
  // neighbouring needs to be done after they're all initialised
  for (let x = 0; x < columns; x++) {
    for (let y = 0; y < rows; y++) {
      hexagons[x][y].initialiseNeighbours(x, y);
    }
  }
  
  // initialise ants
  for (let i = 0; i < antCount; i++) {
		let x = Math.round(columns * (0.2 + random(0.6)));
		let y = Math.round(rows * (0.2 + random(0.6)));
    ants.push(new Ant(i, x, y));
  }
}

function draw() {
  background(30);
	
	if (drawHex) {
		for (let y = 0; y < rows; y++) {
			for (let x = 0; x < columns; x++) {
				hexagons[x][y].drawHex();
			}
		}
	}
	
  if (drawAnts) {
    for (let i = 0; i < antCount; i++) {
      ants[i].draw();
    }
  }
	
  for (let y = 0; y < rows; y++) {
    for (let x = 0; x < columns; x++) {
      hexagons[x][y].drawLines();
      hexagons[x][y].checkActive();
    }
  }
  update();
}

function update() {
  for (let i = 0; i < antCount; i++) {
		if (random() < 1/frameUpdate) {
			ants[i].update();
		}
  }
  for (let y = 0; y < rows; y++) {
    for (let x = 0; x < columns; x++) {
      let hex = hexagons[x][y];
      hex.update();
    }
  }
}

function mouseClicked() {
	antCount++;
	let x = Math.round(mouseX / width * columns);
	let y = Math.round(mouseY / height * rows);
	ants.push(new Ant(antCount, x, y));
}


class Ant {
  constructor(i, x, y) {
    this.i = i;
		
		// set random position on the grid
    this.x = x;
    this.y = y;
		
		// set random direction 0-5
		this.dir = Math.floor(random(0, 6));
    this.pixelPos = createVector(0, 0);
  }
  
  draw() {
    fill(255);
    this.pixelPos.x = hexWidth * (1.5 * this.x + 0.5 + this.y % 2 * 0.75);
    this.pixelPos.y = hexHeight * (this.y * 0.5 + 0.5);
    ellipse(this.pixelPos.x, this.pixelPos.y, antSize, antSize);
  }
	
	die() {
		// reset at a random position
    this.x = Math.floor(random(0, columns));
    this.y = Math.floor(random(0, rows));
	}
  
  update() {
		// get current hexagon by x, y
		var curHex = hexagons[this.x][this.y];
		
		// flip current state
		curHex.nextActive = !curHex.active;
		
		// turn right if current state was active
		if (curHex.active) {
			this.dir++;
		}
		// otherwise turn left
		else {
			this.dir--;
		}
		// make direction wrap around 0-5
		this.dir = (this.dir + 6) % 6;
		
		// get next hexagon from current's neighbours
		var nextHex = curHex.neighbours[this.dir];
		
		// if next hexagon doesn't exist call die()
		if (nextHex == false) {
			this.die();
			return;
		}
		
		// update x and y from next hexagon
		this.x = nextHex.pos.x;
		this.y = nextHex.pos.y;
	}
}


class Hex {
  constructor(x, y) {
    
    // establish grid position
    this.pos = createVector(x, y);
    
    // establish pixel position
    this.pixelPos = createVector(0, 0);
    this.pixelPos.x = hexWidth * (1.5 * x + 0.5 + y % 2 * 0.75);
    this.pixelPos.y = hexHeight * (y * 0.5 + 0.5);
    
    // establish state
    this.active = false;
    this.nextActive = false;
    
    // establish neighbours
    this.neighbours = [];
    
    // chose random layout (1-3) for dense (4/5/6 neighbours) display
    // regenerated when hex goes from inactive to active
    this.denseLayout = Math.ceil(random(3));
		
		// lazily updating count of active neighbours
		// used to colour hexagons
		this.xenosNeighbours = 0;
  }
  
  initialiseNeighbours(x, y) {
    let n = [false, false, false, false, false, false];
    const odd = y%2;
    
    // above
    if (y >= 2) {
      n[0] = hexagons[x][y-2];
    }
    
    // top right
    if (y >= 1) {
      if (!odd || x < columns-1) {
        n[1] = hexagons[x+odd][y-1];
      }
    }
    
    // bottom right
    if (y < rows-1) {
      if (!odd || x < columns-1) {
        n[2] = hexagons[x+odd][y+1];
      }
    }
    
    // bottom
    if (y < rows-2) {
      n[3] = hexagons[x][y+2];
    }
    
    // bottom left
    if (y < rows-1) {
      if (odd || x >= 1) {
        n[4] = hexagons[x-1+odd][y+1];
      }
    }
    
    // top left
    if (y >= 1) {
      if (odd || x >= 1) {
        n[5] = hexagons[x-1+odd][y-1];
      }
    }

    this.neighbours = n;
  }
  
  update() {
		// randomise layout if hex is becoming active
		if (!this.active && this.nextActive) {
			this.denseLayout = Math.ceil(random(3));
		}
    this.active = this.nextActive;
		
		// add to xenosNeighbours
		if (this.xenosNeighbours == 0) {
			// make accurate if 0
			this.xenosNeighbours = this.countActiveNeighbours();
		} else {
			this.xenosNeighbours = this.xenosNeighbours*(1-xenoSway) + xenoSway*this.countActiveNeighbours();
		}
  }
  
  countActiveNeighbours() {
    let activeNeighbours = 0;
    for (let i = 0; i < 6; i++) {
      if (this.neighbours[i] && this.neighbours[i].active) {
        activeNeighbours++;
      }
    }
    return activeNeighbours;
  }
  
  getActiveNeighbours() {
    let activeNeighbours = [];
    for (let i = 0; i < 6; i++) {
      if (this.neighbours[i] && this.neighbours[i].active) {
        activeNeighbours.push(true);
      } else {
        activeNeighbours.push(false);
      }
    }
    return activeNeighbours;
  }
  
  checkActive() {
		if (this.nextActive != this.active) {
			this.nextActive = this.active;
		}
  }
  
  checkNeighbours() {
    return true;
  }
  
  drawHex() {
    push();
    translate(this.pixelPos.x, this.pixelPos.y);
    noStroke();
		fill(5*this.xenosNeighbours,
				 10*Math.pow(this.xenosNeighbours, 1.7),
				 30*this.xenosNeighbours);
		if (!this.active) fill(0);
		beginShape();
		for (let i = 0; i < 6; i++) {
			vertex((hexRadius-hexMargin/2)*cos(i*Math.PI/3), (hexRadius-hexMargin/2)*sin(i*Math.PI/3));
		}
		endShape(CLOSE);
    pop();
	}

  drawLines() {
    push();
    translate(this.pixelPos.x, this.pixelPos.y);
    // draw shapes
    if (this.active) {
      let activeNeighboursCount = this.countActiveNeighbours();
      let activeNeighbours = this.getActiveNeighbours();
      stroke(255);
      strokeWeight(hexLineWeight);
      noFill();
      
      // no neighbours
      if (activeNeighboursCount == 0) {
        if (drawPoints) {
          point(0, 0);
          // ellipse(0, 0, hexRadius/2);
        }
      }
      
      // one neighbour
      else if (activeNeighboursCount == 1) {
        if (drawStraightLines) {
          var pos = getEdgePos(activeNeighbours.indexOf(true));
          line(0, 0, pos.x, pos.y);
        }
      }
			
      // two or three neighbours
      else if (activeNeighboursCount == 2 || activeNeighboursCount == 3) {
        if (drawCurves) {
          for (var i = 0; i < 6; i++) {
            if (activeNeighbours[i]) {
              for (var j = i+1; j < 6; j++) {
                if (activeNeighbours[j]) {
                  var pos1 = getEdgePos(i);
                  var pos2 = getEdgePos(j);
                  drawCurveThroughOrigin(pos1, pos2);
                }
              }
            }
          }
        }
      }
      
      // four neighbours
      else if (activeNeighboursCount == 4) {
        if (drawCurves) {
          let skipped1 = activeNeighbours.indexOf(false);
					let skipped2 = activeNeighbours.slice(skipped1+1).indexOf(false) + skipped1 + 1;
					
					// make list of active edge positions
					var positions = [];
					for (let i = 0; i < 6; i++) {
						if (i != skipped1 && i != skipped2) {
							positions.push(getEdgePos(i));
						}
					}
					
					// skips are adjacent
					if (skipped2 - skipped1 == 1) {
						if (this.denseLayout == 3) {
							// connect edges to adjacent edges
              drawCurveThroughOrigin(positions[0], positions[1]);
              drawCurveThroughOrigin(positions[1], positions[2]);
              drawCurveThroughOrigin(positions[2], positions[3]);
            }
            else if (this.denseLayout == 2) {
              // cross over curves
              drawCurveThroughOrigin(positions[0], positions[2]);
              drawCurveThroughOrigin(positions[1], positions[3]);
            }
            else {
              // pair edges with adjacent edges
              drawCurveThroughOrigin(positions[0], positions[1]);
              drawCurveThroughOrigin(positions[2], positions[3]);
						}
					}
					
					// 1 and 3 situation
					// or 2 and 2
					else {
						if (this.denseLayout == 3) {
							// connect edges to adjacent edges
              drawCurveThroughOrigin(positions[0], positions[1]);
              drawCurveThroughOrigin(positions[1], positions[2]);
              drawCurveThroughOrigin(positions[2], positions[3]);
              drawCurveThroughOrigin(positions[3], positions[0]);
						}
            else if (this.denseLayout == 2) {
              // pair edges with adjacent edges
              drawCurveThroughOrigin(positions[3], positions[0]);
              drawCurveThroughOrigin(positions[1], positions[2]);
            }
            else {
              // pair edges with adjacent edges alt
              drawCurveThroughOrigin(positions[0], positions[1]);
              drawCurveThroughOrigin(positions[2], positions[3]);
						}
					}
				}
			}
      
      // five neighbours
      else if (activeNeighboursCount == 5) {
        if (drawCurves) {
          let skipped = activeNeighbours.indexOf(false);
          if (this.denseLayout == 3) {
            // connect edges to adjacent edges
            for (var i = skipped; i < 5 + skipped; i++) {
              var pos1 = getEdgePos(i);
							if (i == skipped) {
								pos1 = getEdgePos((i+5) % 6);
							}
              var pos2 = getEdgePos((i+1) % 6);
              drawCurveThroughOrigin(pos1, pos2);
            }
          }
          else if (this.denseLayout == 2) {
						// batman logo
						// curve between two adjacent to skipped one
						let pos1 = getEdgePos((skipped+5) % 6);
						let pos2 = getEdgePos((skipped+1) % 6);
						drawCurveThroughOrigin(pos1, pos2);
						// connect other 3 to eachother
						let pos3 = getEdgePos((skipped+2) % 6);
						let pos4 = getEdgePos((skipped+3) % 6);
						let pos5 = getEdgePos((skipped+4) % 6);
						drawCurveThroughOrigin(pos3, pos4);
						drawCurveThroughOrigin(pos4, pos5);
          }
          else if (this.denseLayout == 1) {
						// evil M
						let pos1 = getEdgePos((skipped+1) % 6);
						let pos2 = getEdgePos((skipped+2) % 6);
						let pos3 = getEdgePos((skipped+3) % 6);
						let pos4 = getEdgePos((skipped+4) % 6);
						let pos5 = getEdgePos((skipped+5) % 6);
						// curve the two skipped-adjacent edges to the opposite edge
						drawCurveThroughOrigin(pos1, pos3);
						drawCurveThroughOrigin(pos5, pos3);
						// curve the other two edges to the skipped-adjacent edges
						drawCurveThroughOrigin(pos1, pos2);
						drawCurveThroughOrigin(pos5, pos4);
          }
        }
      }
      
      // full house
      else {
        if (drawCurves) {
          if (this.denseLayout == 3) {
            // connect edges to adjacent edges
            for (var i = 0; i < 6; i++) {
              var pos1 = getEdgePos(i);
              var pos2 = getEdgePos((i+1) % 6);
              drawCurveThroughOrigin(pos1, pos2);
            }
          }
          else {
            // pair edges with adjacent edges
            for (var i = this.denseLayout - 1; i < 6; i+=2) {
              var pos1 = getEdgePos(i);
              var pos2 = getEdgePos((i+1) % 6);
              drawCurveThroughOrigin(pos1, pos2);
            }
          }
        }
      }
      
    }
    pop();
  }
}

function drawCurveThroughOrigin(pos1, pos2) {
  beginShape();
  vertex(pos1.x, pos1.y);
  quadraticVertex(0, 0, pos2.x, pos2.y);
  endShape();
}

function getEdgePos(i) {
  var pos = createVector(0, -hexHeight/2);
  pos.rotate(i*Math.PI/3);
  return pos;
}