// assumption for Move struct
struct Move {
	var player: Player?
	var position: Int?
	var boardIndex: Int = 0
	var indicator: String {
		if let p = player {
			return p == .human ? "x" : "o"
		}
		return ""
	}
}

// assumption for AlertItem struct
struct AlertItem {
	var title: String = "Result"
	var message: String = "message"
	var buttonTitle: String = "OK"
}

enum Player {
	case human
	case computer
}

class CodeTicTacToeViewController: UIViewController {
	
	var gameBoardView: UIView = {
		let v = UIView()
		v.backgroundColor = .systemBlue
		return v
	}()
	var buttons: [UIButton] = []
	var viewModel = TicTacToeViewModel()
	
	override func viewDidLoad() {
		super.viewDidLoad()
		configureUI()
		
		let outerStack: UIStackView = {
			let v = UIStackView()
			v.axis = .vertical
			v.spacing = 8
			v.distribution = .fillEqually
			return v
		}()
		
		for _ in 1...3 {
			let rowStack: UIStackView = {
				let v = UIStackView()
				v.axis = .horizontal
				v.spacing = 8
				v.distribution = .fillEqually
				return v
			}()
			for _ in 1...3 {
				let b: UIButton = {
					let v = UIButton()
					v.backgroundColor = .systemYellow
					return v
				}()
				rowStack.addArrangedSubview(b)
				buttons.append(b)
			}
			outerStack.addArrangedSubview(rowStack)
		}
		
		outerStack.translatesAutoresizingMaskIntoConstraints = false
		gameBoardView.translatesAutoresizingMaskIntoConstraints = false

		gameBoardView.addSubview(outerStack)
		view.addSubview(gameBoardView)
		
		let g = view.safeAreaLayoutGuide
		NSLayoutConstraint.activate([
			
			outerStack.topAnchor.constraint(equalTo: gameBoardView.topAnchor, constant: 8.0),
			outerStack.leadingAnchor.constraint(equalTo: gameBoardView.leadingAnchor, constant: 8.0),
			outerStack.trailingAnchor.constraint(equalTo: gameBoardView.trailingAnchor, constant: -8.0),
			outerStack.bottomAnchor.constraint(equalTo: gameBoardView.bottomAnchor, constant: -8.0),

			gameBoardView.leadingAnchor.constraint(equalTo: g.leadingAnchor, constant: 20.0),
			gameBoardView.trailingAnchor.constraint(equalTo: g.trailingAnchor, constant: -20.0),
			gameBoardView.centerYAnchor.constraint(equalTo: g.centerYAnchor),
			gameBoardView.heightAnchor.constraint(equalTo: gameBoardView.widthAnchor),

		])
		
		// set tag and action for the buttons
		var t: Int = 1
		buttons.forEach { b in
			b.tag = t
			b.addTarget(self, action: #selector(buttonClicked(_:)), for: .touchUpInside)
			t += 1
		}

	}
	
	func configureUI() {
		viewModel.delegate = self
	}
	
	@IBAction func buttonClicked(_ sender: UIButton) {
		viewModel.processPlayerMove(for: sender.tag)
	}

	/// This **function is to reset the view means remove close and circle image once player wants to restart the game. But this code is not working**

	/// should be working now
	func updateButtonView() {
		DispatchQueue.main.async {
			for (index, moves) in self.viewModel.moves.enumerated() {
				let button = self.buttons[index]
				if let moves = moves {
					// let's make sure we get a valid image
					if let image = UIImage(named: moves.indicator) {
						button.setImage(image, for: [])
						button.setTitle("", for: [])
					} else {
						button.setImage(nil, for: [])
						button.setTitle(moves.indicator, for: [])
					}
				} else {
					button.setImage(nil, for: [])
					button.setTitle("", for: [])
				}
			}
		}
	}
}

/// Delegates are called from viewmodel

extension CodeTicTacToeViewController: TicTacToeViewModelProtocol {
	
	func updatePlayerInfo(index: Int) {
		let button = buttons[index - 1]
		let systemImageName =  viewModel.moves[index - 1]?.indicator ?? ""
		if !systemImageName.isEmpty {
			// let's make sure we get a valid image
			if let image = UIImage(named: systemImageName) {
				button.setImage(image, for: [])
				button.setTitle("", for: [])
			} else {
				button.setImage(nil, for: [])
				button.setTitle(systemImageName, for: [])
			}
		} else {
			button.setImage(nil, for: [])
			button.setTitle("", for: [])
		}
	}
	
	func displayAlert(alertData: AlertItem) {
		let alert = UIAlertController(title: alertData.title, message: alertData.message, preferredStyle: UIAlertController.Style.alert)
		
		alert.addAction(UIAlertAction(title: alertData.buttonTitle, style: UIAlertAction.Style.default, handler: { [weak self] _ in
			self?.viewModel.resetGame()
			self?.updateButtonView()
		}))
		self.present(alert, animated: true, completion: nil)
	}
	
	func gameBoardDisabled(isGameBoardDisable: Bool) {
		gameBoardView.isUserInteractionEnabled = !isGameBoardDisable
	}
}


protocol TicTacToeViewModelProtocol: AnyObject {
	func updatePlayerInfo(index: Int)
	func displayAlert(alertData: AlertItem)
	func gameBoardDisabled(isGameBoardDisable: Bool)
}

class TicTacToeViewModel {
	var currentMovePosition: Int?
	
	var moves: [Move?]  = Array(repeating: nil, count: 9) {
		didSet {
			if let delegate = delegate, let position = self.currentMovePosition {
				delegate.updatePlayerInfo(index: position)
			}
		}
	}
	var isGameBoardDisable = false {
		didSet {
			if let delegate = delegate {
				delegate.gameBoardDisabled(isGameBoardDisable: isGameBoardDisable)
			}
		}
		
	}
	var alertItem: AlertItem? {
		didSet {
			if let delegate = delegate, let alertItem = alertItem {
				delegate.displayAlert(alertData: alertItem)
			}
		}
	}
	
	let winPatterns: Set<Set<Int>> = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [1, 4, 7], [2, 5, 8], [3, 6, 9], [1, 5, 9], [3, 5, 7]]
	
	weak var delegate: TicTacToeViewModelProtocol!
	
	func processPlayerMove(for position: Int) {
		self.currentMovePosition = position
		if isSquareOccupied(in: moves, forIndex: position) { return }
		moves[position - 1] = Move(player:  .human, boardIndex: position)

		// logic for win, draw or lose
		if checkWinCondition(for: .human, in: moves) {
			var a = AlertItem()
			a.message = "Human Wins"
			alertItem = a
			return
		}
		
		if checkForDraw(in: moves) {
			var a = AlertItem()
			a.message = "Player Draw"
			alertItem = a
			return
		}
		isGameBoardDisable = true
		
		processComputerMove()
	}
	
	func processComputerMove() {
		let computerPosition = determinComputerMovePosition(in: moves)
		self.currentMovePosition = computerPosition
		
		moves[computerPosition - 1] = Move(player:  .computer, boardIndex: computerPosition)
		isGameBoardDisable = false
		
		if checkWinCondition(for: .computer, in: moves) {
			var a = AlertItem()
			a.message = "Computer Wins"
			alertItem = a
			return
		}
		if checkForDraw(in: moves) {
			var a = AlertItem()
			a.message = "Computer Draw"
			alertItem = a
			return
		}
	}
	
	func isSquareOccupied(in moves:[Move?], forIndex index: Int) -> Bool {
		return moves.contains(where: { $0?.boardIndex == index })
	}
	
	func determinComputerMovePosition(in moves: [Move?]) -> Int {
		
		let computerMoves: [Move] = moves.compactMap { $0 }.filter { $0.player == .computer }
		let computerPositions: Set<Int> = Set(computerMoves.map { $0.boardIndex })
		
		for pattern in winPatterns {
			let winPositions = pattern.subtracting(computerPositions)
			if winPositions.count == 1 {
				let isAvailable = !isSquareOccupied(in: moves, forIndex: winPositions.first!)
				if isAvailable { return winPositions.first! }
			}
		}
		// if the AI ​​can't finish the game it will block
		let humanMoves = moves.compactMap { $0 }.filter { $0.player == .human }
		let humanPositions = Set(humanMoves.map { $0.boardIndex })
		
		for pattern in winPatterns {
			let winPositions = pattern.subtracting(humanPositions)
			
			if winPositions.count == 1 {
				let isAvailable = !isSquareOccupied(in: moves, forIndex: winPositions.first!)
				if isAvailable { return winPositions.first! }
			}
		}
		// always take the middle block
		let middleSquare = 5
		if !isSquareOccupied(in: moves, forIndex: middleSquare) {
			return middleSquare
		}

		// this could theoretically take a LONG time to process!
		// if the AI ​​can't get position middle block it will get a random position
		//var movePosition = Int.random(in: 1..<10)
		//while isSquareOccupied(in: moves, forIndex: movePosition) {
		//	movePosition = Int.random(in: 1..<10)
		//}
		//return movePosition
		
		// create a shuffled array of 1 to 9
		//	loop through until we find an available position
		var positions: [Int] = Array(1...9).shuffled()
		var movePosition: Int = positions.removeFirst()
		while isSquareOccupied(in: moves, forIndex: movePosition) {
			movePosition = positions.removeFirst()
		}
		return movePosition
	}
	
	func checkWinCondition(for player: Player, in moves:[Move?]) -> Bool {
		
		let playerMoves = moves.compactMap({ $0 }).filter { $0.player == player }
		let playerPositions = Set(playerMoves.map { $0.boardIndex })
		
		for pattern in winPatterns where pattern.isSubset(of: playerPositions) {return true}
		return false
	}
	
	func checkForDraw(in moves: [Move?]) -> Bool {
		return moves.compactMap { $0 }.count == 9
		
	}
	
	func resetGame() {
		moves = Array(repeating: nil, count: 9)
	}
}