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

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


public class Transition 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 SCHALTFAEHIG_FARBE = Color.green;
	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		Position;		// Koordinaten
	private Dimension	Groesse;		// Ausdehnung
	private String		Text;			// Bezeichnung
	private boolean		Markierung; 	// ist die Transition ausgewählt
	private boolean		Schaltfaehig;	// schaltfaehige Transition sind eingefärbt
	private KantenListe	VorKanten;  	// Liste aller eingehenden Kanten
	private KantenListe	NachKanten;		// Liste aller ausgehenden Kanten


	/***************************************************/
	/* Konstruktor                                     */
	/***************************************************/
	public Transition(Point mittelPkt, Dimension ausdehnung, String text) {
		this.ID = maxID;
		maxID++;
		this.Position = new Point( mittelPkt.x-(ausdehnung.width>>1), mittelPkt.y-(ausdehnung.height>>1));
		this.Groesse  = new Dimension( ausdehnung);
		this.Text     = new String( text);

		this.VorKanten= new KantenListe();
		this.NachKanten= new KantenListe();
		this.Markierung = false; //ist ggf gesetzt, aber auch nur im Eingabemodus
		this.Schaltfaehig = false; //ist ggf gesetzt, aber auch nur im Simulationsmodus

		this.setLocation(Position);
		this.setSize(Groesse);
		//this.setPreferredSize(Groesse);
	} //Transition-Konstruktor

	private Transition() {
		ID = -1;
		Position = null;
		Groesse = null;
		Text = null;
		VorKanten = new KantenListe();
		NachKanten = new KantenListe();
		Markierung = false;
		Schaltfaehig = false;
	}

	/***************************************************/
	/* Darstellungsteil                                */
	/***************************************************/
	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		if(Markierung) {
			g.setColor( MARKIERT_FARBE);
			g.drawRect( Position.x-13, Position.y-13, Groesse.width+26, Groesse.height+26);
		}
		if(Schaltfaehig) {
			g.setColor( SCHALTFAEHIG_FARBE);
			g.fillRect( Position.x, Position.y, Groesse.width, Groesse.height);
		} else {
			g.setColor( NORMAL_FARBE);
			g.drawRect( Position.x, Position.y, Groesse.width, Groesse.height);
		}
		g.setColor( TEXT_FARBE);
		g.drawString( Text, Position.x, Position.y+Groesse.height+12);
	}


	/***************************************************/
	/* struktureller Teil                              */
	/***************************************************/
	public void VorKanteEinfuegen(Kante eineKante) {
		VorKanten.Einfuegen(eineKante);
		Schaltfaehig = false;
	}//VorKanteEinfuegen

	public void NachKanteEinfuegen(Kante eineKante) {
		NachKanten.Einfuegen(eineKante);
		Schaltfaehig = false;
	}//NachKanteEinfuegen

	public boolean KanteLoeschen(Kante eineKante) {
		Schaltfaehig = false;
		if( VorKanten.Enthalten(eineKante) ){
			VorKanten.Entfernen(eineKante);
			return true;
		} else if( NachKanten.Enthalten(eineKante) ){
			NachKanten.Entfernen(eineKante);
			return true;
		}
		return false;
	}//KanteLoeschen

	public void Leeren(boolean mitKanten, Netz einNetz, KantenListe alleKanten) {
		if( mitKanten) {
			Kante[] vorKant = VorKanten.toArray();
			Kante[] nachKant = NachKanten.toArray();
			int iKant, anzVor = vorKant.length, anzNach = nachKant.length;
			for( iKant=0; iKant<anzVor; iKant++ ){
				vorKant[iKant].getPlatz().KanteLoeschen( vorKant[iKant]);
				alleKanten.Entfernen( vorKant[iKant]);
				vorKant[iKant].Leeren();
				einNetz.remove( vorKant[iKant]);
			}
			for( iKant=0; iKant<anzNach; iKant++ ){
				nachKant[iKant].getPlatz().KanteLoeschen( vorKant[iKant]);
				alleKanten.Entfernen( nachKant[iKant]);
				nachKant[iKant].Leeren();
				einNetz.remove( nachKant[iKant]);
			}
		}
		VorKanten.Leeren();
		NachKanten.Leeren();
		Text = null;
		Markierung = false;
		Schaltfaehig = false;
	}//Leeren

	public Point getMittelPkt() {
		return new Point( Position.x+(Groesse.width>>1), Position.y+(Groesse.height>>1));
	}//getMittelPkt

	public Dimension getGroesse() {
		return new Dimension(Groesse);
	}//getGroesse

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

	public void Speichern(FileWriter Schreiber) throws IOException {
		Schreiber.write( "T");
		Schreiber.write( Integer.toString( ID)+ "t");
		Schreiber.write( Integer.toString( Position.x)+ "t");
		Schreiber.write( Integer.toString( Position.y)+ "t");
		Schreiber.write( Integer.toString( Groesse.width)+ "t");
		Schreiber.write( Integer.toString( Groesse.height)+ "t");
		Schreiber.write( Integer.toString( Text.length())+ "t");
		Schreiber.write( Text);
		Schreiber.write( "/\r\n");
		//die Listen VorKanten und NachKanten werden aus Konsistenzgründen nicht gespeichert
		//sie können beim Laden entsprechend aus den gelesenen Kanten erzeugt werden
	}//Speichern

	public static Transition Laden(Netz.LeseDaten LD) {
		try {
			Transition neuTrans = new Transition();
			TransLesen: {
				if( !Netz.TestStrLesenOK( "T", LD)) break TransLesen;
				if( !Netz.IntLesenBisCharOK( 1, 't', LD)) break TransLesen;
				neuTrans.ID = LD.wert[1];
				if( neuTrans.ID >= maxID) maxID = neuTrans.ID+1;

				if( !Netz.IntLesenBisCharOK( 1, 't', LD)) break TransLesen;
				if( !Netz.IntLesenBisCharOK( 2, 't', LD)) break TransLesen;
				neuTrans.Position = new Point( LD.wert[1], LD.wert[2]);

				if( !Netz.IntLesenBisCharOK( 1, 't', LD)) break TransLesen;
				if( !Netz.IntLesenBisCharOK( 2, 't', LD)) break TransLesen;
				neuTrans.Groesse = new Dimension( LD.wert[1], LD.wert[2]);

				if( !Netz.IntLesenBisCharOK( 1, 't', LD)) break TransLesen;
				if( !Netz.TextLesenOK( LD.wert[1], LD)) break TransLesen;
				neuTrans.Text = LD.text;
				if( !Netz.EinlesenOK(LD)) break TransLesen;
				return neuTrans;
			}
			return null;
		} catch(Exception e) {
			return null;
		}
	}//Laden


	/***************************************************/
	/* 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                                */
	/***************************************************/
	public void Verschieben(int x_entfernung, int y_entfernung, boolean kantenAktualisieren) {
		Position.translate( x_entfernung, y_entfernung);
		setLocation(Position);

		if( kantenAktualisieren ){
			Kante[] vorKant = VorKanten.toArray();
			Kante[] nachKant = NachKanten.toArray();
			int iKant, anzVor = vorKant.length, anzNach = nachKant.length;
			for( iKant=0; iKant<anzVor; iKant++ ) vorKant[iKant].PositionAktualisieren();
			for( iKant=0; iKant<anzNach; iKant++ ) nachKant[iKant].PositionAktualisieren();
			repaint();
		}
	}//Verschieben

	public void TextAendern(String text) {
		Text = text;
	}//TextAend

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


	/***************************************************/
	/* Algorithmen-Teil                                */
	/***************************************************/
	public boolean TestSchalten() {
		Schaltfaehig = false;
		Kante[] VorKant = VorKanten.toArray();
		int iVor, anzVor = VorKant.length;
		//die Vorbedingungen testen
		if( anzVor > 0) {
			for( iVor=0; iVor<anzVor; iVor++ ){
				if( VorKant[iVor].getPlatz().MarkenVorhanden( VorKant[iVor].getKopieMarkenFluss()) ){
					//Vorbedingung erfüllt
				} else return false;
			}
			//alle Vorbedingungen erfüllt
			//nun Marken entsprechend löschen
			for( iVor=0; iVor<anzVor; iVor++ ){
				if( VorKant[iVor].getPlatz().MarkenEntfernen( VorKant[iVor].getKopieMarkenFluss()) ){
					//Marken der Vorbedingung entfernen
				} else return false;
			}
		} else {} //keine Vorbedingung also alle erfüllt
		//Marken aller Vorbedingungen entfernt
		//jetzt Testen, ob Nachbedingungen erfüllt
		Kante[] NachKant = NachKanten.toArray();
		int iNach = 0, anzNach = NachKant.length;
		boolean allesOK = true;
		while( (iNach<anzNach) && allesOK ){
			if( NachKant[iNach].getPlatz().UebrigeKapazitaetMindestens( NachKant[iNach].getKopieMarkenFluss()) ){
				//Nachbedingung erfüllt
			} else allesOK = false;
			iNach++;
		}
		Schaltfaehig = allesOK;
		//in allesOK steht, ob alle Nachbedingungen erfüllt sind
		//Vorbedingungsmarken in allen Fällen zurücksetzen
		for( iVor=0; iVor<anzVor; iVor++ ){
			if( VorKant[iVor].getPlatz().MarkenEinfuegen( VorKant[iVor].getKopieMarkenFluss()) ){
			} else return false;
		}
		return allesOK;
	}//TestSchalten

	public void Abschalten() {
		Schaltfaehig = false;
	}//Abschalten

	public int Schalten() {
		boolean aenderung = false;
		if( Schaltfaehig ){
			Kante[] VorKant = VorKanten.toArray();
			int iVor, anzVor = VorKant.length;
			for( iVor=0; iVor<anzVor; iVor++ ){
				Tupel wanderMarken = VorKant[iVor].getKopieMarkenFluss();
				aenderung |= wanderMarken.getSummeAller() > 0;
				VorKant[iVor].getPlatz().MarkenEntfernen( wanderMarken);
			}
			Kante[] NachKant = NachKanten.toArray();
			int iNach, anzNach = NachKant.length;
			for( iNach = 0; iNach<anzNach; iNach++ ){
				Tupel wanderMarken = NachKant[iNach].getKopieMarkenFluss();
				aenderung |= wanderMarken.getSummeAller() > 0;
				NachKant[iNach].getPlatz().MarkenEinfuegen( wanderMarken);
			}
			if( aenderung ) return 1;
			return 0;
		} else return -1;
	}//Schalten


	/***************************************************/
	/* ...-Teil                                        */
	/***************************************************/

} //Transition-Klasse