// applet asciiplotter
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.Color;
import java.awt.image.*;
import java.io.*;
import java.util.*;

public class AsciiGravityApplet extends Applet implements Runnable, MouseListener, MouseMotionListener, KeyListener{
	
	Color []colorsPos = {Color.white,Color.black,Color.yellow,Color.red};	//	foreground / background colors
	Color []colorsNeg = {Color.black,Color.green,Color.blue,Color.red};		//	negative colors
	
	boolean neg = false;				//	flag for negative colors on/off
	boolean grav = false;				//	flag for physics on/off
	static float scaleMe =2;			//	resize for canvas 
	int scaleOff = 2;					//	resize for characters
	boolean start = true;				//	init flag
	
	Gravity2 gravity; 					//	physicsclass
	
	Thread plottThread;					//	Thread for plott
	int delayPlott = 1;
	
	int nextImg = 0;					//	counter for next image
	int imgTimer = 0; 					//	counter for image change
	int imgDelay = 100;					//	change image every n time
	
	static int width =400;				//	default display size
	static int height=300;
	static int dim = width*height;		//	count pixels
	static int pos;						//	pixelImg[pos]
	
	//type------------    
	Font font;
	String[][] myChar  = {				//	character array
		{" ",".","-",":","=","o","#"},
		{" ",".",":","-","=","|"},
		{" ",".","_",":","=","#"},
		{" ","-","="}
	};
	int charLength;						//	length of current char-set
	int wichChar;						//	current character
	
	int fontSize = 5*scaleOff;
	int xOffset = 3;					//	offset = character width & height
	int yOffset = 4;
	
	// main graphics
	BufferedImage bufferedImage;		//	offscreenbuffer for canvas
	Graphics      bg;					//	canvas        
	int pixelImg [][] ;					//	rgb array for each picture
	
	int dimX = width/xOffset;			//	= screenwidth / fontwidth 
	int dimY = height/yOffset;
	int [] posX         = new int [dimX];	//	x/y positions of each character
	int [] posY         = new int [dimY];	
	
	//loaded images
	Image [] images;					//	image array for jpg's
	int countImg;						//	count jpg's
	Vector fileV = new Vector();		//	vector with jpg names
	
	//save img
	//File saveImg;
	//int saveCount=0;
	//String filename = "";
	//boolean save = false;
	
	int countPos = 0;					//	counter for elements of physics-array
	
	//////////////////////////////////
	//	init method					//
	//////////////////////////////////
	
	public void init() {
		
		addMouseListener(this);
		addMouseMotionListener(this);
		addKeyListener(this);

		for(int i=0;i<5;i++){							//	build url's for jpg-serie
			fileV.addElement("ram" + i + ".jpg");
			System.out.println("vector: "+fileV.lastElement());
		}
		fileV.trimToSize();
		countImg=fileV.capacity();
		
		System.out.println("countImg" + countImg);
		System.out.println("anz.Pixel" + dim);
		
		gravity = new Gravity2(20000,0);				//	physics class
		
		loadImg();
		
		dim = width*height;								//	new pixel array dimension		
		pixelImg  = new int [countImg][dim];	
		
		xOffset = (int)((xOffset/scaleMe)*scaleOff);	//	new character-offsets
		yOffset = (int)((yOffset/scaleMe)*scaleOff);
		
		dimX = width/xOffset;							//	dimensions for char-positions-arrays
		dimY = height/yOffset;
		
		posX         = new int [dimX];					//	positions-arrays
		posY         = new int [dimY];
		
		bufferedImage = new BufferedImage((int)(width* scaleMe), (int)(height* scaleMe), BufferedImage.TYPE_INT_RGB);
		
		font=new Font("Verdana", Font.PLAIN, fontSize);
		
		for (int i=0;i<posY.length;i++){				//	positions of characters
			for (int j=0;j<posX.length;j++){
				posY[i]= i*yOffset;
				posX[j]= j*xOffset;
			}
		}
		
		if(plottThread == null){						//	start thread for drawing
			plottThread = new Thread(this);
			plottThread.start();
		}
		
		grabPixel();									//	grab pixels from images
		
		setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
	}
	
	//////////////////////////////////
	//	overwrite update method		//
	//////////////////////////////////
	
	public void update(Graphics g){paint(g);}
	
	public void start(){}
	
	//////////////////////////////////
	//	overwrite stop method		//
	//////////////////////////////////
	
	public void stop(){
		if(plottThread != null && plottThread.isAlive()){
			plottThread.stop();
			plottThread = null;
			
		}
	}
	
	//////////////////////////////////
	//	run method					//
	//////////////////////////////////
	
	public void run() {
		while (plottThread != null ) {
			try {plottThread.sleep(delayPlott);}
			catch (InterruptedException e) {}
			
			repaint();
			
			if(imgTimer >imgDelay){
				if(nextImg == (countImg-1)){
					nextImg = 0;
				}
				else{ nextImg++; }
				imgTimer = 0;
			}else{
				imgTimer++;
			}
		}
		plottThread = null;
	}
	
	//////////////////////////////////
	//	paint method				//
	//////////////////////////////////
	
	public void paint(Graphics g) {
		if(start){
			scaleOff=1;
			start=false;
		}
		Graphics2D bg = bufferedImage.createGraphics();
		bg.setFont(new Font("Arial", Font.PLAIN, fontSize*scaleOff));
		
		countPos = 0;
		
		int randChar =0;
		
		charLength = myChar[randChar].length-1;
		wichChar = 256/charLength;
		
		if(neg){
			bg.setColor(Color.black);
			bg.fillRect(0,0,(int)(width * scaleMe),(int)(height * scaleMe));
			
		}else{
			bg.setColor(colorsPos[0]);
			bg.fillRect(0,0,(int)(width * scaleMe),(int)(height * scaleMe));
			bg.setColor(colorsPos[1]);
		}
		for (int i = 0; i < posY.length; i += scaleOff){
			for (int j = 0; j < posX.length; j+= scaleOff){
				pos = posY[i] * width + posX[j];
				
				if(neg){
					bg.setColor(new Color(pixelImg[nextImg][pos]));
					if(!grav){
						gravity.newPosX[countPos]=300;
						gravity.newPosY[countPos]=200;
						gravity.posY[countPos]=(int)(posY[i]*scaleMe);
						gravity.posX[countPos]=(int)(posX[j]*scaleMe);
						
						bg.drawString(myChar[randChar][(pixelImg[nextImg][pos]&0x000000FF)/wichChar],posX[j]*scaleMe,posY[i]*scaleMe);
					}else if(grav){
						gravity.iterateGauss(countPos);
						bg.drawString(myChar[randChar][(pixelImg[nextImg][pos]&0x000000FF)/wichChar],(int)gravity.newPosX[countPos],(int)gravity.newPosY[countPos]);
					}
				}else{
					
					if(!grav){
						gravity.newPosX[countPos]=300;
						gravity.newPosY[countPos]=200;
						gravity.posY[countPos]=(int)(posY[i]*scaleMe);
						gravity.posX[countPos]=(int)(posX[j]*scaleMe);
						
						bg.drawString(myChar[randChar][charLength-(pixelImg[nextImg][pos]&0x000000FF)/wichChar],posX[j]*scaleMe,posY[i]*scaleMe);
					}else if(grav){
						gravity.iterateGauss(countPos);
						bg.drawString(myChar[randChar][charLength-(pixelImg[nextImg][pos]&0x000000FF)/wichChar],(int)gravity.newPosX[countPos],(int)gravity.newPosY[countPos]);
					}
				}
				countPos++;
			}
		}
		gravity.charCount=countPos;
		
		bg.dispose();
		
		g.drawImage(bufferedImage,0,0,null);		
		
		
		/*
		if(save){
		saveMe();
		saveCount++;
		}else{ saveCount = 0; }
		*/
	}
	
	//////////////////////////////////
	//	load images method			//
	//////////////////////////////////
	
	
	public void loadImg(){
		images = new Image[countImg];
                

		MediaTracker tracker = new MediaTracker(this);
		for (int i=0;i < countImg;i++){
			System.out.println("load: "+ fileV.elementAt(i));
//			String fname =  fileV.elementAt(i).toString();
                       images[i] = getImage(getDocumentBase(), fileV.elementAt(i).toString());     // get the image
//			images[i]  = Toolkit.getDefaultToolkit().getImage(fname);
			tracker.addImage(images[i], i);
			try { tracker.waitForID(i); }
			catch (InterruptedException e) {}
			width = images[i].getWidth(this);
			height = images[i].getHeight(this);
		}
		scaleMe =(400 / (float)width)*scaleMe;
		System.out.println("w: "+ width + " h: "+ height + " new scale: " + scaleMe);
	}
	
	//////////////////////////////////////////////
	//	grab pixel-data from images method		//
	//////////////////////////////////////////////
	
	public void grabPixel() {
		for(int i=0;i< countImg ;i++){
			PixelGrabber grabber = new PixelGrabber(images[i],0,0,-1,-1,true);
			System.out.println("grab: "+ i);
			try {
				if (grabber.grabPixels()) {
					int grabPixel[] = (int[])grabber.getPixels();   // Pixel Grabbing
					for (int x=0;x<dim;x++) pixelImg[i][x] = grabPixel[x];
				}
			}
			catch (InterruptedException e) {                     // Achtung: IO Fehler
				System.out.print("Error:" + e);
				System.exit(1);
			}
		}
	}
	
	//////////////////////////////////////
	//	save frames as jpg's method		//
	//////////////////////////////////////
	
	/*
	public void saveMe(){
	filename = "temp/"+saveCount+".jpg";
	try {
	saveImg = new File(filename);
	ImageIO.write(bufferedImage, "jpg", saveImg);
	} catch (IOException e) {
	System.out.println("error save: " + saveImg);
	}
	}
	*/
	
	//////////////////////////////
	//   Mouse Events			//
	//////////////////////////////
	
	public void mousePressed(MouseEvent e)   {
		//if(e.getModifiers() == MouseEvent.BUTTON1_MASK){
		//if(grav){
		grav=true;
		for (int i=0;i<countPos;i++) {
			gravity.mouseClicked = true;
			gravity.mouseX=e.getX();
			gravity.mouseY=e.getY();
		}
		//}
		//}    
	}
	public void mouseReleased(MouseEvent e)  {
		/*
		if(e.getModifiers() == MouseEvent.BUTTON3_MASK){
		int x = (e.getX()-(int)(width*scaleMe)/2)/20;
		if(x==0)x=1;
		if(x<0)x*=-1;
		scaleOff =  x;
		}
		*/
		//if(e.getModifiers() == MouseEvent.BUTTON1_MASK){
		if(grav){
			gravity.mouseClicked = false;
		}
		//}    
	}
	
	public void mouseClicked(MouseEvent e)  {}
	
	public void mouseEntered(MouseEvent e)  {}
	public void mouseExited(MouseEvent e)   {}
	public void mouseDragged(MouseEvent e)  {}
	public void mouseMoved(MouseEvent e)    {}
	
	public void keyPressed(KeyEvent e){
		if (e.getKeyCode() == 32) {		// "space"
			if(neg)neg=false;
			else neg=true;
		}
		if (e.getKeyCode() == 71) {		// "g"
			if(grav)grav=false;
			else grav=true;
			//System.out.println(gravity.dec[1]);
		}
		//if (e.getKeyCode() == 49) {		// "1"
		//	gravity.mouseClicked = false;
		//}
		if (e.getKeyCode() == 65)System.out.println(gravity.dec[1]);
		//--- scale by keynumbers 1-9
		if (e.getKeyCode() >= 49 && e.getKeyCode() <= 58){
			grav=false;
			scaleOff = e.getKeyCode()-48;
		}
		System.out.println(e.getKeyCode());
	}
	public void keyReleased(KeyEvent e){}
	public void keyTyped(KeyEvent e){}
	
}//end class AsciiPlotter