/************************************************************/
/* Platz.java Version 2003/03/28                            */
/*                                                          */
/* Tom Fellmann, Christoph Weißenborn                       */
/*                                                          */
/************************************************************/

import java.awt.*;
import java.io.*;
import javax.swing.*;

public class Platz extends JComponent implements PN_Knoten{
	/***************************************************/
	/* Daten-Teil                                      */
	/***************************************************/
	public static final Color NORMAL_FARBE = Color.black;
	public static final Color MARKIERT_FARBE = Color.red;
	public static final Color TEXT_FARBE = Color.white;
	protected static int maxID=0;		//globale Durchnummerierung aller Platz-Objekte, für ID
	private int		ID;				//
	private Point	Mittel_Pkt;		// Koordinaten des Platzes
	private int		Radius;			// Radius des Platzes
	private String	Text;			// Bezeichnung des Platzes
	private Tupel	Kapazitaet;		// Kapazität (FarbTupel)
	private Tupel	Marken;			// Marken (FarbTupel)
	private KantenListe	WegKanten;	// Liste aller ausgehenden Kanten
	private KantenListe	HinKanten;	// Liste aller eingehenden Kanten
	private boolean Markierung;		// Hervorhebung
	private smartiPunkte smarties;  // Punkte der Marken & übrigen Kapazitäten
	private boolean seitletztemMalenGeaendert;

	/***************************************************/
	/* Konstruktor                                     */
	/***************************************************/
	public Platz(Point mittelPkt, int radius, String text) {
		this.ID = maxID;
		maxID++;
		this.Mittel_Pkt = new Point( mittelPkt);
		this.Radius = radius;
		this.Text 	= new String(text);
		this.Kapazitaet = new Tupel( 0);
		this.Marken = new Tupel( 0);
		this.WegKanten = new KantenListe();
		this.HinKanten = new KantenListe();
		this.Markierung = false;

		this.setLocation( mittelPkt.x-(radius>>1), mittelPkt.y-(radius>>1));
		this.setSize( Radius, Radius);
		smarties = new smartiPunkte(this, smarties);
		seitletztemMalenGeaendert = false;
	} //Platz-Konstruktor

	private Platz() {
		this.ID = -1;
		this.Mittel_Pkt = null;
		this.Radius = 0;
		this.Text = null;
		this.Kapazitaet = new Tupel( 0);
		this.Marken = new Tupel( 0);
		this.WegKanten = new KantenListe();
		this.HinKanten = new KantenListe();
		this.Markierung = false;
		smarties = null;
		seitletztemMalenGeaendert = false;
	} //Platz-Konstruktor (privat & ohne Parameter)

	/***************************************************/
	/* PN_Knoten-Implementierung                       */
	/***************************************************/
	public int getID() {
		return ID;
	}//getID

	public boolean gleich(PN_Knoten Knoten) {
		return Knoten.getID() == ID;
	}//gleich

	public boolean isKlasse(String str) {
		return getClass().getName().compareTo(str)==0;
	}//isKlasse


	/***************************************************/
	/* Darstellungsteil                                */
	/***************************************************/
	protected myJLabel[] getMatrixTexte() {
		myJLabel[] jls = new myJLabel[ Netz.getFarbanzahl()+ 1];
		jls[0] = new myJLabel( Text);
		int h;
		for( int i=1; i<jls.length; i++ )
			if( (h = Kapazitaet.getWert(i-1)) > 0)
				jls[i] = new myJLabel( Netz.Zweistellig( Marken.getWert(i-1))+ "/"+
									   Netz.Zweistellig(                   h), JLabel.LEFT);
			else
				jls[i] = new myJLabel( " ", JLabel.LEFT);
		return jls;
	}//getMatrixTexte

	protected int getBitMusterBenutzeFarben() {
		if( smarties==null) return 0;
		int muster = 0;
		for( int i=0; i<smarties.anzBenuFarben; i++ ) muster |= 1 << smarties.benuFarbe[ i];
		return muster;
	}//getBitMusterBenutzeFarben

	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		if( Markierung ){
			g.setColor( MARKIERT_FARBE);
			g.drawOval( Mittel_Pkt.x-Radius-10, Mittel_Pkt.y-Radius-10, (Radius+10<<1)-1, (Radius+10<<1)-1);
		}
		g.setColor( NORMAL_FARBE);
		g.drawOval( Mittel_Pkt.x-Radius, Mittel_Pkt.y-Radius, Radius<<1, Radius<<1);
		g.setColor( TEXT_FARBE);
		g.drawString(Text, Mittel_Pkt.x-Radius, Mittel_Pkt.y+Radius+8);

		/*******************/
		/* Marken zeichnen */
		/*******************/
		if( smarties==null ) smarties = new smartiPunkte(this, smarties);
		if( smarties!=null ){
			if( smarties.leer ){
				g.setColor( TEXT_FARBE);
				g.drawString( "leer", Mittel_Pkt.x-12, Mittel_Pkt.y+3);
			} else if( !smarties.alsMatrixDarstellen ){
				int i, j, markenradius;
				for( i=0; i<smarties.anzBenuFarben; i++ ){
					j = 0;
					g.setColor( PetriFrame.FARB_WERT[smarties.benuFarbe[i]]);
					markenradius = (int)smarties.markenradius[i];
					while( j<smarties.benuMark[i] ){
						g.fillOval( smarties.x[i][j]- markenradius, smarties.y[i][j]- markenradius,
									markenradius<<1, markenradius<<1);
						j++;
					}
					while( j<smarties.benuKapa[i] ){
						g.drawOval( smarties.x[i][j]- markenradius, smarties.y[i][j]- markenradius,
									(markenradius<<1)-1, (markenradius<<1)-1);
						j++;
					}
				}
			} else { //nicht leer, alsMatrixDarstellen
				g.setColor( TEXT_FARBE);
				g.drawString( "in Matrix", Mittel_Pkt.x-22, Mittel_Pkt.y+3);
				if( seitletztemMalenGeaendert ) Petri.frame.gefNetz.setMatrixPlatzGeaendert();
			}
		} else {
		} //smarties==null
	}//paintComponent


	/***************************************************/
	/* strukturelle Änderungen                         */
	/***************************************************/
	public void HinKanteEinfuegen(Kante eineKante) {
		HinKanten.Einfuegen(eineKante);
	}//HinKanteEinfuegen

	public void WegKanteEinfuegen(Kante eineKante) {
		WegKanten.Einfuegen(eineKante);
	}//WegKanteEinfuegen

	public boolean KanteLoeschen(Kante eineKante) {
		if( HinKanten.Enthalten(eineKante) ) {
			HinKanten.Entfernen(eineKante);
			return true;
		} else if( WegKanten.Enthalten(eineKante) ) {
			WegKanten.Entfernen(eineKante);
			return true;
		}
		return false;
	}//KanteLoeschen

	public void Leeren(boolean mitKanten, Netz einNetz, KantenListe alleKanten) {
		if( mitKanten) {
			Kante[] hinKant = HinKanten.toArray();
			Kante[] wegKant = WegKanten.toArray();
			int iKant, anzHin = hinKant.length, anzWeg = wegKant.length;
			for( iKant=0; iKant<anzHin; iKant++ ){
				hinKant[iKant].getTransition().KanteLoeschen( hinKant[iKant]);
				alleKanten.Entfernen( hinKant[iKant]);
				hinKant[iKant].Leeren();
				einNetz.remove( hinKant[iKant]);
			}
			for( iKant=0; iKant<anzWeg; iKant++ ){
				wegKant[iKant].getTransition().KanteLoeschen( wegKant[iKant]);
				alleKanten.Entfernen( wegKant[iKant]);
				wegKant[iKant].Leeren();
				einNetz.remove( wegKant[iKant]);
			}
		}
		HinKanten.Leeren();
		WegKanten.Leeren();
		Marken.Leeren();
		Kapazitaet.Leeren();
		if( smarties.alsMatrixDarstellen ) Petri.frame.gefNetz.InMatrixEinfuegen( this, false);
		seitletztemMalenGeaendert = true;
		smarties = null;
		Text = null;
	}//Leeren

	public Point getMittelPkt() {
		return new Point( Mittel_Pkt);
	}//getMittelPkt

	public int getRadius() {
		return Radius;
	}//getRadius

	public String getText() {
		return new String( Text);
	}//getText

	public void Speichern(FileWriter Schreiber) throws IOException {
		Schreiber.write( "P");
		Schreiber.write( Integer.toString(ID)+ "p");
		Schreiber.write( Integer.toString( Mittel_Pkt.x)+ "p");
		Schreiber.write( Integer.toString( Mittel_Pkt.y)+ "p");
		Schreiber.write( Integer.toString( Radius)+ "p");
		Schreiber.write( Integer.toString( Text.length())+ "p");
		Schreiber.write( Text);
		Kapazitaet.Speichern( Schreiber);
		Marken.Speichern( Schreiber);
		Schreiber.write( "/\r\n");
		//die Listen WegKanten und HinKanten werden aus Konsistenzgründen nicht gespeichert
		//sie können beim Laden entsprechend aus den gelesenen Kanten erzeugt werden
	}//Speichern

	public static Platz Laden(Netz.LeseDaten LD/*BufferedReader Leser, String str, int start*/) {
		try {
			Platz neuPlatz = new Platz();
			Tupel eTupel;
			PlatzLesen: {
				if( !Netz.TestStrLesenOK( "P", LD)) break PlatzLesen;
				if( !Netz.IntLesenBisCharOK( 1, 'p', LD)) break PlatzLesen;
				neuPlatz.ID = LD.wert[1];
				if( neuPlatz.ID >= maxID) maxID = neuPlatz.ID+1;

				if( !Netz.IntLesenBisCharOK( 1, 'p', LD)) break PlatzLesen;
				if( !Netz.IntLesenBisCharOK( 2, 'p', LD)) break PlatzLesen;
				neuPlatz.Mittel_Pkt = new Point( LD.wert[1], LD.wert [2]);

				if( !Netz.IntLesenBisCharOK( 1, 'p', LD)) break PlatzLesen;
				neuPlatz.Radius = LD.wert[1];

				if( !Netz.IntLesenBisCharOK( 1, 'p', LD)) break PlatzLesen;
				if( !Netz.TextLesenOK( LD.wert[1], LD)) break PlatzLesen;
				neuPlatz.Text = LD.text;

				eTupel = Tupel.Laden( LD);
				if( eTupel == null) break PlatzLesen;
				neuPlatz.Kapazitaet = eTupel;

				eTupel = Tupel.Laden( LD);
				if((eTupel == null) || !neuPlatz.KapazitaetMindestens(eTupel)) break PlatzLesen;
				neuPlatz.Marken = eTupel;
				neuPlatz.smarties = new smartiPunkte(neuPlatz, neuPlatz.smarties);

				if( !Netz.EinlesenOK(LD)) break PlatzLesen;
				neuPlatz.seitletztemMalenGeaendert = true;
				return neuPlatz;
			}
			return null;
		} catch(Exception e) {
			return null;
		}
	}//Laden

	/*private static boolean readIntKomponente(String objstr) {
		int comlen = objstr.indexOf(':');
		try { int wert = Integer.valueOf(objstr.substring(0,comlen-1)).intValue(); }
		catch (NumberFormatException e) { return false; }
		objstr = objstr.substring(comlen+1);
		return true;
	}//readIntKomponente


	/***************************************************/
	/* Darstellungsteil                                */
	/***************************************************/
	public void Verschieben(int x_entfernung, int y_entfernung, boolean kantenAktualisieren) {
		Mittel_Pkt.translate( x_entfernung, y_entfernung);
		setLocation( Mittel_Pkt.x-(Radius>>1), Mittel_Pkt.y-(Radius>>1));
		smarties = new smartiPunkte(this, smarties);

		if( kantenAktualisieren ){
			Kante[] hinKant = HinKanten.toArray();
			Kante[] wegKant = WegKanten.toArray();
			int iKant, anzHin = hinKant.length, anzWeg = wegKant.length;
			for( iKant=0; iKant<anzHin; iKant++ ) hinKant[iKant].PositionAktualisieren();
			for( iKant=0; iKant<anzWeg; iKant++ ) wegKant[iKant].PositionAktualisieren();
			repaint();
		}
	}//Verschieben

	public void TextAendern(String neuerText) {
		Text = neuerText;
		seitletztemMalenGeaendert = true;
	}//TextAendern

	public void MarkierungAendern(boolean markiert) {
		Markierung = markiert;
	}//MarkierungAendern

	public boolean istLeer() {
		if( smarties!=null ) return smarties.leer;
		return true;
	}//istLeer

	public boolean alsMatrixDarstellen() {
		if( smarties!=null ) return smarties.alsMatrixDarstellen;
		return false;
	}//alsMatrixDarstellen


	/***************************************************/
	/* Algorithmen-Teil                                */
	/***************************************************/
	public boolean UebrigeKapazitaetMindestens(Tupel vglMarken) {
		return Kapazitaet.SummeArgumenteKleinerGleich( Marken, vglMarken);
	}//UebrigeKapazitaetMindestens

	public boolean KapazitaetMindestens(Tupel vglKapaz) {
		return Kapazitaet.ArgumentKleinerGleich( vglKapaz);
	}//KapazitaetMindestens

	public boolean KapazitaetZuweisen(int[] neueKapazitaet) {
		if( !Kapazitaet.wertGleich( neueKapazitaet) ){
			if( Kapazitaet.Zuweisen(neueKapazitaet) ){
				smarties = new smartiPunkte(this, smarties);
				seitletztemMalenGeaendert = true;
				return true;
			} else {
				if( smarties.alsMatrixDarstellen ) Petri.frame.gefNetz.InMatrixEinfuegen( this, false);
				seitletztemMalenGeaendert = true;
				smarties = null;
				return false;
			}
		} else return true;
	}//KapazitaetAendern

	public boolean KapazitaetZuweisen(Tupel neueKapazitaet) {
		if( !Kapazitaet.wertGleich( neueKapazitaet) ){
			if( Kapazitaet.Zuweisen( neueKapazitaet) ){
				smarties = new smartiPunkte(this, smarties);
				seitletztemMalenGeaendert = true;
				return true;
			} else {
				if( smarties.alsMatrixDarstellen ) Petri.frame.gefNetz.InMatrixEinfuegen( this, false);
				seitletztemMalenGeaendert = true;
				smarties = null;
				return false;
			}
		} else return true;
	}//KapazitaetAendern

	public boolean MarkenVorhanden(Tupel vglMarken) {
		return Marken.ArgumentKleinerGleich( vglMarken);
	}//MarkenVorhanden

	public boolean MarkenZuweisen(int[] neueMarken) {
		if( !Marken.wertGleich( neueMarken) ){
			if( Marken.Zuweisen( neueMarken) ){
				smarties.markenAktualisieren();
				seitletztemMalenGeaendert = true;
				return true;
			} else {
				if( smarties.alsMatrixDarstellen ) Petri.frame.gefNetz.InMatrixEinfuegen( this, false);
				seitletztemMalenGeaendert = true;
				smarties = null;
				return false;
			}
		} else return true;
	}//MarkenZuweisen

	public boolean MarkenZuweisen(Tupel neueMarken) {
		if( !Marken.wertGleich( neueMarken) ){
			if( Marken.Zuweisen( neueMarken) ){
				smarties.markenAktualisieren();
				seitletztemMalenGeaendert = true;
				return true;
			} else {
				if( smarties.alsMatrixDarstellen ) Petri.frame.gefNetz.InMatrixEinfuegen( this, false);
				seitletztemMalenGeaendert = true;
				smarties = null;
				return false;
			}
		} else return true;
	}//MarkenZuweisen

	public boolean MarkenEinfuegen(Tupel einfMarken) {
		if( !(UebrigeKapazitaetMindestens(einfMarken)) ) return false;
		if( einfMarken.getSummeAller()>0 ){
			if( Marken.Addieren(einfMarken) ){
				smarties = new smartiPunkte(this, smarties);
				seitletztemMalenGeaendert = true;
				return true;
			} else {
				if( smarties.alsMatrixDarstellen ) Petri.frame.gefNetz.InMatrixEinfuegen( this, false);
				seitletztemMalenGeaendert = true;
				smarties = null;
				return false;
			}
		} else return true;
	}//MarkenEinfuegen

	public boolean MarkenEntfernen(Tupel entfMarken) {
		if( !(MarkenVorhanden(entfMarken)) ) return false;
		if( entfMarken.getSummeAller()>0 ){
			if( Marken.Abziehen(entfMarken) ){
				smarties = new smartiPunkte(this, smarties);
				seitletztemMalenGeaendert = true;
				return true;
			} else {
				if( smarties.alsMatrixDarstellen ) Petri.frame.gefNetz.InMatrixEinfuegen( this, false);
				seitletztemMalenGeaendert = true;
				smarties = null;
				return false;
			}
		} else return true;
	}//MarkenEntfernen

	public Tupel getKopieKapazitaetMarken() {
		return new Tupel( Kapazitaet);
	}//getKapazitaetMarken

	public Tupel getKopieMarken() {
		return new Tupel( Marken);
	}//getMarken
	/***************************************************/
	/* ...-Teil                                        */
	/***************************************************/

}//Platz-Klasse



class smartiPunkte {
	//                                            0,     1,     2,     3,     4,     5,     6,     7,     8
	private static final double radiuskoeff[] = { 0, 0.460, 0.460, 0.460, 0.410, 0.360, 0.330, 0.290, 0.280};
	private double[] kreis_x, kreis_y;
	private double kreisradius;
	private int maxBenuKapa;
	private Platz ePlatz;
	protected boolean alsMatrixDarstellen;
	protected boolean leer;
	protected int anzBenuFarben; //benu = benutzt
	protected int[] benuFarbe;
	protected int[] benuMark;
	protected int[] benuKapa;
	protected int[][] x, y;
	protected double[] markenradius;

	public smartiPunkte(Platz ePlatz, smartiPunkte alterWert) {
		if( (Netz.MAX_FARBENDARSTELLANZ >= radiuskoeff.length) || (Netz.MAX_MARKENDARSTELLANZ >= radiuskoeff.length) )
			throw new IllegalArgumentException( "Die Anzahl der darzustellenden Farben und Marken wurde zu sehr erhoeht. Daher "+
					" sind nun die notwendigen Parameter nicht ausreichend vorhanden. Siehe Platz.java!");
		if( alterWert != null ){
			if( alterWert.alsMatrixDarstellen ) Petri.frame.gefNetz.InMatrixEinfuegen( alterWert.ePlatz, false);
		}
		/*try{*/
			this.ePlatz = ePlatz;
			initialisieren();
			alsMatrixDarstellen = false;
			leer = false;
			if( anzBenuFarben==0 ) leer = true;
			else if( (0<anzBenuFarben) && (anzBenuFarben<=Netz.MAX_FARBENDARSTELLANZ) && (maxBenuKapa<=Netz.MAX_MARKENDARSTELLANZ) ){
				kreisBerechnen();
				kreiseBerechnen();
			} else {
				alsMatrixDarstellen = true;
				Petri.frame.gefNetz.InMatrixEinfuegen( ePlatz, true);
			}
/*		} catch (Exception e) {
			try{ alsMatrixDarstellen = false; } catch (Exception ex){}
		};*/
	}//smartiPunkte-Konstruktor

	public void markenAktualisieren() {
		Tupel platzMarken = ePlatz.getKopieMarken();
		for( int i=0; i<anzBenuFarben; i++ ) benuMark[i] = platzMarken.getWert( benuFarbe[i]);
	}//markenAktualisieren

	private void kreiseBerechnen() {
		double phi, kreiseradius;
		int farbNum, anz, i, j;
		kreiseradius = ePlatz.getRadius()*radiuskoeff[anzBenuFarben];
		for( i=0; i<anzBenuFarben; i++ ){
			farbNum = benuFarbe[i];
			anz = benuKapa[i];
			markenradius[i] = kreiseradius*radiuskoeff[anz];
			for( j=0; j<anz; j++ ){
				phi = (2*Math.PI*j)/anz-Math.PI;
				x[i][j] = (int)(kreis_x[i]+Math.sin(phi)*(kreiseradius-markenradius[i]));
				y[i][j] = (int)(kreis_y[i]+Math.cos(phi)*(kreiseradius-markenradius[i]));
			}
		}
	}//kreiseBerechnen

	private void kreisBerechnen() {
		double phi;
		kreisradius = ePlatz.getRadius()*(1.0-radiuskoeff[anzBenuFarben]);
		for( int i=0; i<anzBenuFarben; i++ ){
			phi = (2*Math.PI*i)/anzBenuFarben-Math.PI;
			kreis_x[i] = ePlatz.getMittelPkt().x+ Math.sin(phi)*kreisradius;
			kreis_y[i] = ePlatz.getMittelPkt().y+ Math.cos(phi)*kreisradius;
		}
	}//kreisBerechnen

	private void initialisieren() {
		Tupel platzKapaz = ePlatz.getKopieKapazitaetMarken();
		Tupel platzMark = ePlatz.getKopieMarken();
		int anzFarben = Netz.getFarbanzahl();
		anzBenuFarben = 0;
		int alleFarben[] = new int[anzFarben];
		for( int i=0; i<anzFarben; i++ ){
			alleFarben[anzBenuFarben] = i;
			if( platzKapaz.getWert(i)>0 ) anzBenuFarben++;
		}
		benuFarbe = new int[anzBenuFarben];
		benuKapa = new int[anzBenuFarben];
		benuMark = new int[anzBenuFarben];
		markenradius = new double[anzBenuFarben];
		kreis_x = new double[anzBenuFarben];
		kreis_y = new double[anzBenuFarben];
		x = new int[anzBenuFarben][];
		y = new int[anzBenuFarben][];
		maxBenuKapa = 0;
		for( int i=0; i<anzBenuFarben; i++ ){
			int farbNum = alleFarben[i];
			int farbKapa = platzKapaz.getWert( farbNum);
			benuFarbe[i] = farbNum;
			benuKapa[i] = farbKapa;
			benuMark[i] = platzMark.getWert( farbNum);
			if( maxBenuKapa < farbKapa ) maxBenuKapa = farbKapa;
			x[i] = new int[farbKapa];
			y[i] = new int[farbKapa];
		}
	}//initialisieren
}//smartiPunkte