use 5.008003;
use MooseX::Declare;

class Thread::Task::Handle {
    use TryCatch;

    use MooseX::Types::Moose qw(ClassName Int ArrayRef);
    use Thread::Task::Types qw(Handle_T Worker_T Task_T Finished_ET);
    use Thread::Task::Exception::Finished;
    use MooseX::MultiMethods;

    require Scalar::Util;

    our $SEQUENCE = 0;

    has hid => (
        isa => Int,
        is => 'ro',
        default => sub { ++$SEQUENCE },
    );

    has task => (
        isa => Task_T,
        is => 'ro',
        required => 1,
    );

    has execption => (
        is => 'ro',
        writer => '_set_exception',
        predicate => 'has_exception',
        init_arg => undef,
    );

    multi method BUILDARGS(ClassName $class: Task_T $task) {
        return $class->next::method({task=>$task});
    }

    method prepare() {
        try {
            $self->task->prepare;
        }
        catch (Finished_ET $e) {
            die $e;
        }
        catch {
            die Thread::Task::Exception::Finished->new(msg=>$@);
        }
    }

    method finish() {
        try {
            $self->task->finish;
        }
        catch (Finished_ET $e) {
            die $e;
        }
        catch {
            die Thread::Task::Exception::Finished->new(msg=>$@);
        }
    }

    method run() {
        try {
            $self->task->handle($self);
            $self->task->run;
            $self->task->clear_handle;
        }
        catch (Finished_ET $e) {
        }
        catch ($e) {
            $self->task->clear_handle;
            $self->_set_exception($e);
        }

        return;
    }

    method as_array() {
        return [
            $self->hid,
            $self->task->meta->name,
            $self->task->as_string,
        ];
    }

    method from_array(ClassName $class: ArrayRef $array) {
        my ($hid,$task_class,$task_serialized)=@$array;
        Class::MOP::load_class($task_class);

        return $class->new(
            hid=>$hid,
            task=>$task_class->from_string($task_serialized),
        );
    }

    method message(@message) {
        Thread::Task::Manager->instance->conduit->signal(
            Storable::nfreeze([$self->hid,@message])
          );
    }

    method on_message(Str $method, @args) {
        unless ($self->task->can($method)) {
            return;
        }

        try {
            $self->task->$method(@args);
        }
        catch {
            return;
        }
        return;
    }

    method started() {
        $self->message('__STARTED__');
    }

    method stopped() {
        $self->message('__STOPPED__',$self->task);
    }

    method on_stopped(Task_T $new_task, @args) {
        $self->task->_update($new_task);

        try {
            $self->task->finish(@args);
        }
        catch {
            return;
        }
        return;
    }
}

1;