package GCE::ArchRef;
use strict;
=head1 NAME

   GCE::ArchRef - a intelligent reference to an arch instance on/in the map

=head1 SYNOPSIS

   GCE::ArchRef->new (...);

=over 4

=cut

use Storable qw/dclone/;
use Deliantra;
use Carp;
use GCE::Util;

sub getarch {
   my ($self, $rw) = @_;

   my $arch;

   if ($self->{map}) {
      $arch =
         $rw
            ? $self->{map}->{map}->get    ($self->{x}, $self->{y})
            : $self->{map}->{map}->get_ro ($self->{x}, $self->{y});

      $self->{last_got_mapspace} = $rw ? $arch : undef;

      $self->{z} = -1 unless defined $self->{z};

      $arch = $arch->[$self->{z}];

      for (@{$self->{inv} || []}) {
         $arch = $arch->{inventory}->[$_];
      }

      unless (defined $arch) {
         die "bad arch cursor: $self->{x}, $self->{y}, $self->{z}, "
             . join (@{$self->{inv} || []})
             . " \n";
      }

   } else {
      $arch = $self->{arch};
   }

   unless (defined $Deliantra::ARCH{$arch->{_name}}) {
      quick_msg (
         $::MAINWIN,
         "ERROR: No such archetype '" . ($arch->{_name})
         ."' replacing it's type with 'empty_archetype'.",
         0
      );
   }

   $arch
}

sub commit_last_got_arch {
   my ($self, $change) = @_;
   return unless defined $self->{last_got_mapspace};

   my $map = $self->{map};

   return unless defined $map;

   $map = $map->{map};

   $map->change_begin (($change || 'unknown_edit') . ' on ' . $self);

   $map->change_stack ($self->{x}, $self->{y}, $self->{last_got_mapspace});

   if (my $changeset = $map->change_end) {
      my $undo_stack = ($map->{undo_stack} ||= []);

      my $str_self = "$self";

      if ($undo_stack->[$map->{undo_stack_pos} - 1]->{title}
             =~ /^attribute_edit:.*? on \Q$str_self\E$/) {
         $map->{undo_stack_pos}--;

         warn "merged change ($changeset->{title})\n";
      } else {
         warn "added change ($changeset->{title})\n";
      }

      splice @{ $map->{undo_stack} ||= [] },
             $map->{undo_stack_pos}++, 1e6,
             $changeset;
   }

   $::MAINWIN->broadcast_cursor_changes ($self->{map}, $self->{x}, $self->{y});
}

sub new {
   my $class = shift;
   my $self = { @_ };
   bless $self, $class;

   unless (defined ($self->{arch}) || defined ($self->{map})) {
      Carp::confess ("arch not defined when making new ArchRef")
   }

   $self->getarch;

   return $self;
}

sub type {
   my ($self) = @_;
   Deliantra::arch_attr $self->getarch;
}

sub archetype {
   my ($self) = @_;

   $Deliantra::ARCH{$self->getarch->{_name}} || $Deliantra::ARCH{empty_archetype};
}

sub picker_folder {
   my ($self) = @_;
   my $folder = $self->archetype->{editor_folder};
   my @a = split /\//, $folder;
   $a[0]
}

sub longname {
   my ($self) = @_;

   my $name = $self->get ('_name');
   my $rname = $self->get ('name');
   my $t = $self->type;

   $name . ($rname ? " - $rname" : "") . " ($t->{name})"
}

sub field_value_is_default {
   my ($self, $key, $val) = @_;
   my $al_arch = $self->archetype;

   # XXX: Was '... and $val', does this fix problems?
   (defined ($al_arch->{$key}) && $al_arch->{$key} ne $val)
      || (not (defined $al_arch->{$key}) and $val)
}

sub add_inv {
   my ($self, $arch) = @_;

   my $arch = $self->getarch (1);

   push @{$self->{arch}->{inventory}}, dclone (getarch $arch);

   $self->commit_last_got_arch ('add_inventory');
}

sub swap_inv {
   my ($self, $swapidx, $ownidx) = @_;

   my $arch = $self->getarch (1);

   my $inv = $arch->{inventory};

   ($inv->[$swapidx], $inv->[$ownidx])
      = ($inv->[$ownidx], $inv->[$swapidx]);

   $self->commit_last_got_arch ('swap_inventory');
}

#sub get_inv_refs {
#   my ($self) = @_;
#
#   my $cb = sub {
#      $self->{cb}->($self)
#         if defined $self->{cb};
#
#      $self->exec_change_cbs (qw/inventory/);
#   };
#
#   [ map { GCE::ArchRef->new (arch => $_, source => 'inventory', cb => $cb) } @{$self->get ('inventory') || []} ]
#}

sub replace_inv {
   my ($self, $idx, $new) = @_;

   my $arch = $self->getarch (1);

   splice @{$arch->{'inventory'}}, $idx, 1, $new;

   $self->commit_last_got_arch ('replace_inventory');
}

sub remove_inv {
   my ($self, $idx) = @_;

   my $arch = $self->getarch (1);

   splice @{$arch->{'inventory'}}, $idx, 1;

   $self->commit_last_got_arch ('remove_inventory');
}

sub reset_to_defaults {
   my ($self) = @_;

   my $arch = $self->getarch (1);

   for (keys %$arch) {
      delete $arch->{$_} if $_ ne '_name'
   }

   $self->commit_last_got_arch ('reset_to_defaults');
}

sub get {
   my ($self, $key) = @_;
   $self->getarch->{$key}
}

sub get_or_default {
   my ($self, $key) = @_;
   def ($self->get ($key), $self->archetype->{$key})
}

sub set {
   my ($self, $key, $value, $type) = @_;

   my $arch = $self->getarch (1);
   my $al_arch = $self->archetype;

   if (ref $value) {
      $arch->{$key} = $value;

   } else {
      if (not defined $al_arch->{$key}) {
         if ((not defined $value) || $value eq ''
             || ($type eq 'bool' && $value eq '0')) {
            # try to normalize
            delete $arch->{$key};
         } else {
            # try to normalize
            $arch->{$key} = $value;
         }
      } else {
         if ($al_arch->{$key} ne $value) {
            $arch->{$key} = $value;
         } else {
            # try to normalize
            delete $arch->{$key};
         }
      }
   }

   $self->commit_last_got_arch ('attribute_edit:' . $key);
}

=head1 AUTHOR

 Marc Lehmann <schmorp@schmorp.de>
 http://home.schmorp.de/

 Robin Redeker <elmex@ta-sa.org>
 http://www.ta-sa.org/

=cut
1;