package Protocol::Modbus::Response;
use strict;
use warnings;
use overload '""' => \&stringify;
use overload 'eq' => \=
use Protocol::Modbus::Exception;
use Carp;
our @in    = ();
our @coils = ();
sub equals {
    my ($x, $y) = @_;
    $x->stringify() eq $y->stringify();    # or "$x" == "$y"
}
#
# `frame' is required when calling constructor
#
sub new {
    my ($obj, %args) = @_;
    my $class = ref($obj) || $obj;
    $args{pdu} ||= $args{frame};
    my $self = {_options => {%args},};
    bless $self, $class;
}
sub stringify {
    my $self = $_[0];
    my $cRes = 'Modbus generic response';
    if ($self->{_function}) {
        $cRes = 'Modbus response (func=%s, address=%s, value=%s)';
        $cRes = sprintf($cRes, $self->{_function}, $self->{_address}, $self->{_value});
    }
    return ($cRes);
}
# Frame is the entire packet stream received from transport
sub frame {
    my $self = shift;
    if (@_) {
        $self->{_options}->{frame} = $_[0];
    }
    return ($self->{_options}->{frame});
}
# PDU is the "Pure" Modbus packet without transport headers
sub pdu {
    my $self = shift;
    if (@_) {
        $self->{_options}->{pdu} = $_[0];
    }
    return ($self->{_options}->{pdu});
}
sub process {
    my ($self, $pdu) = @_;
    # If binary packets not supplied, take them from constructor options ('frame')
    $pdu ||= $self->pdu();
    #warn('Parsing binary data [', unpack('H*', $pdu), ']');
    my $excep = 0;     # Modbus exception flag
    my $error = 0;     # Error in parsing response
    my $count = 0;     # How many bytes in response
    my @bytes = ();    # Hold response bytes
    # Get function code (only first char)
    my $func = ord substr($pdu, 0, 1);
    # Check if there was an exception (msb on)
    if ($func & 0x80) {
        # Yes, exception for function $func - 0x80
        $func -= 0x80;
        $excep = ord substr($pdu, 1, 1);
    }
    # There was an exception response. Throw exception!
    if ($excep > 0) {
        warn('Throw exception func=', $func, ' code=', $excep);
        return (throw Protocol::Modbus::Exception(function => $func, code => $excep));
    }
    #
    # Normal response
    # Decode bytes that arrived
    #
    if ($func == &Protocol::Modbus::FUNC_READ_COILS) {
        $count = ord substr($pdu, 1, 1);
        @bytes = split //, substr($pdu, 2);
        @coils = ();
        for (@bytes) {
            $_ = unpack('B*', $_);
            $_ = reverse;
            push @coils, split //;
        }
        $self->{_coils} = \@coils;
    }
    elsif ($func == &Protocol::Modbus::FUNC_READ_INPUTS) {
        $count = ord substr($pdu, 1, 1);
        @bytes = split //, substr($pdu, 2);
        @in = ();
        for (@bytes) {
            $_ = unpack('B*', $_);
            $_ = reverse;
            push @in, split //;
        }
        $self->{_inputs} = \@in;
    }
    elsif ($func == &Protocol::Modbus::FUNC_WRITE_COIL
        || $func == &Protocol::Modbus::FUNC_WRITE_REGISTER)
    {
        $self->{_function} = $func;
        $self->{_address}  = unpack 'n', substr($pdu, 1, 2);
        $self->{_value}    = unpack 'n', substr($pdu, 3, 2);
    }
    elsif ($func == &Protocol::Modbus::FUNC_READ_HOLD_REGISTERS) {
        $count = ord substr($pdu, 1, 1);
        @bytes = split //, substr($pdu, 2);
        @in = ();
        for (@bytes) {
            push @in, unpack('H*', $_);
        }
        $self->{_registers} = \@in;
    }
    return ($self);
}
sub coils {
    $_[0]->{_coils};
}
sub inputs {
    $_[0]->{_inputs};
}
sub registers {
    $_[0]->{_registers};
}
# Given function code, return response structure
sub structure {
    my ($self, $func) = @_;
    my @tokens = ();
    if (   $func == &Protocol::Modbus::FUNC_READ_COILS
        || $func == &Protocol::Modbus::FUNC_READ_INPUTS)
    {
        @tokens = (&Protocol::Modbus::PARAM_COUNT, &Protocol::Modbus::PARAM_STATUS_LIST,);
    }
    elsif ($func == &Protocol::Modbus::FUNC_READ_HOLD_REGISTERS
        || $func == &Protocol::Modbus::FUNC_READ_INPUT_REGISTERS)
    {
        @tokens =
            (&Protocol::Modbus::PARAM_COUNT, &Protocol::Modbus::PARAM_REGISTER_LIST,);
    }
    else {
        croak('UNIMPLEMENTED RESPONSE');
    }
    return (@tokens);
}
1;