package controllers

import play.api._
import play.api.data._
import play.api.data.Forms._
import play.api.mvc._

import play.api.db.slick._
import play.api.db.slick.Config.driver.simple._
import play.api.Play.current

import scala.concurrent.Future

import models._


case class AuthRequest[A](account: Option[Views.Account] = None, request: Request[A]) extends WrappedRequest(request)

object Auth extends ActionBuilder[AuthRequest] {

  def invokeBlock[A](request: Request[A], block: (AuthRequest[A]) => Future[Result]) = DB.withSession { implicit session =>
    val uuid = request.session.get(Security.username)
    var account: Option[Views.Account] = None

    if (uuid.nonEmpty) {
      val resultSet = Views.Accounts.filter(_.userUuid === uuid).run
      if (resultSet.nonEmpty) {
        account = Some(resultSet.head)
      }
    }

    block(AuthRequest(account, request))
  }

}


case class LoginData(username: String, password: String)

object Authentication extends Controller {

  val loginForm = Form(
    mapping(
      "username" -> nonEmptyText,
      "password" -> nonEmptyText
    )(LoginData.apply)(LoginData.unapply)
      verifying("Log in failed.", fields => fields match {
      case loginData => checkLoginData(loginData.username, loginData.password)
    })
  )

  def checkLoginData(username: String, password: String) = DB.withSession { implicit session =>
    Tables.Users.filter(u => u.username === username && u.userPassword === password).length.run > 0
  }


  def login = Auth { implicit request =>
    if (request.account.isEmpty) {
      Ok(views.html.pages.auth.loginForm(loginForm))
    } else {
      Redirect(routes.Application.index())
    }
  }

  def loginSubmit = Auth { implicit request =>
    DB.withSession { implicit session =>
      loginForm.bindFromRequest.fold(
        formWithErrors => {
          BadRequest(views.html.pages.auth.loginForm(formWithErrors))
        },
        validForm => {
          val userUuid: String = Tables.Users.filter(_.username === validForm.username).map(_.uuid).first.run

          Redirect(routes.Application.index())
            .withSession(Security.username -> userUuid)
            .flashing(("success", "Welcome, valuable user!"))
        }
      )
    }
  }

  def logout = Auth { implicit request =>
    if (request.account.nonEmpty) {
      Redirect(routes.Application.index())
        .withNewSession
        .flashing("success" -> "You are now logged out. Do not go to our competitor's website. Thanks.")
    } else {
      Redirect(routes.Application.index())
    }
  }

}