// Purpose.  Proxy design pattern
// 1. Create a "wrapper" for a remote, or expensive, or sensitive target
// 2. Encapsulate the complexity/overhead of the target in the wrapper
// 3. The client deals with the wrapper
// 4. The wrapper delegates to the target
// 5. To support plug-compatibility of wrapper and target, create an interface

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

interface SocketInterface {                // 5. To support plug-compatibility 
   String readLine();                      //    between the wrapper and the
   void   writeLine( String str );         //    target, create an interface
   void   dispose(); 
}

public class ButtonProxy {
    SocketInterface socket;

    public ButtonProxy() {
	BufferedReader nPut = new BufferedReader(new InputStreamReader(System.in));
	socket = new SocketProxy( "soc4.acpub.duke.edu", 8189, false);
    }

    public String[] arrayInit() {
	String[] temp = new String[100];	
	for (int i=0;i<temp.length;i++)
	    {
		temp[i] = "-1";
	    }
	return temp;
    }
    public String[] myArray = arrayInit();

    public String[] set(String[] m,int index, String n) {
	for (int j=0;j<m.length;j++)
	    if (j==index)
		m[j] = n;
	return m;
    }
    
    public String compute (String str) {
	String[] p = str.split(",");
	int index;
	Integer f = new Integer(p[0]);
	index = f.intValue();

	if ( p[3].equals("right") && (("-1".equals(myArray[index]))!=true))
	    {
		System.out.println("Information already computed");
		return myArray[index];
	    }
	else if (p[3].equals("right"))
	    {
		socket.writeLine(str);
		System.out.println("sent " + str + " to server");
		String ans = socket.readLine();
		myArray = set(myArray,index,ans);
		return myArray[index];
	    }
	else if (p[3].equals("left"))
	    {
		socket.writeLine(str);
		System.out.println("sent " + str + " to server");
		String ans = socket.readLine();
		return ans;
	    }
	else {
	    socket.writeLine(p[3]);
	    socket.dispose();
	    return "end communication";
	}
    }
}

class SocketProxy implements SocketInterface { // 1. Create a "wrapper" for a
   private Socket         socket;              //    remote, or expensive, or
   private BufferedReader in;                  //    sensitive target
   private PrintWriter    out;

   public SocketProxy( String host, int port, boolean wait ) {
      try {
         if (wait) {
            ServerSocket server = new ServerSocket( port );
            socket = server.accept();           // 2. Encapsulate the complexi-
         } else                                 //    ty/overhead of the target
            socket = new Socket( host, port );  //    in the wrapper
         in  = new BufferedReader( new InputStreamReader(
                  socket.getInputStream()));
         out = new PrintWriter( socket.getOutputStream(), true );
      } catch( IOException e ) { e.printStackTrace(); }
   }
   public String readLine() {
      String str = null;
      try { str = in.readLine();
      } catch( IOException e ) { e.printStackTrace(); }
      return str;
   }
   public void writeLine( String str ) {
      out.println( str );             // 4. The wrapper delegates to the target
   }
    public void dispose() {
       try { socket.close();
      } catch( IOException e ) { e.printStackTrace(); }
   }
}