package bank.time

import bank._
import java.io
import java.io.{File, FileOutputStream, PrintWriter}

class Bank() {

  var tomBank: Vector[BankAccount] = Vector.empty
  var tomHistory: Vector[HistoryEntry] = Vector.empty

  def allAccounts(): Vector[BankAccount] = {
      tomBank.sortBy(_.holder.name)
  }

  def saveString(text: String, fileName: String): Unit = {
   if (new java.io.File(fileName).exists) {
      val currentFile = new PrintWriter(new FileOutputStream(new File(fileName), true))
      currentFile.append(text)
      currentFile.close()
    }
   else {
     val file = new io.File(fileName)
     val printW = new io.PrintWriter(file, "UTF-8")
     try printW.write(text) finally printW.close()
    }
  }

  def findByNumber(accountNbr: Int): Option[BankAccount] = {

    var count = 0
    var result: Vector[BankAccount] = Vector[BankAccount]()
    for (bankAccount <- tomBank.indices) {
      if (tomBank(bankAccount).accountNumber == accountNbr) {
        result = result :+ tomBank(bankAccount)
      }
      else count += 1
      }
    Option(result(0))

  }

  def findAccountsForHolder(id: Long): Vector[BankAccount] = {

    var count = 0
    var result: Vector[BankAccount] = Vector[BankAccount]()
    for (bankAccount <- tomBank) {
      if (bankAccount.holder.id == id) {
        result = result :+ bankAccount
      }
      else count += 1
    }
    result
  }

  def findByName(namePattern: String): Vector[Customer] = {
    var namn: Vector[Customer] = Vector.empty

    for (bankAccounts <- tomBank) {
      val customers = bankAccounts.holder.name.toLowerCase
      if (customers.contains(namePattern.toLowerCase)) {namn = namn :+ bankAccounts.holder}
    }
    namn
  }

  def doEvent(event: BankEvent): String = {

    saveString(HistoryEntry(Date.now(), event).toLogFormat + "\n", "minbank.txt")

    event match {
      case Deposit(account, amount) =>
        val rensad = tomBank.filter(bankAccount => bankAccount.accountNumber == account)
        if (rensad.nonEmpty) {
          for (bankAccount <- tomBank) {
            if (rensad(0).accountNumber == bankAccount.accountNumber) {
              bankAccount.accountBalace += amount
              tomHistory = tomHistory :+ HistoryEntry(Date.now(), Deposit(account, amount))
            }
          }
          println(s"Transaktionen lyckades \nNuvarande saldo: ${rensad(0).accountBalace}kr")
          Date.now().toNaturalFormat + event.toNaturalFormat
        }
        else println("Error: Kontonummer finns ej")
        "error"

      case Withdraw(account, amount) =>
        val rensad = tomBank.filter(bankAccount => bankAccount.accountNumber == account)

        if (rensad.nonEmpty) {
          for (bankAccount <- tomBank) {
            if (rensad(0).accountNumber == bankAccount.accountNumber) {
              if (bankAccount.withdraw(amount)) {
                bankAccount.accountBalace += -amount
                tomHistory = tomHistory :+ HistoryEntry(Date.now(), Withdraw(account, amount))
              }
              else println("Transaktionen misslyckades. Otillräckligt saldo. ")
            }
            println(s"Transaktionen lyckades \nNuvarande saldo: ${rensad(0).accountBalace}kr")
            Date.now().toNaturalFormat + Withdraw(account, amount).toNaturalFormat
          }
        }
        else println("Error; finns ej ett konto med detta nummer")
        "error"

      case Transfer(accFrom, accTo, amount) =>
        val rensadFrom = tomBank.filter(bankAccount => bankAccount.accountNumber == accFrom)
        val rensadTo = tomBank.filter(bankAccount => bankAccount.accountNumber == accTo)

        if (rensadFrom.nonEmpty && rensadTo.nonEmpty) {
          for (account <- tomBank) {
            if (rensadFrom(0).accountNumber == account.accountNumber) {
              if (account.withdraw(amount)) {
                account.accountBalace = account.accountBalace - amount
                tomHistory = tomHistory :+ HistoryEntry(Date.now(), bank.Transfer(accFrom, accTo, amount))
                println(s"\nTransaktionen lyckades \nNuvarande saldo: ${account.accountBalace}kr \n${rensadFrom(0)} ")
                Date.now().toNaturalFormat + event.toNaturalFormat
              }
              else println("Transaktionen misslyckades. Otillräckligt saldo. ")
              "error"
            }
            if (rensadTo(0).accountNumber == account.accountNumber) {
              account.accountBalace += amount
              println(s"\nNuvarande saldo: ${account.accountBalace}kr \n${rensadTo(0)} \n")
            }
          }
        }
        else println("Error; saknas konto med detta nummer")
        "error"

      case NewAccount(id, name) =>
        val newBankAccount = new BankAccount(Customer(name, id))

        tomBank = tomBank :+ newBankAccount
        tomHistory = tomHistory :+ HistoryEntry(Date.now(), bank.NewAccount(id, name))
        println(s"Nytt konto skapat med kontonummer: \n${newBankAccount.accountNumber}")
        event.toNaturalFormat

      case DeleteAccount(account) =>
        tomBank = tomBank.filterNot(bankAccount => bankAccount.accountNumber == account)
        Date.now().toNaturalFormat + event.toNaturalFormat
    }
  }

  def history(): Vector[HistoryEntry] = scala.io.Source.fromFile("minbank.txt").getLines().toVector.map(HistoryEntry.fromLogFormat)

  def returnToState(returnDate: Date): String = {

    val old = history().filter(_.date.compare(returnDate) < 0)
    val currentFile = new PrintWriter(new FileOutputStream(new File("minbank.txt"), false))
    currentFile.write("")
    saveString(old.toString(), "minbank.txt")

      for (o <- old) {
        doEvent(o.event)
      }

    "hej"
  }

}