package models

import externals.BCrypt
import play.db.anorm._;


class User (protected var _id: Int, protected var _email: String, protected var _name: String,
            protected var _password: String, protected var _permissions: Set[String]) extends ActiveModel {
    private val BCRYPT_WORK_FACTOR: Int = 6


    def id: Int = _id
    def id_=(v: Int) = { _id = v; _dirty = true}
    def email: String = _email
    def email_=(v: String) = { _email = v; _dirty = true }
    def name: String = _name
    def name_=(v: String) = { _name = v; _dirty = true }
    def permissions: Set[String] = _permissions


    def password_=(password: String) = {
        _password = BCrypt.hashpw(password, BCrypt.gensalt(BCRYPT_WORK_FACTOR))
        _dirty = true
    }
    def checkPassword(password: String): Boolean = {
        return BCrypt.checkpw(password, _password)
    }

    def hasPermission(permission: String): Boolean = _permissions.contains(permission)
    def grantPermission(permission: String) = {
        var _set = new scala.collection.immutable.HashSet[String]

        _permissions.foreach( p => { _set += p })
        _set += permission
        _permissions = _set.toSet[String]
        _dirty = true
    }
    def revokePermission(permission: String) = {
        var _set = new scala.collection.immutable.HashSet[String]

        _permissions.foreach( p => { if (p != permission) _set += p })
        _permissions = _set.toSet[String]
        _dirty = true
    }

    protected def insert(): Boolean = {
        var res = SQL(User.INSERT_USER).on("name" -> _name, "email" -> _email, "password" -> _password).execute()

        if (res == false)
            return false

        var getIdRow = SQL(User.GET_USER_ID_BY_EMAIL).on("email" -> _email).apply().head

        _id = getIdRow.get[Int]("id").get

        return storePermissions
    }
    protected def update(): Boolean = {
        var result = SQL(User.UPDATE_USER).on("name" -> _name, "email" -> _email, "password" -> _password).execute()

        if (result == false)
            return false

        return storePermissions
    }

    protected def storePermissions(): Boolean = {
        var q = new StringBuilder

        q append "START TRANSACTION;"

        q append User.REVOKE_ALL_PERMISSIONS + "\n"

        _permissions.foreach( p => {
            q append User.GRANT_PERMISSION.replace("{permission_name}", "\"" + p + "\"") + "\n"
        })

        q append "COMMIT;"

        return SQL(q.toString).on("user_id" -> _id).execute()
    }
}

object User {
    private val USER_TABLE: String = "users"
    private val USER_PERMISSIONS_TABLE: String = "user_permissions"

    private val GET_USER_BY_ID: String =
        "SELECT * FROM tbl WHERE id={id};".replace("tbl", USER_TABLE)
    private val GET_USER_ID_BY_EMAIL: String =
        "SELECT id FROM tbl WHERE email={email};".replace("tbl", USER_TABLE)
    private val GET_USER_PERMISSIONS: String =
        "SELECT * FROM tbl WHERE user_id={id};".replace("tbl", USER_PERMISSIONS_TABLE)

    private val INSERT_USER: String =
        "INSERT INTO tbl (name, email, password) VALUES ({name}, {email}, {password});".replace("tbl", USER_TABLE)

    private val UPDATE_USER: String =
        "UPDATE tbl SET name={name}, email={email}, password={password} WHERE id={id};".replace("tbl", USER_TABLE)

    private val GRANT_PERMISSION: String =
        "INSERT INTO tbl VALUES ( {user_id}, {permission_name});".replace("tbl", USER_PERMISSIONS_TABLE)
    private val REVOKE_PERMISSION: String =
        "DELETE FROM tbl WHERE user_id={user_id} AND permission_name = {permission_name};".replace("tbl", USER_PERMISSIONS_TABLE)
    private val REVOKE_ALL_PERMISSIONS: String =
        "DELETE FROM tbl WHERE user_id={user_id};".replace("tbl", USER_PERMISSIONS_TABLE)

    def getById(id: Int): User = {
        var query = SQL(GET_USER_BY_ID).on("id" -> id)
        var result = query.apply().head

        return createUserFromRow(result)
    }
    private def createUserFromRow(row: Row): User = {
        var id: Int = row.get[Int]("id").get
        var email: String = row.get[String]("email").get
        var name: String = row.get[String]("name").get
        var password: String = row.get[String]("password").get

        var permissions: Set[String] = getPermissionsById(id)

        return new User(id, email, name, password, permissions)
    }

    def getPermissionsById(id: Int): Set[String] = {
        var query = SQL(GET_USER_PERMISSIONS).on("id" -> id)

        var permSet = new scala.collection.mutable.HashSet[String]

        val permissions = query.apply().foreach(
            row => permSet.add(row.get[String]("permission_name").get)
        )

        return permSet.toSet[String]
    }
}