enum Event {
	case kingInCheck(_ by: Piece)
	case piecePinned(from: Piece, on: Piece)
}
protocol EventDelegate {
	func notify(_ event: Event)
	func movePiece(_ piece: Piece, to dst: Square.Position)
}
public class Board: CustomStringConvertible, EventDelegate {
	public typealias Grid = [[Square]]

	private enum UnicodeBar: String, CustomStringConvertible {
		case VerticalBar = "│"
		case TopHorizontalLine = "┌───┬───┬───┬───┬───┬───┬───┬───┐"
		case MiddleHorizontalLine = "  ├───┼───┼───┼───┼───┼───┼───┼───┤"
		case BottomHorizonLine = "  └───┴───┴───┴───┴───┴───┴───┴───┘"

		var description: String {
			return self.rawValue
		}
	}

	func notify(_ event: Event) {

	}

	func movePiece(_ piece: Piece, to dst: Square.Position) {

	}

	public func getSquareInfo(on pos: Square.Position) -> Square? {
		self[pos]
	}

	private var squares = [Square]()
	internal var board: Grid {
		var board = Grid()
		var rank = -1
		for i in 0...63 {
			if i % 8 == 0 {
				board.append([])
				rank += 1
			}
			board[rank].append(squares[i])
		}
		return board
	}

	public internal(set) var fen: Fen

	public func setBoard() throws {
		var file: Int8 = 1
		var rank: Int8 = 8
		var index: Int8 = 0
		var b: [Square] = squares
		for c in fen.placement {
			let r = 8 - Int(rank)
			if c == "/" {
				if file != 9 {
					throw Fen.FenError.NotAppropriateLength(
						n: file, column: index)
				}
				rank -= 1
				file = 0
			} else if c.isWholeNumber, let n = Int8(String(c)) {
				if n < 1 {
					throw Fen.FenError.NumberTooSmall(n: n, column: index)
				} else if n > 8 {
					throw Fen.FenError.NumberTooBig(n: n, column: index)
				}

				let f = file
				for i in f..<(f + n) {
					file += 1
					b[8 * r + Int(i)].piece = nil
				}
				file -= 1
			} else if c.isASCII {
				switch Kind[c] {
				case .some(let (k, c)):
					let piece: Piece =
						switch k {
						case .Pawn:
							Pawn(with: c, on: .init(rank: rank, file: file))
						case .Knight:
							Knight(with: c, on: .init(rank: rank, file: file))
						case .Bishop:
							Bishop(with: c, on: .init(rank: rank, file: file))
						case .Rook:
							Rook(with: c, on: .init(rank: rank, file: file))
						case .Queen:
							Queen(with: c, on: .init(rank: rank, file: file))
						case .King:
							King(with: c, on: .init(rank: rank, file: file))
						}
					piece.delegate = self
					b[8 * r + Int(file) - 1].piece = piece
				case .none:
					throw Fen.FenError.InvalidCharacter(
						c: String(c), column: index)
				}
			}

			file += 1
			index += 1
		}
		#if DEBUG
			print(b)
		#endif
		squares = b
	}

	public required init(
		fen: Fen =
			.init(
				fen: "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1")
	) {
		var rank: Int8 = 8
		self.fen = fen
		for i in 0...63 {
			let index = Int8(i)
			let square = Square(
				position: .init(rank: rank, file: (index % 8) + 1),
				color: index % 2 != rank % 2 ? .Black : .White)
			squares.append(square)
			if (index + 1) % 8 == 0 {
				rank -= 1
			}
		}
		// TODO: Handle better
		do {
			try setBoard()
		} catch Fen.FenError.NotAppropriateLength(let n, let column) {
			fatalError("Not appropriate length: \(n) on \(column)")
		} catch {

		}
	}

	public var description: String {
		var boardString =
			"    A   B   C   D   E   F   G   H \n  \(UnicodeBar.TopHorizontalLine)\n"
		var _rank: UInt8 = 8
		board.forEach { rank in
			boardString += String(_rank) + " \(UnicodeBar.VerticalBar)"
			rank.forEach { square in
				let p = square.piece?.unicodeRepresentation ?? " "
				boardString += " \(p) \(UnicodeBar.VerticalBar)"
			}
			boardString += "\n"
			_rank -= 1
			if _rank > 0 {
				boardString += "\(UnicodeBar.MiddleHorizontalLine)\n"
			}
		}
		boardString += "\(UnicodeBar.BottomHorizonLine)"
		return boardString
	}

	internal subscript(pos: Square.Position) -> Square? {
		guard let i = pos.index else {
			return nil
		}
		if i > squares.count {
			return nil
		}
		return squares[i]
	}
}