package DoctorKarma::Model::User;

use v5.30.0;

use strict;
use warnings;

use Types::Standard qw/Str Int InstanceOf/;
use Params::ValidationCompiler qw(validation_for);

use DateTime;

{
    my $validator = validation_for(
        params => {
            id_user               => { type => Int },
            username              => { type => Str, optional => 1 },
            first_name            => { type => Str, optional => 1 },
            karma                 => { type => Int },
            last_karma_given_date =>
              { type => InstanceOf ['DateTime'], optional => 1 },
        }
    );

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

sub can_modify_karma {
    my $self                  = shift;
    my $last_karma_given_date = $self->last_karma_given_date;
    if ( !defined $last_karma_given_date ) {
        return 1;
    }
    return DateTime->now >
      $self->last_karma_given_date->clone->add( minutes => 1 );
}

sub first_name {
    my $self = shift;
    if ( exists $self->{first_name} ) {
        return $self->{first_name};
    }
    return undef;
}

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

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

    sub username {
        my $self = shift;
        my ($new_username) = $validator->(@_);
        if ( defined $new_username ) {
            $self->{username} = $new_username;
        }
        if ( exists $self->{username} ) {
            return $self->{username};
        }
        return undef;
    }
}

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

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

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

    sub karma {
        my $self = shift;
        my ($new_karma) = $validator->(@_);
        if ( defined $new_karma ) {
            $self->{karma} = $new_karma;
        }
        return $self->{karma};
    }
}
1;