package telnet;

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import javax.microedition.io.*;
import java.io.*;
import ssh.*;

/* This file is part of "Telnet Floyd".
 *
 * (c) Radek Polak 2003-2004. All Rights Reserved.
 *
 * Please visit project homepage at http://phoenix.inf.upol.cz/~polakr
 *
 * --LICENSE NOTICE--
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 * --LICENSE NOTICE--
 *
 */

/**
 * Main class for whole application. Here are all important variables defined
 * as public static members, so that they can be easily accessed. See also
 * method run, that handles main telnet loop.
 */

public class Telnet
    extends MIDlet
    implements Runnable {

  private static Telnet instance;

  /** handles with data from telnet and with data from user */
  public static vt320 emulation;
  /** user interface */
  public static MidletTerminal terminal;


  public static Console console=new Console();

  /**
   * We will collect here data for writing. Data will be sent when nothing is
   * in input stream, otherwise midlet hung up.
   * @see #run
   */
  public static byte[] output = new byte[16];  // this will grow if needed

  /**
   * Number of bytes to be written, from output array, because it has fixed
   * lenght.
   */
  public static int outputCount = 0;

  public static SshIO sshIO = null;

  public static int traffic = 0;

  /** Time to sleep between checks for new input from connection */
  public static int sleepTime = 1000;

  /** After this count of cycles without communication on connection we will send something just to keep connection alive */
  public static int keepAliveCycles = 300; // 5 minutes for sleepTime=1000

  /**
   * Holds the socket connetion object (from the Generic Connection
   * Framework) that is the basis of this connection.
   */
  public static StreamConnection socket;

  /**
   * Holds the InputStream associated with the socket.
   */
  private static DataInputStream in;

  /**
   * Holds the OutputStream associated with the socket.
   */
  public static DataOutputStream out;

  public static String host;

  public static Thread reader;

  public static boolean useColors;

  /** Constructor */
  public Telnet() {

//    System.out.println( Action.EXIT_APP.hashCode() );
    instance = this;
    useColors = getDisplay().isColor();

    // we now create a new terminal that is used for the system
    // if you want to configure it please refer to the api docs
    emulation = new vt320();
    terminal = new MidletTerminal(emulation);
    sshIO = new SshIO();
  }

  /** Main method */
  public void startApp() {
    setDisplay( (Displayable) terminal);
    reader = new Thread( this );
  }
  /** Handle pausing the MIDlet */
  public void pauseApp() {
  }

  /** Handle destroying the MIDlet */
  public void destroyApp(boolean unconditional) {
  }

  /** Quit the MIDlet */
  public static void quitApp() {
    instance.destroyApp(true);
    instance.notifyDestroyed();
    instance = null;
  }

  public static void setDisplay(Displayable display) {
    instance.getDisplay().setCurrent(display);
  }

  public Display getDisplay() {
    return Display.getDisplay(this);
  }

  /**
   * Continuously read from remote host and display the data on screen.
   */
  public void run() {

    int n;
    int noInputCycles = 0;


    // Connect
    try
    {
      emulation.putString("Connecting...");
      terminal.redraw();
      socket = (StreamConnection) Connector.open("socket://"+host+":22",
                                                 Connector.READ_WRITE, false);
      in = socket.openDataInputStream();
      out = socket.openDataOutputStream();
      emulation.putString("OK");
    }
    catch( Exception e )
    {
      emulation.putString("FAILED");
    }
    emulation.putString("\n\r");
    terminal.redraw();

    // Main loop
    try {
      for(;;) {

        n = in.available();

        if( n <= 0 )
        {
          if( outputCount > 0 )  // Writing
          {
            traffic += outputCount;
            out.write(output, 0, outputCount);
            outputCount = 0;
          }
          else  // Sleeping
          {
            Thread.sleep(sleepTime);
            if( noInputCycles++ > keepAliveCycles )
            {
              emulation.keyTyped( 0, 'a', 0 ); // BAD HACK - SHOULD SEND AYA...
              emulation.keyPressed( 8, '\b', 0 );
              noInputCycles=0;
            }
          }
        }
        else // Reading
        {
          byte[] b = new byte[n];
          in.read( b, 0, n );
          byte[] tmp = new byte[n];
          System.arraycopy(b, 0, tmp, 0, n);
          byte[] buffer = sshIO.handleSSH(tmp);
          if(buffer != null && buffer.length > 0)
          {
            if (n > 0) {
              try {
                emulation.putString(new String(buffer));
                terminal.redraw();
              }
              catch (Exception e) {}
            }
          }
           noInputCycles = 0;
        }
      } // while( connected )
    }
    catch (Exception e) {
      console.append( e.getMessage());
    }
  }
}