package DBD::Mock::StatementTrack;
use strict;
use warnings;
use List::Util qw( reduce );
sub new {
    my ( $class, %params ) = @_;
    # these params have default values
    # but can be overridden
    $params{return_data}        ||= [];
    $params{fields}             ||= $DBD::Mock::DefaultFieldsToUndef ? undef : [];
    $params{bound_params}       ||= [];
    $params{bound_param_attrs}  ||= [];
    $params{statement}          ||= "";
    $params{failure}            ||= undef;
    $params{callback}           ||= undef;
    $params{driver_attributes}  ||= {};
    $params{execute_attributes} ||= {};
    # these params should never be overridden
    # and should always start out in a default
    # state to assure the sanity of this class
    $params{is_executed}        = 'no';
    $params{is_finished}        = 'no';
    $params{current_record_num} = 0;
    # NOTE:
    # changed from \%params here because that
    # would bind the hash sent in so that it
    # would reflect alterations in the object
    # this violates encapsulation
    my $self = bless {%params}, $class;
    return $self;
}
sub has_failure {
    my ($self) = @_;
    $self->{failure} ? 1 : 0;
}
sub get_failure {
    my ($self) = @_;
    @{ $self->{failure} };
}
sub num_fields {
    my ($self) = @_;
    return $self->{fields} ? scalar @{ $self->{fields} } : $self->{fields};
}
sub num_rows {
    my ($self) = @_;
    return scalar @{ $self->{return_data} };
}
sub num_params {
    my ($self) = @_;
    return scalar @{ $self->{bound_params} };
}
sub bind_col {
    my ( $self, $param_num, $ref ) = @_;
    $self->{bind_cols}->[ $param_num - 1 ] = $ref;
}
sub bound_param {
    my ( $self, $param_num, $value, $attr ) = @_;
    # Basic support for named parameters
    if ( $param_num !~ /^\d+/ ) {
        $param_num = $self->num_params + 1;
    }
    $self->{bound_params}->[ $param_num - 1 ] = $value;
    $self->{bound_param_attrs}->[ $param_num - 1 ] = ref $attr eq "HASH" ? { %$attr } : $attr;
    return $self->bound_params;
}
sub bound_param_trailing {
    my ( $self, @values ) = @_;
    push @{ $self->{bound_params} }, @values;
}
sub bind_cols {
    my $self = shift;
    return @{ $self->{bind_cols} || [] };
}
sub bind_params {
    my ( $self, @values ) = @_;
    @{ $self->{bound_params} } = @values;
    @{ $self->{bound_param_attrs} } = map { undef } @values;
}
# Rely on the DBI's notion of Active: a statement is active if it's
# currently in a SELECT and has more records to fetch
sub is_active {
    my ($self) = @_;
    return 0 unless $self->statement =~ /^\s*select/ism;
    return 0 unless $self->is_executed eq 'yes';
    return 0 if $self->is_depleted;
    return 1;
}
sub is_finished {
    my ( $self, $value ) = @_;
    if ( defined $value && $value eq 'yes' ) {
        $self->{is_finished} = 'yes';
        $self->current_record_num(0);
        $self->{return_data} = [];
    }
    elsif ( defined $value ) {
        $self->{is_finished} = 'no';
    }
    return $self->{is_finished};
}
####################
# RETURN VALUES
sub mark_executed {
    my ($self) = @_;
    push @{$self->{execution_history} }, {
        params => [ @{ $self->{bound_params} } ],
        attrs  => [ @{ $self->{bound_param_attrs} } ],
    };
    $self->is_executed('yes');
    $self->current_record_num(0);
    $self->{driver_attributes} = { %{ $self->{driver_attributes} }, %{ $self->{execute_attributes} } };
    if (ref $self->{callback} eq "CODE") {
        my %recordSet = $self->{callback}->(@{ $self->{bound_params} });
        if (ref $recordSet{fields} eq "ARRAY") {
            $self->{fields} = $recordSet{fields};
        }
        if (ref $recordSet{rows} eq "ARRAY") {
            die "DBD::Mock error - a resultset's callback should return rows as an arrayref of arrayrefs" if reduce { ref $b ne "ARRAY" ? 1 : $a } 0, @{ $recordSet{rows} };
            $self->{return_data} = $recordSet{rows};
        }
        if (defined $recordSet{last_insert_id}) {
            $self->{last_insert_id} = $recordSet{last_insert_id};
        }
        if (defined $recordSet{execute_attributes}) {
            $self->{driver_attributes} = { %{ $self->{driver_attributes} }, %{ $recordSet{execute_attributes} } };
        }
    }
}
sub next_record {
    my ($self) = @_;
    return if $self->is_depleted;
    my $rec_num = $self->current_record_num;
    my $rec     = $self->return_data->[$rec_num];
    $self->current_record_num( $rec_num + 1 );
    return $rec;
}
sub is_depleted {
    my ($self) = @_;
    return ( $self->current_record_num >= scalar @{ $self->return_data } );
}
# DEBUGGING AID
sub to_string {
    my ($self) = @_;
    return join "\n" => (
        $self->{statement},
        "Values: [" . join( '] [', @{ $self->{bound_params} } ) . "]",
        "Records: on $self->{current_record_num} of "
          . scalar( @{ $self->return_data } ) . "\n",
        "Executed? $self->{is_executed}; Finished? $self->{is_finished}"
    );
}
# PROPERTIES
# boolean
sub is_executed {
    my ( $self, $yes_no ) = @_;
    $self->{is_executed} = $yes_no if defined $yes_no;
    return ( $self->{is_executed} eq 'yes' ) ? 'yes' : 'no';
}
# single-element fields
sub statement {
    my ( $self, $value ) = @_;
    $self->{statement} = $value if defined $value;
    return $self->{statement};
}
sub current_record_num {
    my ( $self, $value ) = @_;
    $self->{current_record_num} = $value if defined $value;
    return $self->{current_record_num};
}
sub callback {
    my ( $self, $callback ) = @_;
    $self->{callback} = $callback if defined $callback;
    return $self->{callback};
}
# multi-element fields
sub return_data {
    my ( $self, @values ) = @_;
    push @{ $self->{return_data} }, @values if scalar @values;
    return $self->{return_data};
}
sub fields {
    my ( $self, @values ) = @_;
    $self->{fields} ||= [];
    push @{ $self->{fields} }, @values if scalar @values;
    return $self->{fields};
}
sub bound_params {
    my ( $self, @values ) = @_;
    push @{ $self->{bound_params} }, @values if scalar @values;
    return $self->{bound_params};
}
sub bound_param_attrs {
    my ( $self, @values ) = @_;
    push @{ $self->{bound_param_attrs} }, @values if scalar @values;
    return $self->{bound_param_attrs};
}
sub execution_history {
    my ( $self, @values ) = @_;
    push @{ $self->{execution_history} }, @values if scalar @values;
    return $self->{execution_history};
}
1;