import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;                                 
import java.text.*;

public class MonoAlphaSubCrack extends Applet
implements TextListener, ActionListener, WindowListener {

  static String title = "Monoalphabetic Substition Tool";

  Panel panDisplay = new Panel();
  Panel panKey = new Panel();

  Label       labTitle = new Label( title );
  TextArea    taDisplay = new TextArea( 25, 80 );
  Button      btnMakeKey = new Button( "make key" );
  Button      btnDumpKey = new Button( "dump key" );
  Button      btnDumpPlainKey = new Button( "dump key (p-sort)" );

  int numChars = 36;
  Label[]      label = new Label[numChars];
  TextField[]  pchar = new TextField[numChars];
  Label[]      count = new Label[numChars];

  String original_ciphertext=null;

  class CipherChar {
    public char pchar;
    public int count;
    public char guess;

    public CipherChar( char p ) {
      pchar = p;
      count = 1;
    }

    public boolean equals( Object obj ) {
      CipherChar cmp = (CipherChar)obj;
      if (cmp.pchar == pchar) {
        return true;
      } else {
        return false;
      }
    }
  }

  Vector cipherChars = new Vector( numChars );

  //***************************************************************************
  // Called by the browser or applet viewer to inform this applet that it has
  // been loaded into the system. It is always called before the first time that
  // the start method is called.
  public void init() {
    //setFont( new Font( "Courier", Font.PLAIN, 12 ) );

    labTitle.setFont( new Font( "Helvetica", Font.BOLD, 14 ) );
    setFont( new Font( "Courier", Font.PLAIN, 10 ) );
    taDisplay.setFont( new Font( "Courier", Font.PLAIN, 12 ) );

    // setup Panel One
    panDisplay.setBackground( Color.lightGray );

    GridBagConstraints c1 = new GridBagConstraints();
    GridBagLayout gridbag1 = new GridBagLayout();
    panDisplay.setLayout( gridbag1 );

    c1.fill = GridBagConstraints.BOTH;
    c1.gridwidth = GridBagConstraints.REMAINDER;
    c1.anchor = GridBagConstraints.NORTHWEST;
    gridbag1.setConstraints( taDisplay, c1 );
    panDisplay.add( taDisplay );

    c1.fill = GridBagConstraints.NONE;
    c1.gridwidth = 1;
    c1.anchor = GridBagConstraints.NORTHWEST;
    panDisplay.add( btnMakeKey );
    panDisplay.add( btnDumpPlainKey );

    c1.fill = GridBagConstraints.NONE;
    c1.gridwidth = GridBagConstraints.REMAINDER;
    c1.anchor = GridBagConstraints.NORTHWEST;
    panDisplay.add( btnDumpKey );

    btnMakeKey.addActionListener( this );
    btnDumpKey.addActionListener( this );
    btnDumpPlainKey.addActionListener( this );
    //btnMakeKey.setEnabled(false);


    // setup Key Panel
    Panel pans[] = new Panel[numChars];
    panKey.setBackground( Color.yellow );
    int scols = 8;
    int srows = (numChars/scols);
    if (numChars%scols>0) srows++;
    panKey.setLayout( new GridLayout(srows, scols*3) );
    for (int i=0; i<numChars; i++) {
      label[i] = new Label( "?" );
      pchar[i] = new TextField( 1 );
      count[i] = new Label( "0 (%.%)" );
      pchar[i].addTextListener( this );
      pans[i] = new Panel();
      pans[i].setLayout( new BorderLayout() );
      //pans[i].setLayout( new GridLayout(1, 3) );
      pans[i].add( label[i], "West" );
      pans[i].add( pchar[i], "Center" );
      pans[i].add( count[i], "East" );
      panKey.add( pans[i] );
    }

    taDisplay.append("IXDVMUFXLFEEFXSOQXYQVXSQTUIXWF*FMXYQVFJ*FXEFQUQXJFPTUFX\n");
    taDisplay.append("MX*ISSFLQTUQXMXRPQEUMXUMTUIXYFSSFI*MXKFJF*FMXLQXTIEUVFX\n");
    taDisplay.append("EQTEFXSOQXLQ*XVFWMTQTUQXTITXKIJ*FMUQXTQJMVX*QEYQVFQTHMX\n");
    taDisplay.append("LFVQUVIXM*XEI*XLQ*XWITLIXEQTHGXJQTUQXSITEFLQVGUQX*GXKIE\n");
    taDisplay.append("UVGXEQWQTHGXDGUFXTITXDIEUQXGXKFKQVXSIWQXAVPUFXWGXYQVXEQ\n");
    taDisplay.append("JPFVXKFVUPUQXQXSGTIESQTHGX*FXWFQFXSIWYGJTFXDQSFIXEFXGJP\n");
    taDisplay.append("UFXSITXRPQEUGXIVGHFITXYFSSFI*CXC*XSCWWFTIXSOQXCXYQTCXYI\n");
    taDisplay.append("ESFCX*FXCKVQFXVFUQTPUFXQXKI*UCXTIEUVCXYIYYCXTQ*XWCUUFTI\n");
    taDisplay.append("XLQFXVQWFXDCSQWWIXC*FXC*XDI**QXKI*IXEQWYVQXCSRPFEUCTLIX\n");
    taDisplay.append("LC*X*CUIXWCTSFTIXUPUUQX*QXEUQ**QXJFCXLQX*C*UVIXYI*IXKQL\n");
    taDisplay.append("QCX*CXTIUUQXQX*XTIEUVIXUCTUIXACEEIXSOQXTITXEPVJQCXDPIVX\n");
    taDisplay.append("LQ-XWCVFTXEPI*IXSFTRPQXKI*UQXVCSSQEIXQXUCTUIXSCEEIX*IX*\n");
    taDisplay.append("PWQXQVZXLFXEIUUIXLZX*ZX*PTZXYIFXSOQXTUVZUFXQVZKZWXTQX*Z\n");
    taDisplay.append("*UIXYZEEIRPZTLIXTZYYZVKQXPTZXWITUZJTZXAVPTZXYQVX*ZXLFEU\n");
    taDisplay.append("ZTHZXQXYZVKQWFXZ*UZXUZTUIXRPZTUIXKQLPUZXTITXZKQZXZ*SPTZ\n");
    taDisplay.append("XTIFXSFXZ**QJVNWWIXQXUIEUIXUIVTIXFTXYFNTUIXSOQXLQX*NXTI\n");
    taDisplay.append("KNXUQVVNXPTXUPVAIXTNSRPQXQXYQVSIEEQXLQ*X*QJTIXF*XYVFWIX\n");
    taDisplay.append("SNTUIXUVQXKI*UQXF*XDQXJFVBVXSITXUPUUQX*BSRPQXBX*BXRPBVU\n");
    taDisplay.append("BX*QKBVX*BXYIYYBXFTXEPEIXQX*BXYVIVBXFVQXFTXJFPXSIWB*UVP\n");
    taDisplay.append("FXYFBSRPQFTDFTXSOQX*XWBVXDPXEIYVBXTIFXVFSOFPEIXX*BXYBVI\n");
    taDisplay.append("*BXFTXSILFSQXQXQRPBUIV\n");

    setLayout( new BorderLayout() );
    add( panKey, "North" );
    add( panDisplay, "Center" );

  }

  //***************************************************************************

  // Called by the browser or applet viewer to inform this applet that it should
  // start its execution. It is called after the init method and each time the
  // applet is revisited in a Web page.
  public void start() {
  }

  //***************************************************************************

  // Called by the browser or applet viewer to inform this applet that it should
  // stop its execution. It is called when the Web page that contains this applet
  // has been replaced by another page, and also just before the applet is to be
  public void stop() {
  }

  //***************************************************************************

  // Called by the browser or applet viewer to inform this applet that it is being
  // reclaimed and that it should destroy any resources that it has allocated. The
  // stop method will always be called before destroy.
  public void destroy() {
  }

  //***************************************************************************

  // Called by the browser or applet viewer to get applet information
  public String getAppletInfo() {
    return title
    +"\n\nTool for decipherment of monoalphabetic substition ciphers\n\n"
    +"Author: Dav Coleman <dav@danger-island.com>\n"
    +"URL: http://www.danger-island.com/~dav/\n";
  }

  //*****************************************************************
  public void actionPerformed(ActionEvent evt) {
    if ( evt.getSource() == btnMakeKey ) {
      makeKeyPanel();
    } else if ( evt.getSource() == btnDumpKey ) {
      dumpKey();
    } else if ( evt.getSource() == btnDumpPlainKey ) {
      dumpPlainKey();
    }
  }

  //*****************************************************************
  public void textValueChanged(TextEvent e) {
    //System.out.println( e );
    if (original_ciphertext==null) {
      return;
    }
    for (int i=0; i<numChars; i++) {
      //System.out.println( "compare field "+i );
      if ( e.getSource() == pchar[i]) {
        String newtext = pchar[i].getText();
        char cipherchar = label[i].getText().charAt(0);
        char newchar=cipherchar;
        if (newtext.length()>0) {
          newchar = newtext.charAt( 0 );
        }
        //System.out.println( "**** match!" );
        String ciphertext = taDisplay.getText();
        int idx=-1;
        while ((idx = original_ciphertext.indexOf((int)cipherchar, idx+1))!=-1) {
          taDisplay.replaceRange( String.valueOf(newchar), idx, idx+1 );
        }
      }
    }
  }

  //***************************************************************************
  public void makeKeyPanel() {
    String ciphertext = taDisplay.getText();
    char c;
    int cipherCount = ciphertext.length();

    original_ciphertext = ciphertext;

    CipherChar cc = new CipherChar( '?' );
    int idx;
    for (int i=0; i<cipherCount; i++) {
      c = ciphertext.charAt(i);

      cc.pchar=c;
      if ((idx=cipherChars.indexOf(cc))!=-1) {
        CipherChar uc = (CipherChar)cipherChars.elementAt( idx );
        uc.count++;
      } else {
        CipherChar nc = new CipherChar(c);
        cipherChars.addElement((Object)nc);
      }
    }

    sortVector();

    if (cipherChars.size()<=numChars) {
      int i=0;
      double percent;
      NumberFormat format = NumberFormat.getInstance();
      ((DecimalFormat)format).applyPattern( "0.0" );

      for ( Enumeration en = cipherChars.elements(); en.hasMoreElements() ; i++) {
        cc = (CipherChar)en.nextElement();
        label[i].setText( String.valueOf( cc.pchar ) );
        percent = (double)cc.count/(double)cipherCount*100;
        String freq = cc.count+" ("+format.format(percent)+")";
        count[i].setText( String.valueOf( freq ) );
        System.out.println( cc.pchar+": "+cc.count+" of "+cipherCount+" ("+percent+")");
      }
    } else {
      System.err.println( "oops, lousy programmer didn't make numChars big'nuff" );
    }
  }

  //***************************************************************************
  // cheap and slutty sort routine
  public void sortVector() {
    Vector newVec = new Vector( numChars );
    int high;
    int ptr;
    CipherChar cc=null;

    Enumeration en = cipherChars.elements();
    while (en.hasMoreElements()) {
      high = 0;
      ptr = -1;
      int i=0;                         

      // find highest
      for ( Enumeration en2 = cipherChars.elements(); en2.hasMoreElements() ; i++) {
        cc = (CipherChar)en2.nextElement();
        if (cc.count>high) {
          ptr = i;
          high = cc.count;
        }
      }

      if (ptr>-1) {
        cc = (CipherChar)cipherChars.elementAt(ptr);
        // add to newVec
        newVec.addElement((Object)cc);
        // remove from cipherChars
        cipherChars.removeElementAt(ptr);
      }
      en = cipherChars.elements();
    }
    cipherChars = newVec;
  }


  //***************************************************************************
  public void dumpKey() {
    char cipherchar, guesschar;

    System.out.println( "KEY DUMP:" );
    for ( int i=0; i<numChars ; i++) {
      cipherchar = (label[i].getText()).charAt(0);
      if (cipherchar!='?') {
        if ((pchar[i].getText()).length()>0) {
          guesschar=pchar[i].getText().charAt(0);
        } else {
          guesschar=' ';
        }
        System.out.println( ""+guesschar+'='+cipherchar );
      }
    }
  }

  //***************************************************************************
  public void dumpPlainKey() {
    char cipherchar, guesschar, plainchar;
    String alphabet = "abcdefghijklmnopqrstuvwxyz";
    int count = alphabet.length();

    System.out.println( "KEY DUMP:" );
    for ( int i=0; i<count; i++) {
      plainchar = alphabet.charAt(i);
      System.out.print( String.valueOf(plainchar) );
      for ( int c=0; c<numChars; c++) {
        cipherchar = (label[c].getText()).charAt(0);
        if (cipherchar!='?') {
          if ((pchar[c].getText()).length()>0) {
            guesschar=pchar[c].getText().charAt(0);
            if (guesschar==plainchar) {
              System.out.print( " "+cipherchar );
              break;
            } 
          } 
        }
      }
      System.out.println();
    }
  }

  //***************************************************************************
  //***************************************************************************
  //***************************************************************************

  static public void main( String[] args ){
    MonoAlphaSubCrack me = new MonoAlphaSubCrack();
    me.init();

    Frame f = new Frame( title );
    f.add( me );
    f.pack();
    f.addWindowListener( me );
    f.show();

  }
  public void windowClosing(WindowEvent event) {
    System.exit(0);
  }
  public void windowClosed(WindowEvent event) {}
  public void windowDeiconified(WindowEvent event) {}
  public void windowIconified(WindowEvent event) {}
  public void windowActivated(WindowEvent event) {}
  public void windowDeactivated(WindowEvent event) {}
  public void windowOpened(WindowEvent event) {}


}