// Layout:
// Part I
// 1. Are we using a proxy server?
// 2. Open the URL and get the data
//
// Part II
// Parse the data
//
// Part III
// Connect to the DB and do the query with the data

import java.net.*;
import java.sql.*;
import java.util.*;
import java.io.*;
import com.ibm.xml.parsers.DOMParser;
import com.bpsinfo.javassl.*;
import HTTPClient.*;

import org.w3c.dom.*;
import ProxyObject;
import SiteObject;

public class FetchApp extends Object {

// globals
boolean useProxy=false;
static int gArrayLength=10;
static ProxyObject proxyInfo=new ProxyObject();
static SiteObject[] siteInfo=new SiteObject[gArrayLength];

// ***********************************
//
//	main
//
//  Notes: the starting point for it all
//
// ***********************************

public static void main(String[] args) 
	throws IOException, UnknownHostException {
    init();
    myReadPrefs();
    String container=null;
    int location=0, location2=0;

    // for now just spit the output to the terminal window
	int x=0;
	while ((siteInfo[x].URL!=null) && (x<gArrayLength)){
                System.out.println("Read # "+x);
                container=myGetURL(x);
		if ((location=container.indexOf("Server:"))!=-1) {
			// look for the next line break
			location2=container.substring(location,container.length()).indexOf("\n");
			if (location2==-1) location2=location+100;
			else location2+=location;
        		toDatabase(container.substring(location,location2));
			// put the server info taken from the headers into the database
			// while this isn't glamorous, it illustrates the methodology
			}
		else toDatabase(container.substring(0,100));
			// if we can't find a Server line, just put the first 100 characters
                System.out.println("End of read # "+x);
		x++;
	}
    } // end main


// ***********************************
//
//	myGetURL
//
//  Notes: the static return type is essential; without it, the code will not compile.
//
// ***********************************
                  
public static String myGetURL(int whichSite)
	throws UnknownHostException, IOException {
int result=0, fetched=0, port=0;
URL destination=new URL(siteInfo[whichSite].URL);
char[] cbuf=new char[65000];
boolean useProxy=(proxyInfo.ProxyServer!=null);
SSLSocket s=null;

try {
	// are we using a proxy server? If so, Java provides a method for using it
	// note that it won't work with https sites because the OpenSSL Java wrapper
	// and HTTPClient aren't completely integrated yet. We take care of the proxy
	// by hand, further down.
	if (useProxy) {
                    System.getProperties().put("proxySet", "true");
	            System.getProperties().put("ftpProxySet", "true");
                    System.getProperties().put("http.proxyHost", proxyInfo.ProxyServer);
                    System.getProperties().put("http.proxyPort", proxyInfo.ProxyPort);
                    System.getProperties().put("https.proxyHost", proxyInfo.ProxyServer);
                    System.getProperties().put("https.proxyPort", proxyInfo.ProxyPort);
                    System.getProperties().put("ftpProxyHost", proxyInfo.ProxyServer);
                    System.getProperties().put("ftpProxyPort", proxyInfo.ProxyPort);
		} // fi use proxy


// this section for https is obsolete with Sun's JSSE, but JSSE only works with JDK 1.2!
// note that until we get the OpenSSL wrapper working better with HTTPClient, we don't 
// have the ability to automatically handle passwords (authentication) on https sites,
// although it could be done by hand.
       if (destination.getProtocol().equalsIgnoreCase("https")) {
       try {
               if (destination.getPort()==-1) {
                    port=443;
                    }
               else {
                    port=destination.getPort();
                    }

               if (useProxy) {
                   InetAddress theAddress= InetAddress.getByName(proxyInfo.ProxyServer);
                   InetAddress localAddress=InetAddress.getByName("0.0.0.0");
                   s =new SSLSocket(theAddress, (java.lang.Integer.decode(proxyInfo.ProxyPort).intValue()), localAddress, 0,
                       "CONNECT " + destination.getHost() + ":" + port + " HTTP/1.0\r\n\r\n");
                   }
               else {
                    s = new SSLSocket(destination.getHost(), port);
                    }

               s.setSoLinger(true, 30);

               OutputStream dos = s.getOutputStream();

               InputStream is = s.getInputStream();
               InputStreamReader dinsr=new InputStreamReader(is);
               BufferedReader in=new BufferedReader(dinsr);

               String themsg=new String("GET / HTTP/1.0\r\n\r\n");

               dos.write(themsg.getBytes());
               dos.flush();

               while ((fetched!=-1) && (result<65000)) {
                       fetched=in.read(cbuf,result,65000-result);
                       result+=fetched;
               } // while
               in.close();
               s.close();

             } // try

             catch (Exception e) {
               System.out.println("\nUh oh! "+e);

               e.printStackTrace();

             }
           //return null;
       } // if https

    else { // not https
            URLConnection conn = destination.openConnection();
        // do we need a username and password for the site?
	if (siteInfo[whichSite].username!=null) {
                String authString = new String(siteInfo[whichSite].username+":"+siteInfo[whichSite].password); // format is "username:pass";
                String auth = "Basic " + new sun.misc.BASE64Encoder().encode(authString.getBytes());
                // this is how you send the username and password to the site
                conn.setRequestProperty("Authorization", auth);
		}
	if (proxyInfo.username!=null) {
                // this next part is only used for proxy servers that require authentication.
		// Haven't tested it yet.
                String authString2 = new String(proxyInfo.username+":"+proxyInfo.password);
                String auth2 = "Basic " + new sun.misc.BASE64Encoder().encode(authString2.getBytes());
                conn.setRequestProperty("Proxy-Authorization", auth2);
		}

                BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
                while ((fetched!=-1) && (result<65000)) {
                        fetched=in.read(cbuf,result,65000-result);
                        result+=fetched;
                } // while
                in.close();
        } // else not https

	} // try
	catch (UnknownHostException e) {
		System.err.println("Don't know about host: "+e);
	}
	catch (IOException e) {
		System.err.println("Couldn't get I/O for the connection: "+e);
	}
	catch (Exception e) {
        	System.err.println(e);
	}
	finally {
		String theInfo=new String(cbuf,0,result);
		return theInfo;
	}
	
} // end myGetURL


// ***********************************
//
//	myReadPrefs
//
//  Notes: reads information stored in an XML file
//
// ***********************************

public static void myReadPrefs () {



        String filename = "FetchAppPrefs.ene";

        //*** The document is the root of the DOM tree.
        try {

           GetParseTreeErrors(filename);

        }
	catch (Exception e) {

            e.printStackTrace();

        }

}

public static void traverseDOMBranch(Node node) {

NamedNodeMap theMap=null;
Node pointer=null;
int counter=0;

 if (node.hasChildNodes()) {
    NodeList nl = node.getChildNodes();
    int size = nl.getLength();
    for (int i = 0; i < size; i++) {
        theMap=nl.item(i).getAttributes(); // does this node have any attributes (data, in our case)?
	if (theMap!=null) { // Is there any information to get from this node?

            if (nl.item(i).getNodeName().equalsIgnoreCase("proxyinfo")) { // we've got the proxy info!
		for (int x=0; x<theMap.getLength(); x++) {
                    // get the proxy values and stuff them into the object
                    if (theMap.item(x).getNodeName().equalsIgnoreCase("port"))
                        proxyInfo.ProxyPort=theMap.item(x).getNodeValue();
                    if (theMap.item(x).getNodeName().equalsIgnoreCase("ip"))
                        proxyInfo.ProxyServer=theMap.item(x).getNodeValue();
                    if (theMap.item(x).getNodeName().equalsIgnoreCase("username"))
                        proxyInfo.username=theMap.item(x).getNodeValue();
                    if (theMap.item(x).getNodeName().equalsIgnoreCase("pass"))
                        proxyInfo.password=theMap.item(x).getNodeValue();
			} // for
		} // if=proxyinfo

            else if (nl.item(i).getNodeName().equalsIgnoreCase("siteinfo")) {
		// must be Site Information. Note that we ignore any other Node Names (types)
                for (int x=0; x<theMap.getLength(); x++) {
                    // get the site values and stuff them into the object
                    if (theMap.item(x).getNodeName().equalsIgnoreCase("url"))
                        siteInfo[counter].URL=theMap.item(x).getNodeValue();
                    if (theMap.item(x).getNodeName().equalsIgnoreCase("username"))
                        siteInfo[counter].username=theMap.item(x).getNodeValue();
                    if (theMap.item(x).getNodeName().equalsIgnoreCase("password"))
                        siteInfo[counter].password=theMap.item(x).getNodeValue();
                    } // for
		counter++; // keep track!
		if (counter>gArrayLength) {
			System.out.println("Error: More sites than space available. Please increase the size of the gArrayLength variable.");
			return;
			}
		} // else if=siteinfo

            } // if theMap!=null
            } // for i<size
} // if has child nodes
}

public static void GetParseTreeErrors (String filename) {

        try {

            DOMParser parser = new DOMParser();

            parser.parse(filename);

            Document document = parser.getDocument();
            Element root = (Element)document.getDocumentElement();
            traverseDOMBranch(root);

        } catch (Exception e) {
            System.out.println("Got to an error: "+e);

            e.printStackTrace();

        }

    }

// ***********************************
//
//	init
//
//  Notes: initializes JDBC drivers
//
// ***********************************

static public void init() {

	try {
		//Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
		//Class.forName ("oracle.jdbc.driver.OracleDriver");
        	Class.forName("org.gjt.mm.mysql.Driver").newInstance();
                //System.getProperties().put("java.protocol.handler.pkgs", "com.sun.net.ssl.internal.www.protocol");
                System.getProperties().put("java.protocol.handler.pkgs", "HTTPClient");
		//Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
    	}
    catch (Exception E) {
		System.out.println("Unable to a load driver during init phase.");
		System.out.println(E);
		E.printStackTrace();
		}

// this part is required to instantiate each element. Why is this so tough with non-prefab classes?
	for(int i=0; i<gArrayLength; i++)
            siteInfo[i]=new SiteObject();

} // init


// ***********************************
//
//	toDatabase
//
//  Notes: Connect to the Oracle DB
//
// ***********************************

static void toDatabase (String value) {

String	user="matt", // the username which the JDBC driver should use to connect
		password="", // the password associated with the previous username
		host="192.168.34.44", // either the IP address of the server or its name
		SID="xx", // this is the Oracle SID (System Identifier) of the database. Not used by MySQL
		port="1521", // the port number at which Oracle is expecting connections. 1521 may be the default.
				// Not used by MySQL in this example
		table="test";
Connection con=null;
ResultSet rs = null;
ResultSetMetaData rsmd=null;
String query=null;

		try {
			String datasource="jdbc:mysql://"+host+"/"+table; // this only applies to MySQL
			con = DriverManager.getConnection(datasource+"?user="+user+"&password="+password, user, password);
			
			// this one is for Oracle
			// con = DriverManager.getConnection ("jdbc:oracle:thin:@"+host+":"+port+":"+SID,user, password);
			// Create Oracle DatabaseMetaData object
			// DatabaseMetaData meta = con.getMetaData ();

			// gets driver info:
			// System.out.println("JDBC driver version is " + meta.getDriverVersion());
			}
		catch (SQLException e) {
			con = null;
                        System.out.print("Couldn't connect to database on<b>: " + host + "\n");
                        System.out.print(e+"\n");
                        e.printStackTrace();
                        return;
			}
		
		Statement stmt = null;
		try {
        		stmt = con.createStatement();
			query="insert into "+table+"(info) values(\""+value+"\")";
			rs = stmt.executeQuery(query);
			// System.out.print("\n<br>Query: "+query); // echo the query to the command line for debugging

			// now turn around pull out the contents and display it to the screen
                        query="select * from "+table;
                        rs = stmt.executeQuery(query);

			rsmd = rs.getMetaData ();
		
			// now you would use rsmd to check for the results of a select query
                        int numCols = rsmd.getColumnCount ();
			while (rs.next()) {
				for (int i = 1; i <= numCols; i++) {
                        	System.out.println(rs.getString(i));
                		}
			} // while
			} // try
		catch (SQLException e) {
			con = null;
        	System.out.print("SQL Exception<b>: " + host + "\n");
        	System.out.print(e+"\n");
        	return;
			}
		finally {
			try {
				if (rs!=null)
					rs.close();
				stmt.close();
				if (con!=null)
					con.close();
				}
			catch (SQLException e) {
				 System.out.print("SQL Exception during close<b>: "+e+"\n");
				 }
			}

	} // toDatabase

} // end class FetchApp