package java2scala.homeworks

trait CharAutomata[+A] {

  /** потребить один символ и перейти в следующее состояние */
  def consume(char: Char): CharAutomata[A]

  /** получить текущий результат, если это конец строки */
  def result: Either[String, A]

  /** потребить строку символ за символом */
  def apply(source: String): Either[String, A] =
    if (source.isEmpty) result
    else consume(source.head)(source.tail)

  /** создать автомат, который запустит оба автомата
    * и если первый вернёт ошибку, вернёт результат второго
    */
  def or[B](auto: CharAutomata[B]): CharAutomata[Either[A, B]] = new CharAutomata.Or(this, auto)

  /** создать автомат, который запустит оба автомата
    * вернёт результаты обоих, если оба вернут успешный результат
    * и вернёт ошибку, если вернёт ошибку хотя бы один
    */
  def and[B](auto: CharAutomata[B]): CharAutomata[(A, B)] = new CharAutomata.And(this, auto)
}

object CharAutomata {

  /** создаёт автомат, всегда результирующий с ошибкой
    * с заданным текстом message
    */
  def error(message: String): CharAutomata[Nothing] = new Error(message)

  /** создаёт автомат, всегда успешно результирующий
    * с заданным значением `value`
    */
  def const[A](value: A): CharAutomata[A] = new Const[A](value)

  /** создаёт автомат, возвращающий
    * первое вхождение строчки `substring`
    * или ошибкой
    */
  def find(substring: String): CharAutomata[Int] = new Find(substring)(Position(0), State(0))

  /** создаёт автомат, определяющий является ли строчка,
    * если исключить из неё все символы, кроме `'('` и `')'`
    * корректной скобочной последовательностью */
  def balance: CharAutomata[Unit] = new ParenBalance(Balanced)

  /** создаёт автомат, ищущий первое число, из цифр подряд
    * и возвращающий результат в качестве BigInt либо 0
    */
  def parseInt: CharAutomata[BigInt] = new ParseInteger(NotFound)

  /** класс для реализации метода `error` */
  class Error(string: String) extends CharAutomata[Nothing] {
    def consume(char: Char): CharAutomata[Nothing] = this

    def result: Either[String, Nothing] = Left(string)
  }

  /** класс для реализации метода `const` */
  class Const[A] private[CharAutomata] (value: A) extends CharAutomata[A] {
    def consume(char: Char): CharAutomata[A] = this

    def result: Either[String, A] = Right(value)
  }

  /** класс для реализации метода `find` */
  /** Автомат для поиска подстроки взят из книжки Кормена из раздела 32.3 "Поиск подстрок с помощью конечных автоматов" */

  case class Position(value: Int)
  case class State(value: Int)

  class Find private[CharAutomata] (substring: String)(position: Position, state: State) extends CharAutomata[Int] {
    def stateTransitionFunction(state: State, char: Char): State =
      State {
        (Math.min(substring.length, state.value + 1) to 0 by -1)
          .find(i => (substring.substring(0, state.value) + char).endsWith(substring.substring(0, i)))
          .getOrElse(0)
      }

    def consume(char: Char): CharAutomata[Int] =
      result match {
        case Right(_) => this
        case Left(_)  => new Find(substring)(Position(position.value + 1), stateTransitionFunction(state, char))
      }

    def result: Either[String, Int] =
      if (substring.isEmpty) Right(0)
      else if (substring.length == state.value) Right(position.value - substring.length)
      else Left("Not found")
  }

  /** класс для реализации метода `balance` */
  sealed trait ParenBalanceState
  case object Balanced              extends ParenBalanceState
  case object NotBalanced           extends ParenBalanceState
  case class  Imbalance(count: Int) extends ParenBalanceState

  class ParenBalance private[CharAutomata] (balance: ParenBalanceState) extends CharAutomata[Unit] {
    def consume(char: Char): CharAutomata[Unit] = char match {
      case '(' =>
        balance match {
          case Balanced         => new ParenBalance(Imbalance(1))
          case Imbalance(count) => new ParenBalance(Imbalance(count + 1))
          case _                => this
        }
      case ')' =>
        balance match {
          case Balanced                       => new ParenBalance(NotBalanced)
          case Imbalance(count) if count == 1 => new ParenBalance(Balanced)
          case Imbalance(count)               => new ParenBalance(Imbalance(count - 1))
          case _                              => this
        }
      case _   => this
    }

    def result: Either[String, Unit] = balance match {
      case Balanced    => Right(())
      case _           => Left("Incorrect")
    }
  }

  /** класс для реализации метода `parseInt` */

  sealed trait ParsingState
  case object NotFound                 extends ParsingState
  case class  Found(value: BigInt)     extends ParsingState
  case class  InProcess(value: BigInt) extends ParsingState

  class ParseInteger private[CharAutomata] (parse: ParsingState) extends CharAutomata[BigInt] {
    def consume(char: Char): CharAutomata[BigInt] =
      if (char.isDigit)
        parse match {
          case NotFound         => new ParseInteger(InProcess(char.asDigit))
          case Found(_)         => this
          case InProcess(value) => new ParseInteger(InProcess(value * 10 + char.asDigit))
        }
      else
        parse match {
          case NotFound         => this
          case Found(_)         => this
          case InProcess(value) =>
            if (value == 0) new ParseInteger(NotFound)
            else new ParseInteger(Found(value))
        }

    def result: Either[String, BigInt] =
      parse match {
        case NotFound         => Right(0)
        case Found(value)     => Right(value)
        case InProcess(value) => Right(value)
      }
  }

  /** класс для реализации метода `and` */
  class And[A, B] private[CharAutomata] (autoA: CharAutomata[A], autoB: CharAutomata[B]) extends CharAutomata[(A, B)] {
    def consume(char: Char): CharAutomata[(A, B)] = new And(autoA.consume(char), autoB.consume(char))

    def result: Either[String, (A, B)] =
      (autoA.result, autoB.result) match {
        case (Right(valueA), Right(valueB)) => Right((valueA, valueB))
        case _                              => Left("Error")
      }
  }

  /** класс для реализации метода `or` */
  class Or[A, B] private[CharAutomata] (autoA: CharAutomata[A], autoB: CharAutomata[B]) extends CharAutomata[Either[A, B]] {
    def consume(char: Char): CharAutomata[Either[A, B]] = new Or(autoA.consume(char), autoB.consume(char))

    def result: Either[String, Either[A, B]] =
      autoA.result match {
        case Right(value) => Right(Left(value))
        case Left(_)      =>
          autoB.result match {
            case Right(value) => Right(Right(value))
            case Left(error)  => Left(error)
          }
      }
  }
}