package Particle;

use strict;
use warnings;

use Data::Dumper;
$Data::Dumper::Deepcopy = 1;
$Data::Dumper::Sortkeys = 1;

our %param;
our %REGISTRY;

sub new {
    my $class = shift;
    $param{is_movable} = 0;
    @{ $param{history} } = ();
    $param{position} = { x  => 0, y  => 0, z  => 0, };
    $param{movement} = { dx => 0, dy => 0, dz => 0, };
    $param{is_active} = 0;
    my $self = bless \%param, $class;
    if ( scalar @_ ) {
        $self->init(@_);
    }
    $REGISTRY{$self} = $self;

    # my $format_str = qq{Class: %s\n\tKey: %s\n\tref(): %s\n};
    #     my $t = ref( $REGISTRY{$self} );
    #     print sprintf $format_str, $class, $self, $t;

    return $self;
}

sub init {
    my $self = shift;
    my ($data) = @_;

    foreach my $k ( keys %{$data} ) {
        $self->set( $k, \$data->{$k} );
    }
}

sub get {
    my $self = shift;
    my $k    = shift;
    
    if ( $k =~ m/^p_?(.)/i ) {
        return $self->{position}{$1};
    }
    elsif ( $k =~ m/^m_?d?(.)/i or $k =~ m/^d(.)/i ) {
        return $self->{movement}{ q{d} . $1 };
    }
    elsif ( $k =~ m/^is_a/i ) {
        return $self->{is_active};
    }
    elsif ( $k =~ m/^is_m/i ) {
        return $self->{is_movable};
    }
    elsif ( $k =~ m/^h_?(\d+)/i ) {
        return $self->{history}[$1];
    }
    elsif ( $k =~ m/^hc/i ) {
        return scalar @{ $self->{history} };
    }
}

sub set {
    my $self = shift;
    my $k    = shift;
    if ( $k =~ m/^h_?self/i ) {
        push @{ $self->{history} }, 
            { 
                time => time, 
                position => \$self->{position}, 
                movement => \$self->{movement}, 
            };
        return;
    }
    my $v = shift;

    if ( ref $v eq q{REF} ) {
        if ( $k =~ m/^position/i ) {
            $self->{position} = $$v;
        }
        elsif ( ref $v eq q{REF} and $k =~ m/^movement/i ) {
            $self->{movement} = $$v;
        }
    }
    else {
        if ( $k =~ m/^p_?(.)/i ) {
            $self->{position}{$1} = $v;
        }
        elsif ( $k =~ m/^m_?d?(.)/i or $k =~ m/^d(.)/i ) {
            $self->{movement}{ q{d} . $1 } = $v;
        }
        elsif ( $k =~ m/^is_a/i ) {
            $self->{is_active} = $v;
        }
        elsif ( $k =~ m/^is_m/i ) {
            $self->{is_movable} = $v;
        }
        elsif ( $k =~ m/^h_?(\d+)/i ) {
            $self->{history}[$1] = $v;
        }
        elsif ( $k =~ m/^h/i ) {
            push @{ $self->{history} }, $v;
        }
    }
}

sub total_count {
    my $class = shift;

    print __FILE__, q{:}, __LINE__, q{ }, $class, qq{\n};
    # print Data::Dumper->Dump( 
    #                           [ \%REGISTRY, ], 
    #                           [ qw( *REGISTRY ) ] 
    #                       ), qq{\n};
    
    my $format_str = qq{Class: %s\n\tKey: %s\n\tref(): %s\n};
    foreach my $k ( keys %REGISTRY ) {
        my $t = ref( $REGISTRY{$k} );
        print sprintf $format_str, $class, $k, $t;
    }
	return 
        scalar 
        grep { ref( $REGISTRY{$_} ) eq $class } 
        keys %REGISTRY;
}

1;