package jmetal.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;

//Questa classe rappresenta un arco tra due nodi chiamati A e B
//Per verificare la raggiungibilità di un nodo si considerano i due "punti" dell'arco, vertexA e vertexB
public class Edge implements Comparable<Edge> {

    char vertexA;

    char vertexB;

    int weigth;

    public Edge(char vertexA, char vertexB, int weigth)
    {
        if (vertexA == vertexB)
            throw new IllegalArgumentException("Vertex must be different");
        this.vertexA = vertexA;
        this.vertexB = vertexB;
        this.weigth = weigth;
    }

    public char getVertexA()
    {
        return vertexA;
    }

    public char getVertexB()
    {
        return vertexB;
    }

    public int getWeigth()
    {
        return weigth;
    }

    public static int getWeigth(List<Edge> edges)
    {
        int result = 0;
        for (Edge e : edges)
        {
            result += e.getWeigth();
        }
        return result;
    }

    public boolean Reaches(char node)
    {
        if (node == vertexA)
            return true;
        if (node == vertexB)
            return true;
        return false;
    }

    public boolean Reaches(List<Character> vertexes)
    {
        for (Character v : vertexes)
        {
            if (v == vertexA)
                return true;
            if (v == vertexB)
                return true;
        }
        return false;
    }

    public char OtherEndpoint(char node)
    {
        if (node == vertexA)
            return vertexB;
        if (node == vertexB)
            return vertexA;
        throw new IllegalArgumentException("Node must be one of the endpoints");
    }

    public char OtherEndpoint(List<Character> vertexes)
    {
        for (Character v : vertexes)
        {
            if (v == vertexA)
                return vertexB;
            if (v == vertexB)
                return vertexA;
        }
        throw new IllegalArgumentException("vertexes must contain one of the endpoints");
    }

    public boolean Touch(List<Character> vertexes)
    {
        int count = 0;
        for (Character v : vertexes)
        {
            if (Reaches(v))
                count ++;
        }
        if (count == 1)
            return true;
        else
            return false;
    }

    public String toString()
    {
        return vertexA + "-" + vertexB + " (" + weigth + ")";
    }

    public static List<Edge> Touch(List<Edge> edges, List<Character> vertexes)
    {
        ArrayList<Edge> result = new ArrayList<Edge>();
        for (Edge e : edges)
        {
            if (e.Touch(vertexes))
            {
                result.add(e);
            }
        }
        return result;
    }

    @Override
    public int compareTo(Edge other){
        return weigth - other.getWeigth();
    }

    public static List<Character> getLeaves(List<Edge> edges)
    {
        List<Character> result = new ArrayList<Character>();
        HashMap<Character, Integer> map = new HashMap<Character,Integer>();
        for (Edge e : edges)
        {
           char c = e.getVertexA();
           Integer val = map.get(new Character(c));
           if(val != null)
           {
               map.put(c, new Integer(val + 1));
           } else {
               map.put(c, 1);
           }
           c = e.getVertexB();
           val = map.get(new Character(c));
           if(val != null)
           {
               map.put(c, new Integer(val + 1));
           } else {
               map.put(c, 1);
           }
        }
        for (Entry<Character, Integer> entry : map.entrySet()) {
            Character key = entry.getKey();
            Integer value = entry.getValue();
            if (value == 1)
                result.add(key);
        }
        return result;
    }

    public static int getMinWeight(List<Edge> edges)
    {
        int result = Integer.MAX_VALUE;
        for (Edge e : edges)
        {
            if (e.getWeigth() < result)
                result = e.getWeigth();
        }
        return result;
    }

    public static boolean DetectLoop(List<Edge> edges)
    {
        List<Character> reached_nodes = new ArrayList<>();
        for (Edge e : edges)
        {
            if (reached_nodes.contains((Character)e.getVertexA()) && reached_nodes.contains((Character)e.getVertexB()))
                    return true;
            else
            {
                if (!reached_nodes.contains((Character)e.getVertexA()))
                        reached_nodes.add((Character)e.getVertexA());
                if (!reached_nodes.contains((Character)e.getVertexB()))
                    reached_nodes.add((Character)e.getVertexB());

            }
        }
        return false;
    }

    public static boolean _detectLoop(List<Edge> edges, List<Character> reached_nodes)
    {
        return false;
    }

    public static int FindLeaves(List<Edge> edges)
    {
        int result = 0;
        HashMap<Character, Integer> hm = new HashMap<Character, Integer>();
        for (Edge e : edges)
        {
            if (!hm.containsKey(e.getVertexA()))
                hm.put(e.getVertexA(), 1);
            else
                hm.put(e.getVertexA(), hm.get(e.getVertexA())+1);

            if (!hm.containsKey(e.getVertexB()))
                hm.put(e.getVertexB(), 1);
            else
                hm.put(e.getVertexB(), hm.get(e.getVertexB())+1);
        }
        for (Character c : hm.keySet())
        {
            if (hm.get(c) == 1)
                result++;
        }
        return result;
    }

}