package org.lucci.madhoc.network.util;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;

import org.lucci.madhoc.network.Station;
import org.lucci.madhoc.network.Connection;
import org.lucci.madhoc.network.Network;
import org.lucci.madhoc.util.Buffer;

/*
 * Created on Aug 26, 2004
 */

/**
 * @author luc.hogie
 */
public class Data
{


    public static int getThroughput(Network network)
    {
        int throughput = 0;
        Iterator connectionIterator = network.getConnections().iterator();
        
        while (connectionIterator.hasNext())
        {
            Connection c = (Connection) connectionIterator.next();
            throughput += c.getUsedBandwith();
        }

        return (int) (throughput / network.getSimulation().getResolution());
    }


    
    static public List<Buffer> getOutputBuffersInUse(Network network)
    {
        List<Buffer> list = new Vector<Buffer>();
        Iterator stationIterator = network.getStations().iterator();
        
        while (stationIterator.hasNext())
        {
            Station station = (Station) stationIterator.next();
            Buffer buffer = station.getNetworkingUnit().getOutgoingMessageQueue();
            
            if (buffer.getCurrentSize() > 0)
            {
                list.add(buffer); 
            }
        }
        
        return list;
    }

    static public List<Buffer> getFullOutputBuffers(Network network)
    {

        List<Buffer> list = new Vector<Buffer>();
        
        for(Buffer buf : getOutputBuffersInUse(network))
        {
            if (buf.getAvailableSize() == 0)
            {
                list.add(buf); 
            }
        }
        
        return list;
    }

    
    
    static public Collection getOverHeadedOutgoingMessageQueues(Network network)
    {
        Collection c = new Vector();
        Iterator bufferIterator = getOutputBuffersInUse(network).iterator();
        
        while (bufferIterator.hasNext())
        {
            Buffer buffer = (Buffer) bufferIterator.next();

            if (buffer.getOverload() > 0)
            {
                c.add(buffer);
            }
        }
        
        return c;
    }

    static public int getBufferizedBytesCount(Network network)
    {
        int bufferizedBytesCount = 0;
        Iterator bufferIterator = getOutputBuffersInUse(network).iterator();
        
        while (bufferIterator.hasNext())
        {
            Buffer buffer = (Buffer) bufferIterator.next();
            bufferizedBytesCount += buffer.getCurrentSize();
        }
        
        return bufferizedBytesCount;
    }

    static public int getOverload(Network network)
    {
        int overhead = 0;
        Iterator queueIterator = getOverHeadedOutgoingMessageQueues(network).iterator();
        
        while (queueIterator.hasNext())
        {
            Buffer queue = (Buffer) queueIterator.next();
            overhead += queue.getOverload();
        }
        
        return overhead;
    }

    static public double getAverageOverload(Network network)
    {
        return (double) getOverload(network) / (double) network.getStations().size();
    }
}