# Numbrix puzzel => n*n raster => 1 tem n² invullen als een slang => getal kleiner en getal groter moeten buren zijn.
# Mogelijke cellen in een cel => Verzameling voor elke cel
# Kunnen weten of element aanwezig is => hashes (niet gegeven) => 3 dimensies => [x][y]{nummer}
# Steeds testen van een criterium, tot het niet meer nodig is. Als er twee zijn: eerst crit 1, dan crit 2, dat in loop.
# Bij 3 kan je kiezen tussen 123 123 123 en 1212123123 (afh of 2 iets oplevert)
    # 1) alle getallen die nog niet in het raster aanwezig zijn in elke cel.
    # 2) Criteria toepassen:
        # A) Elke kandidaat in elke cel 1 voor 1 aflopen en afvragen of die daar kan staan => Het getal kleiner en groter moet in de mogelijke buurcellen staan. => herhalen tot geen verbetering meer brengt
            # Elementen verwijderen uit hash met delete. (niet gegeven)
            # Houd cellen bij die maar 1 kandidaat hebben => zo weinig mogelijk specialekes doen.
            # Maak extra rijen en kolommen voor randen (0 wordt toch niet gebruikt) en maak die leeg. (niet gegeven)
        # B) Ga op zoek naar de cellen met maar één kandidaat en verwijder die kandidaat uit de andere cellen. => Ook ittereren
            # Programma moet stoppen! => Zorg dat kan vaststellen als hij gestopt is en intermediaire shit kan uitschrijven.
        # C) Als een kandidaat maar in één cel mogelijk is, vul het dan in.

use Data::Dumper;

@ARGV = "A.numbrix";
($bestand) = @ARGV;
$aantal = 0;            #we willen van 1 tot en met 5 opvullen ,  0 en 6 moeten undef zijn.
my %aanwezig;
while(<>) {
    $aantal++;
    # print Dumper @rij;
    for $rij (split " ", $_){
        if ($rij ne "...") {
            # print ("\$_ in if = $_");
            $aanwezig{int($rij)} = 1;
        }

    }
}

for my $j (0 .. ($aantal + 1)) {
    $structuur[$j][$aantal+1]{undef} = undef;
    $structuur[$j][0]{undef} = undef;
    $structuur[$aantal+1][$j]{undef} = undef;
    $structuur[0][$j]{undef} = undef;
}


@ARGV = $bestand;

while(<>){
    $x += 1;
    $y = 0;
    for $rij (split " ", $_){
        $y += 1;
        if($rij eq "..."){
            for $kandidaat (1..$aantal*$aantal){
                unless (exists $aanwezig{$kandidaat}){
                    $structuur[$x][$y]{$kandidaat} = 1;
                }
            }
        }
        else{
            $structuur[$x][$y]{int($rij)} = 1;
        }
    }
}

# print "\$. = $.";
# $. is nu aantal rijen/kolommen


print Dumper @structuur;

# # if defined dan ...
# # verwijderen uit array met splice
# # alle getallen die nog niet aanwezig zijn:
# # dit is super inefficient

for my $k (1 .. $.){
    for my $l (1 .. $.) {
        unless (defined($structuur[$k][$l])){
            for my $m (1 .. $.*$.) {
                unless (defined($aanwezig{$m})){
                    $structuur[$k][$l]{$m} = 1;
                }
            }
        }
    }
}

# print("initialisatie: \n");
# for $cel (1..$aantal*$aantal){
#   $x = $cel%$aantal;
#   # Randgeval als rechtse kolom wordt gebruikt
#   if($cel%$aantal == 0){
#           $x = $aantal;
#       }
#   $y = int(($cel-1)/$aantal)+1;
#   print "cel: $cel ($x, $y) || ";
#   print join ",\t", sort keys %{$structuur[$x][$y]};
#   print "\n";
# }

# mogelijke waarden zitten er in -> nu werken met deze structuur constant.
# criterium 1: voor elke waarde checken of in de aanliggende een waarde ligt die er voor en er na komt



for $a (1 .. $aantal){
    for $b (1 .. $aantal) {
        foreach $key (sort {$a <=> $b} keys $structuur[$a][$b]) {
            # print "a = $a: b = $b: $key\n";
            $vorigeGevonden = 0;
            $volgendeGevonden = 0;
            if (($key ne $aantal*$aantal) and ($key ne 1)){
                if (exists($structuur[$a+1][$b]->{$key+1}) or exists($structuur[$a-1][$b]->{$key+1})
                    or exists($structuur[$a][$b+1]->{$key+1}) or exists($structuur[$a][$b-1]->{$key+1})) {
                    $volgendeGevonden = 1;
                }
                if (exists($structuur[$a+1][$b]->{$key-1}) or exists($structuur[$a-1][$b]->{$key-1})
                    or exists($structuur[$a][$b+1]->{$key-1}) or exists($structuur[$a][$b-1]->{$key-1})) {
                    $vorigeGevonden = 1;
                }
                if ($vorigeGevonden == 0 or $volgendeGevonden == 0) {
                    delete $structuur[$a][$b]->{$key};
                    # print "a = $a: b = $b: $key DELETED, $vorigeGevonden && $volgendeGevonden\n";
                }
            }
            if ($key eq $aantal*$aantal) {
                if (exists($structuur[$a+1][$b]->{$key-1}) or exists($structuur[$a-1][$b]->{$key-1})
                    or exists($structuur[$a][$b+1]->{$key-1}) or exists($structuur[$a][$b-1]->{$key-1})) {
                    $vorigeGevonden = 1;
                }
                unless ($vorigeGevonden) {
                    delete $structuur[$a][$b]->{$key};
                    # print "a = $a: b = $b: $key DELETED, $vorigeGevonden\n";
                }
            }
            if ($key eq 1) {
                if (exists($structuur[$a+1][$b]->{$key+1}) or exists($structuur[$a-1][$b]->{$key+1})
                    or exists($structuur[$a][$b+1]->{$key+1}) or exists($structuur[$a][$b-1]->{$key+1})) {
                    $volgendeGevonden = 1;
                }
                unless ($volgendeGevonden) {
                    delete $structuur[$a][$b]->{$key};
                    print "a = $a: b = $b: $key DELETED, $volgendeGevonden\n";
                }
            }

        }
    }
}
print("\nCriterium 1: \n\n");
for $cel (1..$aantal*$aantal){
    $x = $cel%$aantal;
    # Randgeval als rechtse kolom wordt gebruikt
    if($cel%$aantal == 0){
            $x = $aantal;
        }
    $y = int(($cel-1)/$aantal)+1;
    print "cel: $cel ($x, $y) || ";
    print join ",\t", sort keys %{$structuur[$x][$y]};
    print "\n";
}

for $k (1 .. $aantal){
    for $l (1 .. $aantal) {
        @array = keys(%{$structuur[$k][$l]});
        $value = $array[0];
        $size = @array;
        if ($size == 1){
            for my $x (1 .. $.){
                for my $y (1 .. $.) {
                    delete($structuur[$x][$y]{$value});
                }
            }
        }
    }
}