#!/Perl/bin/perl

use strict;
use warnings;
use Data::Dumper qw/Dumper/;
$Data::Dumper::Sortkeys = 1;

$HASH::Update::beiArrayMitUngleichenElementenAlterDatensatz = 0;

my $alt = {
    key1 => "Ich bin immer noch da",
    key2 => "Ich werde ersatzlos gestrichen",
    key3 => { 
        "key3-1" => "Ich bin immer noch da"
    },
    key4 => [qw(Ich werde ersatzlos gestrichen)],
    key7 => [qw(Ich bin immer noch da)],
    key8 => ['alt', 'scalar', {'alt_hash' => 'alt_value'}, ],
};

my $neu = {
    key1 => "Ich werde überschrieben",
    key3 => { 
        "key3-1" => "Ich werde überschrieben", 
        "key3-2" => "Ich bin neu dazugekommen"
    },
    key5 => "Ich bin neu dazugekommen",
    key6 => [qw (Ich bin neu dazu gekommen)],
    key7 => [qw (Ich werde überschrieben)],
    key8 => [qw(neu scalar scalar)],
};

sub hash_update {
    # $_[0] = alt; $_[1] = neu;
    #my $alt = shift;
    #my $neu = shift; # alles in der Referenz ändern!
    
    # Für Rekursion: stimmen die übergebenen Datenstrukturen nicht überin
    # so wird in der neuen Datensturkur nichts geändert.
    return unless ref $_[0] eq ref $_[1];
    
    # Ist es ein Skalar? Ein Array? Ein Hash?
    
    if( ref $_[1] eq "HASH" ) {
        # Es ist ein Arschloch - äh, nein, ein Hash.
        # Alle Werte im neuen Hash sollen mit den Werten aus
        # dem alten Hash geupdated werden, wenn sie dort mit
        # dem gleichen Schlüssel und in gleicher Form
        # (Datenstruktur) vorliegen.
        
        foreach my $s_neu ( keys %{$_[1]} ) {
            # Gibt es den Schlüssel im alten Hash?
            if( exists $_[0]->{$s_neu}
               # ist es die Gleiche Datenstruktur?
               # Wenn nicht soll die neue übernommen werden.
               and ref $_[0]->{$s_neu} eq ref $_[1]->{$s_neu} ) {
                
                # Rekursuion...
                #print "hash: rekursion mit $s_neu\n";
                hash_update($_[0]->{$s_neu}, $_[1]->{$s_neu});
                
            }
        }
        
    }elsif( ref $_[1] eq "ARRAY" ) {
        # Es ist ein Array. Durchlaufe alle Einträge ud prüfe, ob die
        # alte Datenstruktur mit der neuen übereinstimmt.
        
        # Ist die Datenstruktur gleich, dann Rekursion mit allen Elementen.
        if( compare_arrays($_[0], $_[1]) ) {
            # öhm, scalar @{$_[0]} ???
            print "array-comp: " . scalar @{$_[0]} . " => " . scalar @{$_[1]} . "\n";
            for( my $c = 0; $c < scalar @{$_[0]}; $c++ ) {
                hash_update($_[0]->[$c], $_[1]->[$c]);
            }
        }else{
        
            print "array-comp: " . scalar @{$_[0]} . " => " . scalar @{$_[1]} . "\n";
            # Entscheide anhand der gesetzten Umgebungsvariablen ob bei
            # ungleicher Anzahl von Elementen der alte oder der neue Eintrag
            # genommen werden soll.
            if( $HASH::Update::beiArrayMitUngleichenElementenAlterDatensatz ) {
                $_[1] = $_[0];
            }
            
        }
        
        # ???
        # Ist die Datenstruktur partiell gleich, dann solange Rekursion wie
        # gleich, ansonsten altes belassen + neues hinzufügen???
        # zu faul...
        
    }else{
        # Es ist ein Skalar. Existiert der Wert in der alten Datenstruktur
        # wird er übernommen.
        #print "$_[0] => $_[1]\n";
        $_[1] = $_[0];
    }

} # /hash_update

# Funktion zum Vergleichen zweier Arrays auf Äquivalenz
# vgl. perlfaq4, "How do I test whether two arrays or hashes are equal?"
sub compare_arrays {
    my ($first, $second) = @_;
    no warnings;  # silence spurious -w undef complaints
    return 0 unless @$first == @$second;
    for (my $i = 0; $i < @$first; $i++) {
        # heir "ref" hinzugefügt, weil ich wissen will, ob die
        # Datenstruktur gleich ist, nicht der Inhalt.
        return 0 if ref $first->[$i] ne ref $second->[$i];
    }
    return 1;
}

hash_update($alt, $neu);
print Dumper( $neu );