package Peace::DAO::Build;

use v5.30.0;

use strict;
use warnings;

use Params::ValidationCompiler qw/validation_for/;
use Types::Standard qw/HasMethods InstanceOf
        Str HashRef/;

use Peace::Model::Build;

{
    my $validator = validation_for(
        params => {
            dbh => { type => HasMethods ['selectrow_hashref'] },
        }
    );

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

{
    my $validator = validation_for(
        params => {
            build => { type => InstanceOf ['Peace::Model::Build'] },
        }
    );

    sub create {
        my $self   = shift;
        my %params = $validator->(@_);
        my $build  = $params{build};
        my $dbh    = $self->_dbh;

        my $insert = <<'EOF';
INSERT INTO builds (release, success, log,
    arch)
VALUES (?, ?, ?, ?)
RETURNING uuid;
EOF
        my $result =
          $dbh->selectrow_hashref( $insert, undef, $build->release->uuid,
            $build->success, $build->log, $build->arch );
        die "Couldn't create build." if !defined $result;
        my $uuid      = $result->{uuid};
        my $new_build = $self->recover_by_uuid( uuid => $uuid );
        $build->uuid( $new_build->uuid );
        $build->date_creation( $new_build->date_creation );
        return $build;
    }
}
{
    my $validator = validation_for(
        params => {
            uuid => { type => Str },
        }
    );

    sub recover_by_uuid {
        my $self   = shift;
        my %params = $validator->(@_);
        my $uuid   = $params{uuid};
        my $dbh    = $self->_dbh;
        my $result = $dbh->selectrow_hashref( <<'EOF', undef, $uuid );
SELECT uuid, date_creation,
    release, success, log, arch
FROM builds
WHERE uuid = ?;
EOF
        if ( !defined $result ) {
            die "Build with uuid $uuid not found.";
        }
        return $self->_select_result_to_build($result);
    }
}

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

    sub _select_result_to_build {
        my $self = shift;
        my ($result) = $validator->(@_);
        if ( exists $result->{release} ) {
            $result->{release_uuid} = delete $result->{release};
            $result->{dbh}            = $self->_dbh;
        }
        if ( exists $result->{date_creation} ) {
            my $iso8601 = DateTime::Format::Pg->new;
            $result->{date_creation} =
              $iso8601->parse_datetime( $result->{date_creation} );
        }
        my $release = Peace::Model::Build->new(%$result);
        return $release;
    }
}

sub _dbh {
    my $self = shift;
    return $self->{dbh};
}
1;
=encoding utf8

=head1 NAME

Peace::DAO::Build - Database access object of Peace::Model::Build.

=head1 SYNOPSIS

 my $build_dao = Peace::DAO::Build->new(
     dbh => $dbh,
 );

 my $build = $build_dao->recover_by_uuid(
     uuid => $uuid,
 );

 $build_dao->create( build => $build, );

=head1 DESCRIPTION

Peace::DAO::Build allows you to retrieve and create
the representation of L<Peace::Model::Build> in
the database table builds.

=head1 INSTANCE METHODS

Peace::DAO::Build implements the following instance
methods:

=head2 new

 my $build_dao = Peace::DAO::Build->new(
     dbh => $dbh
 );

Instances a Peace::DAO::Build object.

=head1 METHODS

Peace::DAO::Build implements the following methods:

=head2 recover_by_uuid

 my $build = $build_dao->recover_by_uuid( uuid => $uuid );

Recovers a L<Peace::Model::Build> from its uuid.

=head2 create

 $build_dao->create( build => $build );

Creates the database representation of a
L<Peace::Model::Build>.

=head1 SEE ALSO

L<Peace::Model::Build>, L<DBI>

=cut