package org.example.textdemo;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import android.util.Log;

/**
 * WikiRawTextParser ist eine Klasse zum Parsen von MediaWiki RawTexten. 
 * Er entfernt interne Links und trennt den Text nach ‹berschriften.
 * Dabei wird angenommen das der Text nicht mit einer ‹berschrift anf‰ngt sondern mit normalen Text.
 * Dieser erste Text erh‰lt die ‹berschrift "Deckblatt".
 *
 */
public class WikiRawTextParser {
	private ArrayList<String> textliste;
	private ArrayList<String> headerliste;
	private boolean geladen;

	/**
	 * Konstruktor
	 */
	public void __construct() {		
		geladen = false;
	}

    /**
     * Lisst die Daten aus der Textdatei aus und gibt sie als String zur¸ck
     * 
     * @param InputStream inputStream
     * @return boolean
     */
    public boolean LoadRawTextFromRessourceFile(InputStream inputStream) {
    	// InputStream inputStream = getResources().openRawResource(R.raw.he);
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();        
        int i;
        try {
        	i = inputStream.read();
        	while (i != -1) {
        		byteArrayOutputStream.write(i);
        		i = inputStream.read();
        	}
        	inputStream.close();
        } catch (IOException e) {
        	e.printStackTrace();
        	return false;
        }     
        return Rawtextparsen(byteArrayOutputStream.toString());
     }
	
    /** 
     * Bekommt Die Daten aus einem String
     * 
     * @param String rawtextstring
     * @return boolean
     */
    public boolean LoadRawTextFromString(String rawtextstring) {		
		return Rawtextparsen(rawtextstring);
	}
    
	/**
	 * Rawdaten aufbereiten und in header und text aufteilen
	 *  
	 * @param s
	 * @return
	 */
    private boolean Rawtextparsen(String s) {
		textliste = new ArrayList<String>();
        headerliste = new ArrayList<String>();
        String tempstring;
        Pattern pat;
        Matcher mat;
        
        // Daten aufbereiten
        s = s.replaceAll("===", "=="); // ‹berschriften 2 werden zu ‹berschriften 1
        s = s.replaceAll("\\[\\[[^\\]]*\\|", ""); // Entferne Linkmarkierungen
        s = s.replaceAll("\\[\\[", ""); // Entferne Linkmarkierungen
        s = s.replaceAll("\\]\\]", ""); // Entferne Linkmarkierungen
        s = s.replaceAll("\\{\\{", ""); // Entferne Vorlagenmarkierungen
        s = s.replaceAll("\\}\\}", ""); // Entferne Vorlagenmarkierungen        
        s = s.replaceAll("\\r\\n", "<br>"); // Zeilenumbruch
        s = s.replaceAll("\\r", "<br>"); // Zeilenumbruch
        s = s.replaceAll("\\n", "<br>"); // Zeilenumbruch
        // In HTML Konvertieren
        pat = Pattern.compile("'''(.+?)'''"); // Fett
        mat = pat.matcher(s);
        while(mat.find()) { 
        	tempstring = mat.group(0); 
        	tempstring = tempstring.replaceAll("'''", "");
        	tempstring = "<b>"+tempstring+"</b>";
        	s = s.replaceAll(mat.group(0), tempstring);
        }
        pat = Pattern.compile("''(.+?)''"); // Kursiv
        mat = pat.matcher(s);
        while(mat.find()) { 
        	tempstring = mat.group(0); 
        	tempstring = tempstring.replaceAll("''", "");
        	tempstring = "<i>"+tempstring+"</i>";
        	s = s.replaceAll(mat.group(0), tempstring);
        }        
        
        // nach ‹berschriften trennen
        String[] sarray = s.split("==");        
        Log.v(null, sarray.length+" gefundene Eintr‰ge");
        // F¸lle die ArrayListen
        for (int i=0; i<=(sarray.length / 2); i++) {
        	Log.v(null, "F¸lle Seite"+i);
        	if (i>0) {
        		if ((((i-1)*2)+1)<sarray.length) {
        			headerliste.add(i, sarray[((i-1)*2)+1].trim());
        		} else { // Die erste ‹berschrift ist "Deckblatt" da es mit Text anf‰ngt und nicht mit einer ‹berschrift
        			Log.v(null, "Keine ‹berschrift");         			
        		}
        	} else {
        		headerliste.add(i, "Deckblatt");
        	}        	
        	if ((i*2)<sarray.length) {        		
        		textliste.add(i, sarray[i*2].trim());
    		} else {
    			Log.v(null, "Kein Inhalt");         			
        	}
        }
       geladen = true;
       return geladen;
    }
	
    /**
     * Gibt eine Arrayliste mit allen geparsten Texten zur¸ck.
     * Sollte noch keine Load... funktion aufgerufen worden sein wird null zur¸ckgegeben.
     *  
     * @return ArrayList<String>
     */
	public ArrayList<String> getText() {
		if (geladen==true) {
			return textliste;
		} else {
			return null;
		}
	}
	
	/**
	 * Gibt eine Arrayliste mit allen geparsten ‹berschriften zur¸ck
     * Sollte noch keine Load... funktion aufgerufen worden sein wird null zur¸ckgegeben.
	 * 
	 * @return ArrayList<String>
	 */
	public ArrayList<String> getHeader() {
		if (geladen==true) {
			return headerliste;
		} else {
			return null;
		}
	}

}

package org.example.textdemo;

import java.util.ArrayList;
import java.util.ListIterator;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.animation.Animation;
import android.view.animation.Animation.AnimationListener;
import android.view.animation.AnimationUtils;
import android.widget.TextView;
import android.text.Html;
import android.util.Log;

/**
 * Die Hauptklasse.
 */
public class Textdemo extends Activity {
	private TextView tvtext;
	private TextView tvheader;
	private ArrayList<String> textliste;
	private ArrayList<String> headerliste;
	private ListIterator<String> it;
	Animation slideInLeft;
	Animation slideInRight;
	Animation slideOutLeft;
	Animation slideOutRight;
	
	/** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        slideInLeft = AnimationUtils.loadAnimation(this,R.anim.slide_left_in);
        slideInRight = AnimationUtils.loadAnimation(this,R.anim.slide_right_in);
        slideOutLeft = AnimationUtils.loadAnimation(this,R.anim.slide_left_out);
        slideOutRight = AnimationUtils.loadAnimation(this,R.anim.slide_right_out);

        // Erstelle den Text
        textliste = new ArrayList<String>();
        headerliste = new ArrayList<String>();        
        WikiRawTextParser wrtp = new WikiRawTextParser();
        if (wrtp.LoadRawTextFromRessourceFile(getResources().openRawResource(R.raw.neu))==true) {
        	textliste = wrtp.getText();
        	headerliste = wrtp.getHeader();
        }
        it = textliste.listIterator();

        tvheader = (TextView)findViewById(R.id.header);         
        tvtext = (TextView)findViewById(R.id.page);         

        // Lade die erste Seite
        setpage(it.nextIndex());
        it.next();
    }
            
    /**
     * F¸llt die Seite mit Inhalt.
     * Achtung! Es findet keine ‹berpr¸fung der Seitennummer statt.
     * 
     * @param int pageid Seitennummer die angezeigt werden soll
     */
   @Override 
    public boolean onTouchEvent(MotionEvent event) {

    	  int action = event.getAction();

    	  switch (action) {
    	    case (MotionEvent.ACTION_MOVE):
    	    {
    	      int historySize = event.getHistorySize();
    	      for (int i = 0; i < historySize; i++) {
    	        float x = event.getHistoricalX(i);
    	        float y = event.getHistoricalY(i);
    	        processMovement(x, y);
    	      }

    	      float x = event.getX();
    	      float y = event.getY();
    	      processMovement(x, y);

    	      return true;
    	    }
    	  }

    	  return super.onTouchEvent(event);
    	}

    	private void processMovement(float _x, float _y) {
    	  
    	}
    	
    	
    
    private void setpage(int pageid) {
        // Hohle den Textview und ersetze den angezeigten text durch einen anderen.
        tvheader.setText(Html.fromHtml(headerliste.get(pageid)));
        tvtext.setText(Html.fromHtml(textliste.get(pageid)));
    	Log.v(null, "Gehe zu Seite"+pageid);
    }
    
	/**
	 * Blendet die alte Seite aus und blendet die neue Seite ein.
	 * 
	 * @param Animation _out Ausgehende Animation
	 * @param Animation _in Eingehende Animation
	 * @param int pageid Seitennummer die geladen werden soll
	 */
    private void loadpageanimated(Animation _out, Animation _in, int pageid) {
		final int pid = pageid;
		final Animation in = _in;
		_out.setFillAfter(true);
		_out.setAnimationListener(new AnimationListener() {
			public void onAnimationEnd(Animation _animation) {
				setpage(pid);
				tvheader.startAnimation(in);
				tvtext.startAnimation(in);
			}
			
			public void onAnimationRepeat(Animation _animation) {}
			public void onAnimationStart(Animation _animation) {}
		});
		tvheader.startAnimation(_out);
		tvtext.startAnimation(_out);
	}
    
    /**
     * onKeyDown Ereignis f¸r die gesammte Aktivit‰t
     * Damit kann mit den beidne Tasten rechts und links hin und hergebl‰ttert werden
     */
    @Override
    public boolean onKeyDown(int _keycode, KeyEvent _event) {
    	switch(_keycode) {
    		case (KeyEvent.KEYCODE_DPAD_LEFT): //Vorherige Seite
    			if (it.previousIndex()>0) { 
    	        	it.previous();
    				loadpageanimated(slideOutRight,slideInRight,it.previousIndex());
    			} else {
    				while (it.hasNext()) {
    					it.next();
    				}
    				loadpageanimated(slideOutLeft,slideInLeft,it.previousIndex());
    			}
    			return true;
    		case (KeyEvent.KEYCODE_DPAD_RIGHT): //N‰chste Seite
    			if (it.hasNext()) { 
    				loadpageanimated(slideOutLeft,slideInLeft,it.nextIndex());
    	        	it.next();
    			} else {
    				it = textliste.listIterator();		
    				loadpageanimated(slideOutRight,slideInRight,it.nextIndex());
    	        	it.next();
    			}
    			return true;
    		default: // F¸r alle anderen Tasten den Default benutzen 
    			return super.onKeyDown(_keycode, _event);
    	}
    }
            
    /**
     * Erstellt das Optionsmen¸
     */
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
    	super.onCreateOptionsMenu(menu);
    	MenuInflater inflater = getMenuInflater();
    	inflater.inflate(R.menu.menu, menu);
    	return true;
    }
    
    /**
     * F¸hrt Aktionen je nach ausgew‰hltem Men¸eintrag aus
     */
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
    	switch (item.getItemId()) {
    	case R.id.headerlist:
    		openheaderlistdialog();
    		return true;
    	}
    	return false;
    }    
    
    /**
     * Erstellt einen Alertdialog zur Auswahl der ‹berschriften
     */
    private void openheaderlistdialog() {
        AlertDialog.Builder alert = new AlertDialog.Builder(this);
    	alert.setTitle(R.string.headerlist_label);  

        final CharSequence[] items = headerliste.toArray(new CharSequence[headerliste.size()]);
        alert.setItems(items, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int item) {                
            	it = textliste.listIterator();		
				while ((it.nextIndex()<item) && (it.hasNext())) {
					it.next();
				}
            	loadpageanimated(slideOutLeft,slideInRight,it.nextIndex());
	        	it.next();
            }
        });
        AlertDialog dialog = alert.create();
        dialog.show();
    }    
    
}