package Sietima;
use 5.020;
use Moo;
use Types::Standard qw(ArrayRef Object FileHandle Maybe);
use Type::Params qw(compile);
use Sietima::Types qw(Address AddressFromStr
                      EmailMIME Message
                      Subscriber SubscriberFromAddress SubscriberFromStr
                      Transport);
use Sietima::Message;
use Sietima::Subscriber;
use Email::Sender::Simple qw();
use Email::Sender;
use Email::Address;
use namespace::clean;

has return_path => (
    isa => Address,
    is => 'ro',
    required => 1,
    coerce => AddressFromStr,
);

my $subscribers_array = ArrayRef[
    Subscriber->plus_coercions(
        SubscriberFromAddress,
        SubscriberFromStr,
    )
];
has subscribers => (
    isa => $subscribers_array,
    is => 'lazy',
    coerce => $subscribers_array->coercion,
);
sub _build_subscribers { +[] }

has transport => (
    isa => Transport,
    is => 'lazy',
);
sub _build_transport { Email::Sender::Simple->default_transport }

sub handle_mail {
    state $check = compile(Object,EmailMIME);
    my ($self,$incoming_mail) = $check->(@_);

    my (@outgoing_messages) = $self->munge_mail($incoming_mail);
    for my $outgoing_message (@outgoing_messages) {
        $self->send_message($outgoing_message);
    }
    return;
}

sub munge_mail {
    state $check = compile(Object,EmailMIME);
    my ($self,$incoming_mail) = $check->(@_);

    return Sietima::Message->new({
        mail => $incoming_mail,
        from => $self->return_path,
        to => [
            map { $_->address } @{$self->subscribers}
        ],
    });
}

sub send_message {
    state $check = compile(Object,Message);
    my ($self,$outgoing_message) = $check->(@_);

    my $envelope = $outgoing_message->envelope;
    if ($envelope->{to} && @{$envelope->{to}}) {
        $self->transport->send(
            $outgoing_message->mail,
            $envelope,
        );
    }

    return;
}

1;