package gitbucket.core.service

import gitbucket.core.model.{Account, GroupMember}
import java.util.Date
import org.scalatest.FunSuite

class AccountServiceSpec extends FunSuite with ServiceSpecBase {

  val RootMailAddress = "root@localhost"

  test("getAllUsers") {
    withTestDB { implicit session =>
      assert(AccountService.getAllUsers() match {
        case List(Account("root", "root", RootMailAddress, _, true, _, _, _, None, None, false, false, None)) => true
        case _                                                                                                => false
      })
    }
  }

  test("getAccountByUserName") {
    withTestDB { implicit session =>
      assert(AccountService.getAccountByUserName("root").get.userName == "root")
      assert(AccountService.getAccountByUserName("invalid user name").isEmpty)
    }
  }

  test("getAccountByMailAddress") {
    withTestDB { implicit session =>
      assert(AccountService.getAccountByMailAddress(RootMailAddress).isDefined)
    }
  }

  test("updateLastLoginDate") {
    withTestDB { implicit session =>
      val root = "root"
      def user() = AccountService.getAccountByUserName(root).getOrElse(sys.error(s"user $root does not exists"))

      assert(user().lastLoginDate.isEmpty)

      val date1 = new Date
      AccountService.updateLastLoginDate(root)
      assert(user().lastLoginDate.get.compareTo(date1) > 0)

      val date2 = new Date
      Thread.sleep(1000)
      AccountService.updateLastLoginDate(root)
      assert(user().lastLoginDate.get.compareTo(date2) > 0)
    }
  }

  test("updateAccount") {
    withTestDB { implicit session =>
      val root = "root"
      def user() = AccountService.getAccountByUserName(root).getOrElse(sys.error(s"user $root does not exists"))

      val newAddress = "new mail address"
      AccountService.updateAccount(user().copy(mailAddress = newAddress))
      assert(user().mailAddress == newAddress)

      val newUrl = Some("http://new.url.example/path")
      AccountService.updateAccount(user().copy(url = newUrl))
      assert(user().url == newUrl)

      val newDescription = Some("http://new.url.example/path")
      AccountService.updateAccount(user().copy(description = newDescription))
      assert(user().description == newDescription)
    }
  }

  test("group") {
    withTestDB { implicit session =>
      val group1 = "group1"
      val user1 = "root"
      AccountService.createGroup(group1, None, None)

      assert(AccountService.getGroupMembers(group1) == Nil)
      assert(AccountService.getGroupsByUserName(user1) == Nil)

      AccountService.updateGroupMembers(group1, List((user1, true)))

      assert(AccountService.getGroupMembers(group1) == List(GroupMember(group1, user1, true)))
      assert(AccountService.getGroupsByUserName(user1) == List(group1))

      AccountService.updateGroupMembers(group1, Nil)

      assert(AccountService.getGroupMembers(group1) == Nil)
      assert(AccountService.getGroupsByUserName(user1) == Nil)
    }
  }

  test("createGroup save description") {
    withTestDB { implicit session =>
      AccountService.createGroup("some-group", Some("some clever description"), None)
      val maybeGroup = AccountService.getAccountByUserName("some-group")

      assert(maybeGroup.flatMap(_.description) == Some("some clever description"))
    }
  }

  test("updateGroup save description") {
    withTestDB { implicit session =>
      AccountService.createGroup("a-group", None, None)

      AccountService.updateGroup("a-group", Some("new description"), None, false)

      val group = AccountService.getAccountByUserName("a-group")
      assert(group.flatMap(_.description) == Some("new description"))
    }
  }
}