Graph algorithm goes ordinately and not on the level

Question

I try to implement Iterative Deeping A* Search. The problem is that he goes ordinately and not as I want.

When I declared a node I wrote also the level where he is (adancime).

So my logic would be like, if(the level where he got is the same like the level(adancime) from the assignment) is ok, try there.

My graph is this:

Source: S Destination: G

The path that he should give is: S B D H F H F.... (he should fail to find the node) because he always get the lowest value H or F at some point.

Here is my code:

package com.ida.algorithm;

import java.util.PriorityQueue;
import java.util.HashSet;
import java.util.Set;

import java.util.List;
import java.util.Comparator;
import java.util.ArrayList;
import java.util.Collections;

public class ItDeepAStar {

        public static void main(String[] args){

                Node s = new Node("S", 12, 0);
                Node a = new Node("A", 5, 1);
                Node b = new Node("B", 5, 1);
                Node c = new Node("C", 5, 2);
                Node d = new Node("D", 2, 2);
                Node e = new Node("E", 2, 3);
                Node f = new Node("F", 1, 4);
                Node h = new Node("H", 1, 3);
                Node g = new Node("G", 0, 2);

                s.adjacencies = new Edge[]{
                        new Edge(b, 8),
                        new Edge(a, 10)
                };

                b.adjacencies = new Edge[]{
                        new Edge(d, 8),
                        new Edge(g, 16)
                };

                d.adjacencies = new Edge[]{
                        new Edge(g, 3),
                        new Edge(h, 1)
                };

                h.adjacencies = new Edge[]{
                        new Edge(f, 1)
                };

                a.adjacencies = new Edge[]{
                        new Edge(g, 10),
                        new Edge(c, 2)
                };

                c.adjacencies = new Edge[]{
                        new Edge(e, 3)
                };

                e.adjacencies = new Edge[]{
                        new Edge(g, 2)
                };

                AstarSearch(s, g);

                List<Node> path = printPath(g);

                        System.out.println("Path: " + path);


        }

        public static List<Node> printPath(Node target){
                List<Node> path = new ArrayList<Node>();

        for(Node node = target; node != null; node = node.parent){
            path.add(node);
        }

        Collections.reverse(path);

        return path;
        }

        public static void AstarSearch(Node source, Node goal){

                Set<Node> explored = new HashSet<Node>();
                int level = 0;
                PriorityQueue<Node> queue = new PriorityQueue<Node>(8, new Comparator<Node>(){
                                 //override compare method
                 public int compare(Node i, Node j){
                    if(i.f_scores > j.f_scores){
                        return 1;
                    }

                    else if (i.f_scores < j.f_scores){
                        return -1;
                    }

                    else{
                        return 0;
                    }
                 }

                });

                //cost from start
                source.g_scores = 0;

                queue.add(source);

                boolean found = false;

                while((!queue.isEmpty()) && (!found)){

                        //the node in having the lowest f_score value
                        Node current = queue.poll();

                        explored.add(current);

                        //goal found
                        if(current.value.equals(goal.value)){
                                found = true;
                        }

                        //check every child of current node
                        for(Edge o : current.adjacencies){
                                Node child = o.target;
                                double cost = o.cost;
                                double temp_g_scores = current.g_scores + cost;
                                double temp_f_scores = temp_g_scores + child.h_scores;
                                level++;
                                /*if child node has been evaluated and 
                                the newer f_score is higher, skip*/

                                if((explored.contains(child)) && (temp_f_scores >= child.f_scores)  ) {
                                        level--;
                                        continue;
                                }

                                /*else if child node is not in queue or 
                                newer f_score is lower*/

                                else if((!queue.contains(child)) || (temp_f_scores < child.f_scores) && level == child.adancime){

                                        child.parent = current;
                                        child.g_scores = temp_g_scores;
                                        child.f_scores = temp_f_scores;

                                        if(queue.contains(child)){
                                                queue.remove(child);
                                                level--;
                                        }

                                        queue.add(child);
                                        level++;
                                }
                        }
                }
        }
}

class Node{
    public int adancime;
    public final String value;
    public double g_scores;
    public final double h_scores;
    public double f_scores = 0;
    public Edge[] adjacencies = new Edge[]{};
    public Node parent;

    public Node(String val, double hVal, int adaincime){
            value = val;
            h_scores = hVal;
            this.adancime = adaincime;
    }

    public String toString(){
            return value;
    }    
}

class Edge{
        public final double cost;
        public final Node target;

        public Edge[] adjacencies = new Edge[]{};

        public Edge(Node targetNode, double costVal){
                target = targetNode;
                cost = costVal;
        }
}