import java.io.*;
import java.net.*;
import java.util.*;

public class Proxy extends Thread
{
    Socket c=null;
    int port=0;
    String host="";
    String rawUrl="", pname, fname;
    String CR="\r\n";
    byte readIn[]=null;
    Cache mycache=null;
    URL url=null;
    String getfilename="GET.", postfilename="Post.";
    boolean isCachable=true;

    int bufferSize=4096;
    String connection="";
    String cachePath="", extra="A.";

    //** Wait for new requests and open Connection class *//
    public Proxy(Socket c, int port, String rawUrl, Cache cache)
    {
    	this.c=c;
    	this.port=port;
    	this.rawUrl=rawUrl;
    	this.mycache=cache;
    	cachePath=mycache.getcachePath();

    	try
    	{
    		url=new URL(rawUrl);
    		this.host=url.getHost();
    		this.pname=url.getFile();
    		this.fname=pname.substring(pname.lastIndexOf('/')+1);
    		System.out.println("host: "+host+" pname: "+pname+" fname: "+fname);
    	}
    	catch(Exception e)
		{ System.err.println(e); }
    }

    public void run()
	{
        Socket s = null;

        //** Initiate communications stuff and start a Connection *//
        try
        {
        	s = new Socket(host, port);
	        System.out.println("Connection: " + s);
			System.out.println(CR+"rawUrl: "+rawUrl);

			// Read get stream
			c2p(c);
			System.out.println("Access c2p"+CR);

			// If it has cached, send it from proxy, else get from server
			if(mycache.IsCached(rawUrl))
			{
				postfilename=mycache.getFilename(rawUrl);
				System.out.println("Get "+ postfilename+" from cache.");
				deleteFile(cachePath+getfilename);
				p2c(c);
				System.out.println("Access p2c"+CR);
			}
			else
			{
	 			p2s(s);
				System.out.println("Access p2s"+CR);
				deleteFile(cachePath+getfilename);
				s2p(s);
				System.out.println("Access s2p"+CR);
				if(isCachable)
				{
					p2c(c);
					System.out.println("Access p2c"+CR);
				}
			}
		//	if(connection.equalsIgnoreCase("close"))
		//	{
				closeConnection(s);
				closeConnection(c);
		//	}
        }//try
        catch (Exception e)
        {
            System.out.println(e);
        }
    }//run

//--- c2p --- Client to Proxy
public synchronized void c2p(Socket s)
{

    DataInputStream in = null;
    PrintWriter outFile=null;
    int i;
    String content="", method,path_name,version;
    StringTokenizer z, pn;
    String p;

    try
    {

    	in=new DataInputStream(s.getInputStream());
    	content=in.readLine();
        int string_length=content.length();
        z=new StringTokenizer(content);
        method=z.nextToken();            //GET
        path_name=z.nextToken();
        version=z.nextToken();

        // Generate the filename
        getfilename+=host;
        if(path_name.equals("/"))
        {
           	// Regenerate first line of header
           	content=method + " "+ pname+" "+version;

        	postfilename+=host+".html";
        //	System.out.println("path_name = /");
        }
		else
        {
        	rawUrl="http://"+ host+ path_name;
        	pn=new StringTokenizer(path_name, "/");
        	while(pn.hasMoreTokens())
        	{
        		p=pn.nextToken();
        		getfilename+= "."+ p;
        		postfilename+="."+ p;
        	}

        }
        getfilename+=".txt";
        System.out.println("rawUrl: "+rawUrl);
        System.out.println("getfilename: "+getfilename+ " postfilename: "+postfilename+CR);

        // Do not save CGI and search file
        if(postfilename.indexOf('?')!=-1 ||postfilename.indexOf("cgi-bin")!=-1)
        {
        	isCachable=false;
        }

        // Save get file
        outFile=new PrintWriter(new FileOutputStream(cachePath+getfilename));
        while(string_length!=0 && content!=null)
        {
           System.out.println(content);
           saveFile_header(content,outFile);
           content=in.readLine();
           string_length=content.length();
        }
        outFile.println(); // Write a newline -- this is important, otherwise it will not be recognized
        outFile.close();
        System.out.println("Saved to " + cachePath + getfilename);
      }
      catch(IOException e)
      { System.out.println(e);}
      catch (Exception e)
      {
       closeConnection(s);
      }
}// end c2p

public synchronized void deleteFile(String file)
{
	File f=new File(file);
	f.delete();
}

public synchronized void saveFile_header(String st,PrintWriter outFile)
{
       outFile.println(st);
       outFile.flush();
}

//--- p2s --- Proxy to Server
public synchronized void p2s(Socket s)
{
	DataInputStream inf=null;
	DataOutputStream out=null;

	readIn=new byte[bufferSize];
	try
	{
		inf=new DataInputStream(new FileInputStream(cachePath+getfilename));
		out=new DataOutputStream(s.getOutputStream());

		// Open the get file and send to server
		int read=inf.read(readIn, 0, bufferSize);
		while(read!=-1)
		{
			sendFile(readIn,read,out,s);
			read=inf.read(readIn,0,bufferSize);
		}
		inf.close();
		System.out.println(cachePath+getfilename+" send.");
	}
	catch(FileNotFoundException e)
	{e.printStackTrace();}
	catch(IOException e)
	{e.printStackTrace();}
	catch (Exception e)
	{e.printStackTrace();}
}//end p2s

public synchronized void sendFile(byte readIn[],int st, DataOutputStream out, Socket s)
{
	try
	{
		out.write(readIn ,0, st);
		out.flush();
	}
	catch (Exception e)
	{
	 closeConnection(s);
	}
}

//--- s2p --- Server to Proxy
public synchronized void s2p(Socket s)
{

	DataInputStream inf=null, in=null;
	DataOutputStream outf=null;
	PrintWriter tableFile=null;

	String Token="";
	StringTokenizer tk;


	readIn=new byte[bufferSize];

	try
	{
		in=new DataInputStream(s.getInputStream());

		// Read post stream header from server
		String reads=in.readLine();
		int len=reads.length();
	//	System.out.println("length= "+len);

		String content_type="";
		String[] header=new String[10];
		int i=0, n=0;

		// Save header to an array
		while(len!=0)
		{
			header[i]=reads;
			System.out.println(header[i]);
			i++;
			reads=in.readLine();
			len=reads.length();
		}
		System.out.println("Read postfile header.");

		// Save the Content-Type and Connection
		n=i;
		for(i=0; i<n; i++)
		{
			tk=new StringTokenizer(header[i]);
			Token=tk.nextToken();

           		if(Token.equalsIgnoreCase("Content-Type:"))
           		{
           			content_type=tk.nextToken();
           		}
           		if(Token.equalsIgnoreCase("Connection:"))
           		{
           			connection=tk.nextToken();
           			System.out.println("** Connection: "+connection);
           		}
        	}//for(i=0; i<n; i++)

        // Save text file (no CGI and search file)
        if(content_type.equalsIgnoreCase("text/html") && isCachable==true)
        {
        	outf=new DataOutputStream(new FileOutputStream(cachePath+postfilename));
        	// Save header
        	for(i=0; i<n; i++)
        	{
        		treat(header[i],outf,s);
        	}
        	outf.writeBytes(CR);

        	// add to hashtable and tableFile.txt
        	mycache.AddToTable(rawUrl, postfilename);
			System.out.println("table: "+mycache.IsCached(rawUrl));
        	tableFile=new PrintWriter(new FileWriter("tableFile.txt",true));
        	tableFile.println(rawUrl+" "+ postfilename);
        	System.out.println("Save to talbeFile.txt");

			// Save the rest of file
        	int ss=in.read(readIn,0,bufferSize);
        	while(ss!=-1)
        	{
        		saveReminder(readIn, ss, outf,s);
        		ss=in.read(readIn,0,bufferSize);
        	}
        	outf.close();
        	tableFile.close();
			System.out.println("Saved "+ cachePath+postfilename);

			// Optimize HTML file
			optimizeFile(cachePath+postfilename, cachePath+extra+postfilename);
			System.out.println("Optimize " + cachePath+postfilename);

			deleteFile(cachePath+postfilename);
        }// if(content_type.equalsIgnoreCase("text/html"))
    	else
    	{
    		// As it is an image or uncachable, send it directly to client
    		isCachable=false;
    		DataOutputStream out=new DataOutputStream(c.getOutputStream());
    		for(i=0; i<n; i++)
    		{
    			s2c_header(header[i], out);
    		}
    		out.writeBytes(CR);
    		int ss=in.read(readIn,0,bufferSize);
    		while(ss!=-1)
        	{
        		saveReminder(readIn,ss, out, c);
        		ss=in.read(readIn,0,bufferSize);
        	}
        	System.out.println("As it is an image or uncachable, send it directly to client.");
        }//else
    }//try
    catch (Exception e)
    {
    closeConnection(s);
    }
}// ebd s2p

public synchronized void s2c_header(String st, DataOutputStream out)
{
	try
	{
		out.writeBytes(st+CR);
		out.flush();
	}
	catch(Exception e)
	{
		System.out.println(e);
		closeConnection(c);
	}
}

public synchronized void treat(String st, DataOutputStream out, Socket s)
{
    try
    {
        out.writeBytes(st+CR);
        out.flush();
    }
    catch (Exception e)
    {
    System.out.println(e);
    closeConnection(s);
    }
}

public synchronized void saveReminder(byte readIn[],int st, DataOutputStream out,Socket s)
{
	 try
	 {
		out.write(readIn ,0, st);
		out.flush();
	}
	catch (Exception e)
	{
	 closeConnection(s);
	}
}

//--- p2c --- Proxy to Client
public synchronized void p2c(Socket s)
{
	FileInputStream inf=null;
	DataOutputStream out=null;

	readIn=new byte[bufferSize];
	try
	{
		inf=new FileInputStream(cachePath+extra+postfilename);
		out=new DataOutputStream(s.getOutputStream());

		int read=inf.read(readIn,0,bufferSize);
		while(read!=-1)
		{
			sendFile(read,out,s);
			read=inf.read(readIn,0,bufferSize);
		}
		inf.close();
		System.out.println(cachePath+extra+postfilename+ " send.");
	}
	catch(FileNotFoundException e)
	{e.printStackTrace();}
	catch(IOException e)
	{e.printStackTrace();}
	catch (Exception e)
	{e.printStackTrace();}
}

public synchronized void sendFile(int st, DataOutputStream out, Socket s)
{
	 try
	 {
  		out.write(readIn ,0, st);
  		out.flush();
	}
	catch (Exception e)
	{
	 closeConnection(s);
	}
}


//** Close the Socket if someone gets mad *//
public synchronized void closeConnection(Socket s)
{
    try
    {
        System.out.println("Deconnection: "+s);
        s.close();
    }
    catch (Exception e)
    {
        System.out.println("Erreur closeConn "+e);
        System.exit(10);
    }
}

public synchronized void optimizeFile(String file1, String file2)
{
	try{
		FileReader f1=new FileReader(file1);
		FileWriter f2=new FileWriter(file2);
		PrintWriter staFile=new PrintWriter(new FileWriter("statisticFile.txt",true));
		float inLen=0, outLen=0;
		float per=0;
		int spa=32, e=10;

		int content=f1.read();
		while(content!=-1)
		{
			inLen++;
			//reduce multiple Enter
			if(content==e)
			{
				while((content=f1.read())==e)
				{ inLen++;}
				inLen++;
				outLen++;
				f2.write(e);
			}

			//reduce multiple Space
			if(content==spa)
			{
				while((content=f1.read())==spa)
				{
				  inLen++;
				}
				inLen++;
				outLen++;
				f2.write(spa);

			}
			if(content==-1)
			{
			   inLen--;
			    break;
			}
			outLen++;
			f2.write(content);
		//	System.out.println(content);
			content=f1.read();

		}
		f1.close();
		f2.close();
		per=outLen/inLen;
		System.out.println("inLen= "+(int)inLen+" outLen= "+(int)outLen+" Optimize percentage: "+per);
		staFile.println(file1 + ": "+ (int)inLen +" "+file2 + ": "+ (int)outLen +" Percentage: "+per);
		staFile.close();

	}//try
	catch(Exception e)
	{ System.out.println(e);}
}

}//class Proxy