enum Event {
	case kingInCheck(_ by: Piece, on: King)
	case piecePinned(from: Piece, on: Piece)
}
protocol EventDelegate {
	func notify(_ event: Event)
	func movePiece(_ piece: Piece, to dst: Square.Position) throws
	func addPieceToTarget(_ piece: Piece, target: 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) {

	}

	internal func addPieceToTarget(_ piece: Piece, target: Square.Position) {
		guard var square = self[target] else {
			return
		}
		square.targetted.insert(piece)
	}

	public private(set) var halfMoveClock: UInt8 = 0

	public var fullMoveClock: UInt8 {
		halfMoveClock / 2
	}

	internal var threatenedSquares: [Color: Set<Square.Position>] = [
		.White: [],
		.Black: [],
	]

	public internal(set) var history = History()

	public private(set) var turn: Color = .White

	func movePiece(_ piece: Piece, to dst: Square.Position) throws {
		let from = piece.position
		history.add(
			.pieceMove(
				from: squares[from.index!],
				to: squares[dst.index!]))
		piece.position = dst
		squares[dst.index!].piece = piece
		squares[from.index!].piece = nil
		halfMoveClock += 1
		turn = !turn
		fen.set(
			from: board, activeColor: turn, castling: .All,
			enPassant: fen.enPassant,
			halfMoveClock: halfMoveClock, fullMoveClock: fullMoveClock)
	}

	public enum MoveFailure: Error, CustomStringConvertible {
		case sourceSquareUnreachable(pos: Square.Position)
		case destinationSquareUnreachable(pos: Square.Position)
		case squareHasNoPiece(pos: Square.Position)
		case destinationIsIllegal(pos: Square.Position)
		case squareANIsTooLong(an: String)
		case squareANIsTooShort(an: String)

		public var description: String {
			return switch self {
			case .sourceSquareUnreachable(let pos):
				"The source square given \(pos.rank) \(pos.file) is unreachable."
			case .destinationSquareUnreachable(let pos):
				"The destination square given \(pos.rank) \(pos.file) is unreachable."
			case .squareHasNoPiece(let pos):
				"The square \(pos.rank) \(pos.file) doesn't have any piece to be moved."
			case .destinationIsIllegal(let pos):
				"The destination square given \(pos.rank) \(pos.file) is illegal to be moved to."
			case .squareANIsTooLong(let an):
				"The algebraic notation \(an) is too long. (Needs to be 2 characters)"
			case .squareANIsTooShort(let an):
				"The algebraic notation \(an) is too short. (Needs to be 2 characters)"
			}
		}
	}

	public func move(src: String, dst: String) throws {
		guard src.count < 3 else {
			throw MoveFailure.squareANIsTooLong(an: src)
		}
		guard src.count > 1 else {
			throw MoveFailure.squareANIsTooShort(an: src)
		}
		guard dst.count < 3 else {
			throw MoveFailure.squareANIsTooLong(an: dst)
		}
		guard dst.count > 1 else {
			throw MoveFailure.squareANIsTooShort(an: dst)
		}
		guard let f1 = src.first, let r1 = src.last, r1.isWholeNumber else {
			return
		}
		guard let f2 = dst.first, let r2 = src.last, r2.isWholeNumber else {
			return
		}
		guard
			let srcFile = Square.Position.File.init(rawValue: String(f1))?.value
		else {
			return
		}
		guard
			let dstFile = Square.Position.File.init(rawValue: String(f2))?.value
		else {
			return
		}

		try move(
			src: Square.Position(rank: Int8(String(r1))!, file: srcFile),
			dst: Square.Position(rank: Int8(String(r2))!, file: dstFile))
	}

	public func move(src: Square.Position, dst: Square.Position) throws {
		guard let srcSquare = self[src] else {
			throw MoveFailure.sourceSquareUnreachable(pos: src)
		}
		guard self[dst] != nil else {
			throw MoveFailure.destinationSquareUnreachable(pos: src)
		}
		guard let piece = srcSquare.piece else {
			throw MoveFailure.squareHasNoPiece(pos: src)
		}

		try piece.move(to: dst)
		#warning("May need to clear threatenedSquares before hand.")
		for square in squares where square.piece != nil {
			let p = square.piece!
			p.getLegalPosition()
			threatenedSquares[p.color]! += Set(p.legalPositions)
		}
	}

	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
		}
		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
			}
		}
		#warning("Handle better.")
		do {
			try setBoard()
			for square in squares where square.piece != nil {
				square.piece?.getLegalPosition()
			}
		} 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]
	}
}