package BeastBB::Model::User;

use 5.32.1;

use strict;
use warnings;

use Params::ValidationCompiler 'validation_for';
use Types::Standard qw/Str Bool Int/;

use BeastBB::Types qw/$MATRIX_ADDRESS_TYPE IsClassTypeGenerator/;
use BeastBB::Response;
use Crypt::Bcrypt::Easy;

{
    my $validator = validation_for(
        params => {
            id_user => { type => Int, optional => 1 },
            group   => {
                type     => IsClassTypeGenerator('BeastBB::Model::Group'),
                optional => 1
            },
            username        => { type => Str },
            matrix_address  => { type => Str },
            password_bcrypt => { type => Str },
            is_confirmed    => { type => Bool, default => 0 },
            creation_date   => {
                type    => IsClassTypeGenerator('DateTime'),
                default => sub { return DateTime->now }
            },
            last_connection => {
                type    => IsClassTypeGenerator('DateTime'),
                default => sub { return DateTime->now }
            },
        }
    );

    sub new {
        my $class  = shift;
        my %params = $validator->(@_);
        return bless \%params, $class;
    }
}

sub Hash {
    my $self = shift;
    return {
        (
              ( !$self->IdUser->IsError )
            ? ( id_user => $self->IdUser->Content )
            : ()
        ),
        (
              ( !$self->Group->IsError )
            ? ( group => $self->Group->Content->Hash )
            : ()
        ),
        username        => $self->Username,
        matrix_address  => $self->MatrixAddress,
        password_bcrypt => $self->PasswordBcrypt,
        is_confirmed    => $self->IsConfirmed,
        creation_date   => $self->CreationDate,
        last_connection => $self->LastConnection,
    };
}

{
    my $validator = validation_for(
        params => [
            {
                type     => IsClassTypeGenerator('BeastBB::Model::Group'),
                optional => 1
            },
        ]
    );

    sub Group {
        my $self = shift;
        @_ = $validator->(@_);

        if (@_) {
            $self->{group} = shift;
        }

        if ( !defined $self->{group} ) {
            return BeastBB::Response->new(
                is_error      => 1,
                error_message => 'No group recovered for this user.',
            );
        }
        return BeastBB::Response->new(
            content => $self->{group},
        );
    }
}

sub IdUser {
    my $self    = shift;
    my $id_user = $self->{id_user};
    return BeastBB::Response->new(
        is_error      => 1,
        error_message => 'Id user not set for this user model.'
    ) if !defined $id_user;
    return BeastBB::Response->new( content => $self->{id_user} );
}

{
    my $validator = validation_for(
        params => [
            { type => Int },
        ]
    );

    sub SetIdUser {
        my $self = shift;
        @_ = $validator->(@_);
        $self->{id_user} = shift;
    }
}

sub Username {
    my $self = shift;
    return $self->{username};
}

{
    my $validator =
      validation_for(
        params => [ { type => $MATRIX_ADDRESS_TYPE, optional => 1 } ] );

    sub MatrixAddress {
        my $self = shift;
        @_ = $validator->(@_);
        if (@_) {
            $self->{matrix_address} = shift;
        }
        return $self->{matrix_address};
    }
}

{
    my $validator = validation_for(
        params => [
            {
                type     => Str,
                optional => 1
            }
        ]
    );

    sub PasswordBcrypt {
        my $self = shift;
        @_ = $validator->(@_);
        if (@_) {
            $self->{password_bcrypt} = shift;
        }
        return $self->{password_bcrypt};
    }
}

{
    my $validator = validation_for(
        params => [
            {
                type     => Bool,
                optional => 1
            },
        ]
    );

    sub IsConfirmed {
        my $self = shift;
        @_ = $validator->(@_);
        if (@_) {
            $self->{is_confirmed} = shift;
        }
        return $self->{is_confirmed};
    }
}

{
    my $validator = validation_for(
        params => [
            {
                type     => IsClassTypeGenerator('DateTime'),
                optional => 1
            }
        ],
    );

    sub CreationDate {
        my $self = shift;
        if (@_) {
            $self->{creation_date} = shift;
        }
        return $self->{creation_date};
    }
}

{
    my $validator = validation_for(
        params => [
            {
                type     => IsClassTypeGenerator('DateTime'),
                optional => 1
            }
        ],
    );

    sub LastConnection {
        my $self = shift;
        if (@_) {
            $self->{last_connection} = shift;
        }
        return $self->{last_connection};
    }
}

{
    my $validator = validation_for(
        params => {
            password => { type => Str },
        }
    );

    sub CheckPasswordLogin {
        my $self     = shift;
        my %params   = $validator->(@_);
        my $password = $params{password};
        return bcrypt->compare( text => $password,
            crypt => $self->PasswordBcrypt );
    }
}
1;