package com.example.user.slick.services

import javax.inject._
import scala.concurrent.ExecutionContext
// import slick.jdbc.JdbcProfile
import slick.jdbc.JdbcBackend.Database
import scala.concurrent.Future
import com.example.models._
import com.example.user.slick.dbios.SlickLibraryDbio
import com.example.services.LibraryService
// import slick.jdbc.H2Profile.api._

@Singleton
class SlickLibraryService @Inject() (
    db: Database,
    libraryDbio: SlickLibraryDbio
)(implicit ec: ExecutionContext)
    extends LibraryService {
  import libraryDbio.profile.api._

  override def getAuthorsForBook(id: Long): Future[Seq[(Author, Book)]] = {
    db.run {
      libraryDbio
        .getAuthorsForBook(id)
        .map(_.map {
          case (x, y) => {
            (libraryDbio.authorsRowToAuthor(x), libraryDbio.booksRowToBooks(y))
          }
        })
    }
  }

  // Simple function that returns a book
  def findBookById(id: Long): Future[Option[Book]] =
    db.run(libraryDbio.findBookById(id).map(_.map(libraryDbio.booksRowToBooks)))

  // Simple function that returns a list of books with it's author
  def findBooksWithAuthor: Future[Seq[(Book, Author)]] =
    db.run(libraryDbio.findBooksWithAuthor.map { lst =>
      lst.map(tup => {
        val (x, y) = tup
        (libraryDbio.booksRowToBooks(x), libraryDbio.authorsRowToAuthor(y))
      })
    })

  // Insert a book and an author composing two DBIOs in a transaction
  def insertBookAndAuthor(
      book: NewBook,
      author: NewAuthor
  ): Future[(Long, Long)] = {
    val action = for {
      authorId <- libraryDbio.insertAuthor2(author)
      bookId <- libraryDbio.insertBook2(book.copy(authorId = authorId))
    } yield (
      // libraryDbio.booksRowToBooks(book),
      // libraryDbio.authorsRowToAuthor(author)
      bookId,
      authorId
    )
    db.run(action.transactionally)
  }

  def findBookById2(id: Long) =
    db.run(libraryDbio.findBookById(id).map(_.map(_.title)))

}
case class Book2(title: String)