package exercises

import examples.States._

//  Написать крестики-нолики
//  На вход список клетка - игрок
//  По списку проходим последовательно
//  Если клетка, на которую пытаемся сходить - занята,
//  ничего не происходит, ход сгорает, идём дальше
//  Пустой инпут - ничья
//  Вывести рез-т игры для заданных входных данных
//  while, return и var запрещены
//  try catch не использовать
//  5 баллов

object States {

  sealed trait Player

  case object X extends Player

  case object O extends Player

  sealed trait Cell

  case object AA extends Cell

  case object AB extends Cell

  case object AC extends Cell

  case object BA extends Cell

  case object BB extends Cell

  case object BC extends Cell

  case object CA extends Cell

  case object CB extends Cell

  case object CC extends Cell

  case class Game(cells: Map[Cell, Player] = Map())

  type GameState = State[Game, (Cell, Player)]

  val winMsg: Player => String = (plr: Player) => s"Der Spieler $plr hat gewonnen"
  val standOffMsg = "Unentschieden"

  def getGame(inp: List[(Cell, Player)], gm: Game): Game = Game(inp.reverse.toMap)


  def getLast(inp: List[(Cell, Player)]): (Cell, Player) = {
    if (inp.isEmpty) {
      (CC, O)
    }
    else inp.last
  }

  def play(input: List[(Cell, Player)]): GameState = new GameState(game => (getLast(input), getGame(input, game)))

  def helpFunc(d: List[List[Cell]], g: Game): List[Player] = {
    d.foldLeft(Nil: List[Player]) { (acc, next) =>
      if (acc contains g.cells(next.head)) acc
      else g.cells(next.head) :: acc
    }.reverse
  }

  def getCheck(wins: List[List[Cell]], g: Game): Option[Player] = {
    val d = wins.filter((l: List[Cell]) => g.cells.contains(l(0)) && g.cells.contains(l(1)) && g.cells.contains(l(2))).
      filter((l: List[Cell]) => g.cells(l(0)) == g.cells(l(1)) && g.cells(l(1)) == g.cells(l(2)) && g.cells(l(0)) == g.cells(l(2)))
    val s = helpFunc(d, g)
    if (s.length > 1 || s.isEmpty) {
      None
    }
    else {
      Option(s.head)
    }
  }

  def getWinner(g: Game): Option[Player] = {
    val wins1 = List(AA, BB, CC)
    val wins2 = List(AA, AB, AC)
    val wins3 = List(BA, BB, BC)
    val wins4 = List(CA, CB, CC)
    val wins5 = List(CA, BB, AC)
    val wins6 = List(AA, BA, CA)
    val wins7 = List(AB, BB, CB)
    val wins8 = List(AC, BC, CC)
    val wins: List[List[Cell]] = List(wins1, wins2, wins3, wins4, wins5, wins6, wins7, wins8)
    getCheck(wins, g)
  }

  def result(g: Game): String = {
    if (g.cells.isEmpty) {
      "Unentschieden"
    }
    else {
      getWinner(g) match {
        case Some(i) => s"Der Spieler $i hat gewonnen"
        case None => "Unentschieden"
      }
    }
  }

  def main(args: Array[String]): Unit = {
    val game = Game()
    val p = List((AA, X), (AB, X), (AC, X), (BA, O), (BB, O), (BC, O))
    val (_, gm) = play(p).run(game)

    val a = result(gm)
    val b = winMsg(O)

    val p2 = List()

    val (_, gm2) = play(p2).run(game)

    val c = result(gm2)
    val d = standOffMsg
  }


}