import Vapor
import Auth
import Turnstile
import TurnstileCrypto

final class User: Model{
    var id: Node?
    var name: String?
    var exists: Bool = false
    var username: String
    var password: String

    enum Error: Swift.Error {
        case userNotFound
        case registerNotSupported
        case unsupportedCredentials
    }

    init(credentials: UsernamePassword){
        self.username = credentials.username
        self.password = BCrypt.hash(password: credentials.password)
    }


    init(node: Node, in context: Context) throws {
        self.id = nil
        self.name = try node.extract("name")
        self.username = try node.extract("username")
        self.password = try node.extract("password")


    }

    func makeNode(context: Context) throws -> Node {
        return try Node(node: [
            "id": id,
            "name": name,
            "username": username,
            "password": password
        ])
    }

    static func prepare(_ database: Database) throws {
        try database.create("users"){ users in
            users.id()
            users.string("name", optional:true)
            users.string("password")
            users.string("username")
        }
    }

    static func revert(_ database: Database) throws {
        try database.delete("users")
    }
}

import Auth

extension User: Auth.User {



    static func register(credentials: Credentials) throws -> Auth.User {
        var newUser: User

        switch credentials {
            case let credentials as UsernamePassword:
                newUser = User(credentials: credentials)
                print(newUser)
            default:
                let type1 = type(of: credentials)

                throw Abort.custom(status: .forbidden, message: "Unsupported credential type: \(type1).")
        }

        if try User.query().filter("username", newUser.username).first() == nil {
            print(newUser.username)

            try newUser.save()
            return newUser
        } else {
            throw AccountTakenError()
        }

    }

    static func authenticate(credentials: Credentials) throws -> Auth.User {
        var user: User?
        switch credentials {
             case let credentials as UsernamePassword:
                let fetchedUser = try User.query()
                    .filter("username", credentials.username)
                    .first()
                if let password = fetchedUser?.password,
                    password != "",
                    (try? BCrypt.verify(password: credentials.password, matchesHash: password)) == true {
                    user = fetchedUser

                    print(fetchedUser!.username)
                    print("gggg")
                }
            case let credentials as Identifier:
                user = try User.find(credentials.id)

            default:
                throw UnsupportedCredentialsError()
        }



        guard let u = user else {
            throw Abort.custom(status: .badRequest, message: "User not found")
        }
        print(u.username)
        return u
    }




}

import HTTP

extension Request {
    func user() throws -> User {
        guard let user = try auth.user() as? User else {
            throw Abort.custom(status: .badRequest, message: "Invalid user type.")
        }

        return user
    }

}