import rita.*;
import guicomponents.*;
import java.lang.reflect.*;
import org.w3c.dom.*;
import org.w3c.dom.html.*;




// CHAPTER 1: CONFIGURABLE VARIABLES AND VARIABLE OBJECTS

// how high (tall) the word labels are
int LABELHEIGHT = 20;

// how much horizontal space is between word labels 
int SPACING = 10;

// how much space is between rows of labels (i.e. lines of poetry)
int SHIFTHEIGHT = 30;


// how far the interaction options are from the top
int OPTIONS_DISTANCE_FROM_TOP = 250;

// how far the verse buttons are from the top  
int VERSE_DISTANCE_FROM_TOP = 275;


// this is the initial data model
// NOTE: for a standalone app, remove URL reference
String dataFolder = "http://www.eddeaddad.net/egnoetry/";
//String dataFolder = "";
String dataShakespeare = "shakespeare-sonnets.txt";
String dataCarroll = "carroll-aliceInWonderland.txt";
String dataConrad = "conrad-heartOfDarkness.txt";
String nameShakespeare = "Shakespeare Sonnets";
String nameCarroll = "Alice In Wonderland";
String nameConrad = "Heart Of Darkness";
String fileToUse = dataCarroll;
String oldFileToUse = dataCarroll;


// the color of the control buttons
int controlButtonsColor = #FCBDD8;

// the color of the word buttons  
int wordButtonColor = #8FECF0;


// the verse, which is made up of lines 
List verse = new ArrayList();

// the number of lines in the initial verse
int linesInVerse= 4;

// maximum possible number of lines in verse
final int MAX_LINES_IN_VERSE = 8;

final String FORM_FREEVERSE = "free verse";
final String FORM_QUATRAIN = "Quatrain";
final String FORM_EHAIKU = "eHaiku";
String currentForm = FORM_FREEVERSE;



// an bigram model  
RiMarkov bigramModel;

// a list of words that have been generated from the model, and are ready to use
List wordsFromModel = new ArrayList();

// a random number generator
Random generator = new Random();

// the text being displayed at the top
RiText displayTop[] = new RiText[MAX_LINES_IN_VERSE];

// the button that changes model
GButton changeModelButton;


// CHAPTER 2: STARTING UP

int LEFT_MARGIN = 50;


void setup() {
  // the size of the display area
  size(900,600);

  // instantiate the bigram model  
  bigramModel = new RiMarkov(this, 2);  
  bigramModel.setUseSmoothing(false);
  bigramModel.loadFile(dataFolder + fileToUse); 


  // this is the button to regenerate the whole poem
  GButton regenerateButton = new GButton(this, "Regenerate Verse  ", LEFT_MARGIN, OPTIONS_DISTANCE_FROM_TOP, getWidth("Regenerate "), LABELHEIGHT );  
  regenerateButton.setTextAlign(GAlign.CENTER);
  regenerateButton.setTextAlign(GAlign.MIDDLE);  
  regenerateButton.setColours(controlButtonsColor,controlButtonsColor,controlButtonsColor);
  regenerateButton.tag = "regenerate";  

  // this is the button to change the poetic form
  // probably should be a combobox, but I had problems with g4p's GCombo
  // and anyways it keeps the code simple
  GButton changeFormButton = new GButton(this, "Form: " + FORM_FREEVERSE + "  ", 180, OPTIONS_DISTANCE_FROM_TOP, getWidth(FORM_FREEVERSE), LABELHEIGHT );  
  changeFormButton.setTextAlign(GAlign.CENTER);
  changeFormButton.setTextAlign(GAlign.MIDDLE);  
  changeFormButton.setColours(controlButtonsColor,controlButtonsColor,controlButtonsColor);
  changeFormButton.tag = "formchange";  


  // this is the button to change the language model
  // probably should be a combobox, but I had problems with g4p's GCombo
  // and anyways it keeps the code simple
  changeModelButton = new GButton(this, "Model: " + nameCarroll + "  ", 300, OPTIONS_DISTANCE_FROM_TOP, 200, LABELHEIGHT );  
  changeModelButton.setTextAlign(GAlign.CENTER);
  changeModelButton.setTextAlign(GAlign.MIDDLE);  
  changeModelButton.setColours(controlButtonsColor,controlButtonsColor,controlButtonsColor);
  changeModelButton.tag = "modelchange";


  // this is the button to try to import text from a web page (assuming an applet context)
  GButton importButton = new GButton(this, "Import Model ", 510, OPTIONS_DISTANCE_FROM_TOP, 90, LABELHEIGHT );
  importButton.setTextAlign(GAlign.CENTER);
  importButton.setTextAlign(GAlign.MIDDLE);  
  importButton.setColours(controlButtonsColor,controlButtonsColor,controlButtonsColor);
  importButton.tag = "importbutton";


  // this is the button to try to export to a web page (assuming an applet context)
  GButton exportButton = new GButton(this, "Export Verse ", 610, OPTIONS_DISTANCE_FROM_TOP, 90, LABELHEIGHT );
  exportButton.setTextAlign(GAlign.CENTER);
  exportButton.setTextAlign(GAlign.MIDDLE);  
  exportButton.setColours(controlButtonsColor,controlButtonsColor,controlButtonsColor);
  exportButton.tag = "exportbutton";


  // call the method that creates the first draft of the poem
  createVerse();


  // we're not doing animation, so we don't need the display area to be continually redrawn  
  noLoop();  
}


// draw the display
void draw(){
  background(250);
}


// CHAPTER 3: CREATING A VERSE FROM THE LANGUAGE MODEL AND PRINTING IT AS GBUTTONS


// create a verse,
// which is made up of several lines, 
// where each line has several GButtons containing changeable words
void createVerse() {
  List tempRow = new ArrayList();
  boolean isLastRow = false;
  String displayLine = new String();
  String theLine = new String();    

  if ( currentForm == FORM_FREEVERSE ) {
    // there will be 2-8 lines, randomly determined
    linesInVerse = generator.nextInt( 7 ) + 2;

  } else if ( currentForm == FORM_QUATRAIN ) {
    linesInVerse = 4;
  } else if ( currentForm == FORM_EHAIKU ) {
    linesInVerse = 3;
  }

    // get rid of old lines, if the previous verse had more lines than this one
    for ( int x=linesInVerse; x<MAX_LINES_IN_VERSE; x++ ) {
      displayLineAtTop( x, "" );
    }

  
  // make each line of the poem  
  for ( int x=0; x<linesInVerse; x++ ) {

    if ( x == linesInVerse-1) {
      isLastRow = true;
    }    
    
    int numberOfWords = 0;
    if ( currentForm == FORM_FREEVERSE ) {
      
      numberOfWords = generator.nextInt( 10 ) + 1;

    } else if ( currentForm == FORM_QUATRAIN ) {

      numberOfWords = 10;
      
    } else if ( currentForm == FORM_EHAIKU ) {
      
      if ( x==0 ) {
        numberOfWords = 4;
      } else if ( x==1 ) {
        numberOfWords = 7;
      } else {
        numberOfWords = 4;
      }
    }

    checkForModelChange();
    
    theLine = getWordsFromModel(numberOfWords, isLastRow);    

    int yPos = SHIFTHEIGHT * (x+1) + VERSE_DISTANCE_FROM_TOP;
    tempRow = createListOfButtonsFromString( theLine, yPos, x, isLastRow );

    // if the next line will start with punctuation, put it here instead
    // (but don't do that if this is the last line)
    String nextWord = getNextWordFromModelIfPunctuation();  
    if ( ! nextWord.equals("") && ! isLastRow ) {
      // figure out xPos
      GButton tempButton = (GButton)tempRow.get( tempRow.size()-1 );
      int xPos = tempButton.getX() + tempButton.getWidth() + SPACING;

      tempRow.add( createButton( nextWord, xPos, yPos, x, tempRow.size(), getWidth( nextWord ) ) );  
      theLine = theLine + nextWord;
    }

    verse.add(tempRow);
    
    displayLineAtTop( x, theLine );
  }
}


void checkForModelChange() {

  if ( ! fileToUse.equals(oldFileToUse) ) {

    // regenerate model
    bigramModel = new RiMarkov(this, 2);  
    bigramModel.setUseSmoothing(false);
    bigramModel.loadFile(dataFolder + fileToUse); 
    
    // empty "next words generated from model" string
    wordsFromModel = new ArrayList();    

    oldFileToUse = fileToUse;
  }
}



void displayLineAtTop( int lineIndex, String line ) {

    // display a non-button version of the poem at the top of the page
    int yLocation = 20 * lineIndex + 50;
    String displayLine = new String(line);
    displayLine = displayLine.replaceAll(" \\.", ".");
    displayLine = displayLine.replaceAll(" \\?", "?");
    displayLine = displayLine.replaceAll(" !", "!");
    displayLine = displayLine.replaceAll(" :", ":");
    displayLine = displayLine.replaceAll(" ;", ";");
    displayLine = displayLine.replaceAll(" ,", ",");
    // if there's no RiText object there, create one
    // if there IS, then replace the text
    if (displayTop[lineIndex] == null) {
      displayTop[lineIndex] = new RiText(this, displayLine, LEFT_MARGIN, yLocation);
    } else {
      RiText tempRiText = displayTop[lineIndex];
      tempRiText.setText(displayLine);
    }

}


// get an arbitrary number of words from the language model
String getWordsFromModel( int i, boolean isLastRow ) {  

  StringBuffer toReturn = new StringBuffer();
  
  for ( int x=0; x<i; x++ ) {

    String wordToAdd = getOneWordFromModel();
    
    // if this is the last word of the last line, 
    // and the last word is not a terminal punctuation, 
    // then change it
    if ( isLastRow && x==i-1 && ! ( wordToAdd.equals(".") || wordToAdd.equals("?") || wordToAdd.equals("!")  ) ) {
      // if the last word is a non-terminal punctuation, replace it
      if ( wordToAdd.equals(",") || wordToAdd.equals(";") || wordToAdd.equals(":") || wordToAdd.equals("--") ) {
        wordToAdd = ".";
      } else {
        // otherwise, add the punctuation
        wordToAdd = wordToAdd + " .";
      }
    }
    
    toReturn.append( wordToAdd + " ");
  }
  
  return toReturn.toString().trim();
}


// TO DO: merge above?
// get a word from the list of words generated from the model,
// remembering the current position in the line
String getOneWordFromModel() {

  // if there is no word in the buffer of words that have been already generated,
  // then generate some more words.
  if ( wordsFromModel == null || wordsFromModel.size() < 1 ) {
    
    String[] aL = getLineAsArrayFromModel();
    
    wordsFromModel.addAll(Arrays.asList(aL));
  }
  
  // then return the first words, removing it from the list of generated words
  return wordsFromModel.remove(0).toString().trim();
}



// get a new line, as an array of strings
String[] getLineAsArrayFromModel(){

    String line = bigramModel.generateSentence();
    
    // make sure there is a space before certain punctuations, so they become their own buttons
    // (listed individually instead of as one regex so you can comment them out one at a time if need be)
    line = line.replaceAll("\\.", " .");
    line = line.replaceAll("\\?", " ?");
    line = line.replaceAll("!", " !");
    line = line.replaceAll(":", " :");
    line = line.replaceAll(";", " ;");
    line = line.replaceAll(",", " ,");

    // remove all parentheses and brackets
    line = line.replaceAll("\\)", "");
    line = line.replaceAll("\\(", "");
    line = line.replaceAll("\\]", "");
    line = line.replaceAll("\\[", "");

    // make sure we haven't accidentally created two spaces in sequence
    line = line.replaceAll("\\s\\s", " ");
    
    String[] aL = line.split("\\s");  

    return aL;
}




// given a string, break it into a list of buttons, and display them
List createListOfButtonsFromString( String theLine, int yPos, int row, boolean isLastRow ) {

  List toReturn = new ArrayList();

  int xPos = LEFT_MARGIN;
  
  String[] aS = theLine.split(" ");
      
  for ( int x=0; x<aS.length; x++ ) {
      
    String wordToShow = aS[x];  
    int labelLength = getWidth( wordToShow );
    
    toReturn.add( createButton( wordToShow, xPos, yPos, row, x, labelLength ) );
    
    xPos += labelLength + SPACING;
  }


  return toReturn;
}


// look at the next word from the language model.  if it's punctuation, then get it.
// otherwise, return ""
String getNextWordFromModelIfPunctuation() {
  String toReturn = "";  
  
  // this is kind of an inefficient way of doing it, 
  // but I wanted to minimize the amount of written code
  
  // get a word from the model
  String toConsider = getOneWordFromModel().trim();
    
  // if it's punctuation, return it
  if ( toConsider.equals(".") || toConsider.equals("?") || toConsider.equals("!") ||
        toConsider.equals(",") || toConsider.equals(";") || toConsider.equals(":") ||
        toConsider.equals("--")    ) {
    
    toReturn = toConsider;

  } else {
    
    // if not, put it back
    wordsFromModel.add(0, toConsider);
  }
    
  return toReturn;
}



// create a button
GButton createButton( String text, int xPos, int yPos, int row, int wordNumber, int labelLength ) {

  GButton tempGButton;
  
  tempGButton = new GButton(this, text + "   ", xPos, yPos, labelLength, LABELHEIGHT );  
  tempGButton.setTextAlign(GAlign.CENTER);
  tempGButton.setTextAlign(GAlign.MIDDLE);  
  tempGButton.setColours(wordButtonColor,wordButtonColor,wordButtonColor);  
  // create a tag for this button with the row and word number indexes of the label/word
  // we will refer to this later when re-generating a particular word
  tempGButton.tag = row + "," +  wordNumber;  
  
  return tempGButton;
}

// given a string, figure out how wide the label should be
int getWidth( String s ) {
  
  return s.length() * 10 + 10;
}



// CHAPTER 4: BUTTON EVENT METHODS


// handle the button clicks
void handleButtonEvents(GButton button) { 
  
  // first, see if we need to regenerate the whole verse
  if ( button.tag.equals("regenerate") ) {

    doButtonRegenerateAll();
    
  } else if ( button.tag.equals("formchange") ) {
    
    doButtonFormChange(button);

  } else if ( button.tag.equals("modelchange") ) {

    doButtonModelChange(button);
    
  } else if ( button.tag.equals("exportbutton") ) {

    exportPoem();
    
  } else if ( button.tag.equals("importbutton") ) {

    buildCustomLanguageModel( button );

  } else {
    
    doButtonRegenerateInvididualWord( button );
  }  
}


void doButtonModelChange( GButton button ) {
  
  String buttonOldText = button.getText();

  //  TO DO: allow to cycle through custom-built model?

  if ( button.getText().matches(".*" + nameCarroll + ".*") ) {
    fileToUse = dataShakespeare;
    button.setText( "Model: " + nameShakespeare );
  } else if ( button.getText().matches(".*" + nameShakespeare + ".*") ) {
    fileToUse = dataConrad;
    button.setText( "Model: " + nameConrad );
  } else if ( button.getText().matches(".*" + nameConrad + ".*") ) {
    fileToUse = dataCarroll;
    button.setText( "Model: " + nameCarroll );
  } else {
    fileToUse = dataShakespeare;
    button.setText( "Model: " + nameShakespeare );
  }

  redraw();
  
}

void doButtonRegenerateAll() {
  
    // delete the old GButtons
    // TO DO: I don't think this is the best way to do this...
    for ( int x=0; x<linesInVerse; x++ ) {
      List tempLineDelete = (ArrayList)verse.get(x);
      for ( int y=0; y<tempLineDelete.size(); y++ ) {
        GButton buttonDeleting = (GButton)tempLineDelete.get(y);
        buttonDeleting.setEnabled(false);
        buttonDeleting.setVisible(false);
        buttonDeleting = null;
      }
    }
    
    // create a new language model, verse data structure, and redraw
    wordsFromModel = new ArrayList();
    verse = new ArrayList();    
    createVerse();
    redraw();
  
}



void doButtonFormChange(GButton button) {

  String buttonOldText = button.getText();
  if ( button.getText().matches(".*free verse.*") ) {
    currentForm = FORM_QUATRAIN;
    button.setText(buttonOldText.replace("free verse", "Quatrain"));
  } else if ( button.getText().matches(".*Quatrain.*") ) {
    currentForm = FORM_EHAIKU;
    button.setText(buttonOldText.replace("Quatrain", "eHaiku"));
  } else if ( button.getText().matches(".*eHaiku.*") ) {
    currentForm = FORM_FREEVERSE;
    button.setText(buttonOldText.replace("eHaiku", "free verse"));
  }

  redraw();
}


void doButtonRegenerateInvididualWord(GButton button) {

  int rowIndex = 0;
  int wordIndex = 0;
  
  String row = new String();
  String word = new String();
  String newWord = new String();

  checkForModelChange();

  // look at the tag.  get row and word index of the label from the tag
  try {
    String[] aTag = button.tag.split(",");    
    
    rowIndex = Integer.parseInt(aTag[0]);
    wordIndex = Integer.parseInt(aTag[1]);
    
  } catch ( Exception e ) {
    println("error identifying word");
    return;
  }
    
  // get a reference to the Line list and word
  // get a reference to the word/button toBeReplaced
  List tempLine = (ArrayList)verse.get(rowIndex);
  GButton buttonChanging = (GButton)tempLine.get(wordIndex);

  // figure out the new word

  // if the button is first in the poem...
  if ( wordIndex == 0 && rowIndex == 0 ) {
    
    // generate a new sentence, and take the first word
    String[] aLine = getLineAsArrayFromModel();
    newWord = aLine[0];
    
  // if it's the very last button in the poem, which will be punctuation
  } else if ( wordIndex == tempLine.size()-1 && rowIndex == verse.size()-1 ) {

    // if this is the last line of the poem, just cycle through terminal punctuation
    // this is kind of cheating, but in this app it's not worth the bother to check  
    // the corpus for actual terminal punctuation...
    String changingFinalPunct = buttonChanging.getText().trim();
    if ( changingFinalPunct.equals(".") ) {
      newWord = "!";
    } else if ( changingFinalPunct.equals("!") ) {
      newWord = "?";
    } else if ( changingFinalPunct.equals("?") ) {
      newWord = ".";
    }
    
  // it's not the very first and not the very last button in the poem
  } else {
    
    // figure out the previous and next words
    
    // if the current word is the last of a line,
    // then look at the first word of the next line for the next token
    String nextWord = new String();
    if ( wordIndex == tempLine.size()-1 ) {
      List tempLine2 = (ArrayList)verse.get(rowIndex+1);
      nextWord = ((GButton)tempLine2.get(0)).getText().trim();
    } else {
      nextWord = ((GButton)tempLine.get(wordIndex+1)).getText().trim();
    }
  
    // if the current word is the first of a line,
    // then look at the last word of the previous line for the next token
    String prevWord = new String();
    if ( wordIndex == 0 ) {
      List tempLine2 = (ArrayList)verse.get(rowIndex-1);
      prevWord = ((GButton)tempLine2.get( tempLine2.size()-1 )).getText().trim();
    } else {
      prevWord = ((GButton)tempLine.get(wordIndex-1)).getText().trim();
      }
  
    // look for a (n-1, completion, n+1)
    String[] wordPre = { prevWord };
    String wordChanging = buttonChanging.getText().trim();
    String[] wordPost = { nextWord };
    //println( "pre: " + wordPre[0] );  
    //println( "changing: " + wordChanging );  
    //println( "post: " +  wordPost[0] );  
    String[] completions = bigramModel.getCompletions(wordPre, wordPost);  
    
    // see if you found a (n-1, completion, n+1)
    if ( completions != null && completions.length > 1) {
      
      println("number of completions: " + completions.length );
      
      int numberToPick = generator.nextInt( completions.length );
  
      newWord = completions[numberToPick];
      //println("the completion is: " + newWord );
  
    } else {

      // next, see if you found an (n-1, completion)    
      completions = bigramModel.getCompletions(wordPre);  
    
      if ( completions != null && completions.length > 0) {
  
        println("number of n-1 completions: " + completions.length );
        
        int numberToPick = generator.nextInt( completions.length );
    
        newWord = completions[numberToPick];
  
        //println("the n-1 completion is: " + newWord );
      }
      
    }
    
    // if not, just use the original word
    if ( completions == null || completions.length ==   0) {
      newWord = wordChanging;
      println("there are no completions");
    }

  }


  // now that we've figured out the new word...

  // set the button's new width and text
  buttonChanging.setWidth( getWidth( newWord ) ); 
  buttonChanging.setText(newWord + " ");
  
  int newXPos = buttonChanging.getX() + getWidth( newWord ) + SPACING;    

  // shift the following buttons if need be
  for ( int i=wordIndex+1; i<tempLine.size(); i++ ) {

    // get a reference to the button being looked at
    buttonChanging = (GButton)tempLine.get(i);

    // change the width of the current button 
    buttonChanging.setX( newXPos ); 

    // figure out what the next width will be    
    String textOfCurrentWord = ((GButton)tempLine.get(i)).getText().trim();    
    newXPos += getWidth( textOfCurrentWord ) + SPACING;
  }

  // re-do the line of text at top
  displayLineAtTop( rowIndex, getLineOfVerseText(rowIndex) );


  // redraw the screen to show the changes
  redraw();    
}


// get the text of a line from the verse data structure
String getLineOfVerseText( int rowIndex ) {
  
  StringBuffer toReturn = new StringBuffer();
  List tempRow = (ArrayList)verse.get(rowIndex);
  
  for ( int i=0; i<tempRow.size(); i++) {
    GButton tempGButton = (GButton)tempRow.get(i);
    toReturn.append( tempGButton.getText().trim() + " " );
  }
  
  return toReturn.toString();
}



void buildCustomLanguageModel( GButton button ) {

  try {
    // get HTML document and look for the textarea
    Class c = Class.forName("com.sun.java.browser.plugin2.DOM");
    Method m = c.getMethod("getDocument", new Class[] { java.applet.Applet.class });
    HTMLDocument doc = (HTMLDocument) m.invoke(null, new Object[] { this });
    HTMLBodyElement body = (HTMLBodyElement) doc.getBody();
    seekModelText(body);

    // need at least enough characters for the model name
    if ( newLanguageModelCorpus.length() > 18 ) {
      
      newLanguageModelName = newLanguageModelCorpus.substring(0,17) + "...";
      // TO DO: coordinate this better with file-reading language building
      
      // regenerate model
      bigramModel = new RiMarkov(this, 2);  
      bigramModel.setUseSmoothing(false);
      bigramModel.loadText(newLanguageModelCorpus); 
      
      // empty "next words generated from model" string
      wordsFromModel = new ArrayList();      
      
      changeModelButton.setText( "Model: " + newLanguageModelName );

      redraw();
    }

  } catch (Exception e) {
    e.printStackTrace();
  }
}


String newLanguageModelCorpus = "";
String newLanguageModelName = "";

void seekModelText(Node root ) {

  if (root instanceof Element) {
    // if we've found the textarea, look through the children to get the text in the textarea
    if ( ((Element) root).getTagName().equals("TEXTAREA") ) {
      HTMLTextAreaElement h = (HTMLTextAreaElement)root;
      newLanguageModelCorpus = h.getValue().trim();
      //println( "length of data model: " + dataModel.length() );
      //println( "last several characters: " + dataModel.substring(dataModel.length()-20,dataModel.length()-1) );
      //println( "data model is: " + h.getValue() );
      //println( "data model is: " + root.getValue() );
    }
  }

  if (root.hasChildNodes()) {
    NodeList children = root.getChildNodes();
    if (children != null) {
      for (int i = 0; i < children.getLength(); i++) {
        seekModelText(children.item(i));
      }
    }
  }
}



// attempts to export the poem into a web page
// by calling a javascript function
void exportPoem() {

  String poemAsLine = new String();
  
  for (int i=0; i<verse.size(); i++ ) {
    poemAsLine = poemAsLine + getLineOfVerseText(i) + "<br>";
  }
    
  try {

    String urlEncodedPoem = URLEncoder.encode(poemAsLine.toString(),"UTF-8");
    
    java.applet.AppletContext context = getAppletContext();
    if ( context != null ) {
      AppletContext a = getAppletContext();
      URL url = new URL("http://www.eddeaddad.net/eGnoetry/output.html?" + urlEncodedPoem);
      a.showDocument(url,"_blank");
    }
  
  } catch (Exception e) {
      println("unable to export");
  }

}