import java.net.*;
import java.io.*;
import java.util.Stack;
import java.util.Date;
import java.math.BigInteger;

/**
 * <H2>NetRand Project</H2>
 * <H4>Software Engineering - CS536</H4>
 * <H4>University of Wisconsin - Milwaukee</H4>
 * <H4>Authors:</H4>
 * <UL>
 * <LI>Spring 1998 - Francis William Kasper
 * </UL>
 * <BR>File: Downloader.java
 * <HR>
 * <P>
 * Downloader calls the <A HREF="BinaryLinkExtractor.html">BinaryLinkExtractor</A>
 * to extract all the links to binary files in a given HTML document.  After
 * a list of binary file links is obtained, it places them on a stack.  Each
 * file on the stack is downloaded eight consecutive times.  The time it takes
 * to download the file is examined.  If it is an even number, a 0 bit is recorded,
 * otherwise a 1 bit is recorded.  One byte of entropy is obtained from each
 * binary file link.  <A HREF="BitSender.html>BitSender</A> is used to send
 * these random bytes back to the server.
 */

public class Downloader {

		// -------- Class Variables ----------- //

    /** a stack to hold the binary file links */
    private Stack binaryFileLinks = new Stack();

		// -------- Class Methods ------------- //

    /**
     * calls the appropriate functions to extract the binary file links from
     * the HTML file referenced by the given URL, perform the downloading
     * and sending of the random bytes.
     * @param urlString - the URL to reference the target HTML file
     */
    public void getEntropy( String urlString )
    {
        try {
	    collectBinaryFileLinks( urlString );
             
 	    while ( !binaryFileLinks.empty() )
	        doDownload((String)binaryFileLinks.pop());
	}
	catch ( Exception e ) {
	    System.err.println( e );
	}
    }

		// ------------------------------------ //

    /**
     * collects all the binary file links for a HTML referenced by a given
     * URL
     * @param urlString - the target URL
     * @exception Exception is thrown if the given URL cannot be accessed
     */
    private void collectBinaryFileLinks( String urlString )
    throws Exception
    {
        LinkedList newFiles = null;
        BinaryLinkExtractor extractor = new BinaryLinkExtractor();

        newFiles = extractor.extractBinaryLinks( urlString );

	if ( newFiles == null || newFiles.size() < 1 )
	    throw new Exception( urlString + " does not contain any binary links." );
	    
	newFiles.reset();
        while ( newFiles.hasMoreElements() ) 
            binaryFileLinks.push((String)newFiles.nextElement());
    }

		// -------------------------------------- //

    /**
     * calls getBinaryFile to perform the downloading of the binary file; downloads
     * the binary file eight consecutive times; from these times it records a 0
     * bit if the download time was even, otherwise a 1 bit is recorded.  It
     * uses the BitSender class to send the random byte to the server
     * @param urlString - the target binary file
     */ 
    private void doDownload( String urlString )
    {
        StringBuffer entropy = new StringBuffer();
	byte randomByte = 0;
	
        try
        {
            URL target = new URL( urlString );
            
	    for ( int i = 0; i < 8; i++ )
	    {
                long dtime = getBinaryFile( target );
            
	        if ( dtime < 1 )
		    return;

                if ( (int)dtime % 2 == 0 )
		    entropy.append( "0" );
                else
		    entropy.append( "1" );
             }

	     randomByte = (byte)Integer.parseInt(entropy.toString(),2); 
            
	     try {
		 BitSender sender = new BitSender();
	         sender.SendByte(randomByte); 
             }
             catch ( Exception e ) {
                 System.err.println( e );
                 System.exit( 1 );
             }
        }
        catch ( MalformedURLException me ) {
            System.err.println( me );
            return;
        }
    }

   		// --------------------------------------- //

    /**
     * performs the actual downloading of the binary file
     * @param target - the target URL to download
     * @return the download time is milliseconds
     */
    public long getBinaryFile( URL target )
    {
        Date start_time;
        Date end_time;
        int bfr = 128;

        try {
            URLConnection uc = target.openConnection();

            InputStream theImage = uc.getInputStream();
            byte[] b = new byte[bfr];
            int bytesread = 0;

            start_time = new Date();
            while (bytesread >= 0)
            {
                bytesread = theImage.read(b, 0, bfr);
                if (bytesread == -1) break;
            }

            end_time = new Date();
	}
        catch ( Exception e ) {
            System.err.println(e);
            return (-1);
        }

        long dtime = end_time.getTime() - start_time.getTime();
        
        if ( dtime < 50 )
            return -1;
        
	return ( dtime );
    }

}