// mac.Debug|bool|Debug|0

import Bbi.System.*;
import Weng.Math.Box2d;
import Weng.Geometry.Point;
import Weng.CodeGen.MiscAddr;
import Weng.Modeler.*;

import java.io.*;
import java.util.Vector;

public class BackPlot implements WengMacro
{
	static private boolean DEBUG = false;
	static private boolean BLOCK = false;
	static private boolean WORD  = false;
	static private boolean VALUE = false;
	
	public void main()
	{
		String filename = Model.StringGet( "ncfile" );
		int toolSetupID = Model.IntGet( "toolsetupid" );
		int materialID  = Model.IntGet( "materialid" );

		Model.VarDel( "toolsetupid" );
		Model.VarDel( "materialid" );
		
		// DEBUG = ( Model.IntGet( "mac.Debug" ) == 1);

		boolean okay = (filename.length() > 0 && toolSetupID > 0 && materialID > 0);
		
		if ( okay )
		{
			// Init the model with bogus material dimensions.
			okay = Model.Init( toolSetupID, materialID, 10., 10. );
		}
		
		if ( okay )
		{
			DefaultsSave();
			
			ArcRegistersInit();
			
			try
			{
				String [] ncCode = FileLoad( filename );
				if (DEBUG) Msg.Display( "Passed FileLoad()" );
	
				Decode( ncCode );
				if (DEBUG) Msg.Display( "Passed Decode()" );

				Box2d box = Model.Box2d();
				Model.StockUpdate( box.Dx(), box.Dy(), Model.DoubleGet("thickness") );
				
				Viewer.FullView();
			}
			catch (Exception e)
			{
				ExceptionPrinter.StackTracePrint( e );
			}
	
			DefaultsRestore();
		}
		else
		{
			Msg.Display( "CodeIterpreter.java failed to initialize." );
		}
	}

	// Loads the entire contents of the given text file into an array of strings.
	static private String[] FileLoad( String file ) throws IOException
	{
		BufferedReader rdr = new BufferedReader(new FileReader(file));
		Vector s = new Vector();

		while (true)
		{
			String line = rdr.readLine();
			if (line == null)
				break;
			s.addElement(line);
		}

		rdr.close();

		String[] a = new String[s.size()];
		s.copyInto(a);

		return a;
	}
	
	static private void Decode( String [] ncCode )
	{
		int indx, jndx, len;
		
		int nBlocks = ncCode.length;
		for (indx = 0; indx < nBlocks; ++indx)
		{
			String block = ncCode[ indx ];
			
			if (DEBUG && BLOCK) Msg.Diagnostic( "block <" + block + ">" );
			
			len = block.length();
			jndx = 0;
			
			while (jndx < len)
			{
				String word = WordGet( block, jndx );
				
				if (DEBUG && WORD) Msg.Diagnostic( "word <" + word + ">" );
				
				NextStateUpdate( word );
				
				jndx += word.length();
			}
			
			ModelUpdate();
			
			CurrStateUpdate();
		}
	}
	
	static private void NextStateUpdate( String word )
	{
		char c = word.charAt( 0 );
		
		switch (c)
		{
		case 'T':
			m_tNext.Set( WordValue( word ) );
			break;
		case 'G':
			{
				int ival = (int) WordValue( word );
				
				switch (ival)
				{
				case 0:
				case 1:
				case 2:
				case 3:
					m_gNext.Set( (double) ival );
					break;
				case 40:
					m_comp = 0;
					break;
				case 41:
					m_comp = 1;
					break;
				case 42:
					m_comp = -1;
					break;
				}
			}
			break;
		case 'X':
			m_xNext.Set( WordValue( word ) );
			break;
		case 'Y':
			m_yNext.Set( WordValue( word ) );
			break;
		case 'Z':
			m_zNext.Set( WordValue( word ) );
			break;
		case 'I':
			m_iNext.Set( WordValue( word ) );
			break;
		case 'J':
			m_jNext.Set( WordValue( word ) );
			break;
		case 'R':
			m_rNext.Set( WordValue( word ) );
			break;
		case 'S':
			m_sNext.Set( WordValue( word ) );
			break;
		case 'F':
			m_fNext.Set( WordValue( word ) );
			break;
		default:
			break;
		}
	}
	
	static private void CurrStateUpdate()
	{
		if ( m_tCurr.Delta( m_tNext.Curr() ) )
			m_tCurr.Set( m_tNext.Curr() );

		if ( m_gCurr.Delta( m_gNext.Curr() ) )
			m_gCurr.Set( m_gNext.Curr() );

		if ( m_xCurr.Delta( m_xNext.Curr() ) )
			m_xCurr.Set( m_xNext.Curr() );

		if ( m_yCurr.Delta( m_yNext.Curr() ) )
			m_yCurr.Set( m_yNext.Curr() );

		if ( m_zCurr.Delta( m_zNext.Curr() ) )
			m_zCurr.Set( m_zNext.Curr() );

		if ( m_iCurr.Delta( m_iNext.Curr() ) )
			m_iCurr.Set( m_iNext.Curr() );

		if ( m_jCurr.Delta( m_jNext.Curr() ) )
			m_jCurr.Set( m_jNext.Curr() );

		if ( m_rCurr.Delta( m_rNext.Curr() ) )
			m_rCurr.Set( m_rNext.Curr() );

		if ( m_sCurr.Delta( m_sNext.Curr() ) )
			m_sCurr.Set( m_sNext.Curr() );

		if ( m_fCurr.Delta( m_fNext.Curr() ) )
			m_fCurr.Set( m_fNext.Curr() );

		int gcode = (int) m_gCurr.Curr();
		if (gcode == 0 || gcode == 1)
			ArcRegistersInit();
	}
	
	static private void ModelUpdate()
	{
		int gcurr = (int) m_gCurr.Curr();
		int gnext = (int) m_gNext.Curr();
		
		if ( m_sCurr.Delta( m_sNext.Curr() ) )
			Model.DefDoubleSet( "speed", m_sCurr.Curr() );
	
		if ( m_fCurr.Delta( m_fNext.Curr() ) )
			Model.DefDoubleSet( "feed", m_fCurr.Curr() );

		if (m_comp == 0)
			Model.DefDelete( "cutside" );
		else
			Model.DefIntSet( "cutside", m_comp );

		if ( m_tCurr.Delta( m_tNext.Curr() ) )
		{
			DbTool dbTool = Model.ToolByStation( (int) m_tNext.Curr() );
			if (dbTool != null)
			{
				String layerName = "tool" + dbTool.IntGet( "NC_Code_Number" );
				DbLayer dbLayer = Model.LayerGet( layerName );
				if (dbLayer == null)
				{
					dbLayer = new DbLayer( layerName );
					dbLayer.Color( dbTool.Color() );
				}

				Model.ActiveLayerSet( dbLayer );
					
				m_dbFeature = new DbFeature( dbTool );
			}
		}

		if (m_dbFeature != null)
		{
			if ( m_xCurr.Delta( m_xNext.Curr() ) ||			
				 m_yCurr.Delta( m_yNext.Curr() ) ||			
				 m_zCurr.Delta( m_zNext.Curr() ) ||
				 (gnext == 2 || gnext ==3) )
			{
				if ( (gcurr == 0 && gnext == 1) ||
					 (gcurr == 1 && gnext == 1) ||
					 (gcurr == 2 && gnext == 1) ||
	 				 (gcurr == 3 && gnext == 1) )
				{
					m_dbFeature.Append( LineCreate() );
				}
				else if (gnext == 2 || gnext == 3)
				{
					m_dbFeature.Append( ArcCreate() );
				}
			}
		}		
	}
	
	static private DbLine LineCreate()
	{
		double xs = m_xCurr.Curr();
		double ys = m_yCurr.Curr();
		double zs = m_zCurr.Curr();
		double xe = m_xNext.Curr();
		double ye = m_yNext.Curr();
		double ze = m_zNext.Curr();
		
		return ( new DbLine( xs, ys, zs, xe, ye, ze ) );
	}
	
	static private DbArc ArcCreate()
	{
		int dir = (((int) m_gNext.Curr() == 2) ? Const.CW : Const.CCW);
		
		// NOTE: the system does not support helical movements.
		Point ps = new Point( m_xCurr.Curr(), m_yCurr.Curr(), m_zCurr.Curr() );
		Point pe = new Point( m_xNext.Curr(), m_yNext.Curr(), m_zCurr.Curr() );
		Point pc = new Point();
		
		if ( m_rNext.Delta( 0.0 ) )
		{
			// When program by R-value, arc included angle are restricted to [0..180]
			if ( !Solver.ArcSER( ps, pe, m_rNext.Curr(), dir, false, pc ) )
				Msg.Diagnostic( "ArcCreate() -- Solver.ArcSER() failed -- r:" + m_rNext.Curr() );
		}
		else
		{
			pc.Assign( (m_xCurr.Curr() + m_iNext.Curr()),
					   (m_yCurr.Curr() + m_jNext.Curr()),
					   (m_zCurr.Curr()) );
		}
		
		return ( new DbArc( ps, pe, pc, dir ) );
	}
		
	static private double WordValue( String word )
	{
		int len = word.length();
		int indx = 0;
		while (indx < len)
		{
			if ( IsNumeric( word.charAt( indx ) ) )
				break;

			++indx;
		}
		
		double value = Double.parseDouble( word.substring( indx, len ) );
		
		if (DEBUG && VALUE) Msg.Diagnostic( "value <" + value + ">" );
		
		return value;
	}
	
	static private String WordGet( String block, int indx )
	{
		int indxA, indxB;
		char c;
		
		indxA = WhiteSpaceSkip( block, indx );
		
		c = block.charAt( indxA );
		
		if (c == '%')
		{
			indxB = indxA + 1;
		}
		else if (c == '(')
		{
			// Assume this is a comment that runs to EOL
			indxB = block.length();
		}
		else
		{
			indxB = WordEndFind( block, indxA );
		}

		return ( block.substring( indxA, indxB ) );
	}
	
	static private int WordEndFind( String block, int indx )
	{
		boolean foundNumeric = false;
		boolean isNumeric = false;
		
		int len = block.length();
		
		while (indx < len)
		{
			char c = block.charAt( indx );

			isNumeric = IsNumeric( c );
			
			if (isNumeric && !foundNumeric)
				foundNumeric = true;
				
			if (foundNumeric && !isNumeric)
				break;

			++indx;
		}
		
		return indx;
	}
	
	static private int WhiteSpaceSkip( String s, int indx )
	{
		while (indx < s.length())
		{
			if ( !IsWhiteSpace( s.charAt( indx ) ) )
				break;
			
			++indx;
		}
		
		return indx;
	}
	
	static private boolean IsWhiteSpace( char c )
	{
		return (c == ' ' || c == '\t');
	}
	
	static private boolean IsNumeric( char c )
	{
		return ((c >= '0' && c <= '9') || c == '.' || c == '-' || c == '+');
	}
	
	static private void DefaultsSave()
	{
		m_defSpeed = Model.DefIntGet( "speed" );
		m_defFeed = Model.DefDoubleGet( "feed" );
		m_defCutside = Model.DefIntGet( "cutside" );
	}
	
	static private void DefaultsRestore()
	{
		if (m_defSpeed < (int) Const.UNDEFINED)
			Model.DefIntSet( "speed", m_defSpeed );

		if (m_defFeed < Const.UNDEFINED)
			Model.DefDoubleSet( "feed", m_defFeed );

		if (m_defCutside < (int) Const.UNDEFINED)
			Model.DefIntSet( "cutside", m_defCutside );
	}

	static private void ArcRegistersInit()
	{
		m_rCurr.Set( 0.0 );
		m_iCurr.Set( 0.0 );
		m_jCurr.Set( 0.0 );

		m_rNext.Set( 0.0 );
		m_iNext.Set( 0.0 );
		m_jNext.Set( 0.0 );
	}
	
	
	//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
	// Note: MiscAddr is used simply because of its Set() & Delta() methods.
	// The Delta() method considers the register's precision.
	//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
	
	static MiscAddr m_gCurr = new MiscAddr( "G", 5, 0, 2, 0, 0, 0, "0" );
	static MiscAddr m_tCurr = new MiscAddr( "T", 5, 0, 2, 0, 0, 0, "0" );
	static MiscAddr m_xCurr = new MiscAddr( "X", 5, 0, 3, 1, 0, 4, "0" );
	static MiscAddr m_yCurr = new MiscAddr( "Y", 5, 0, 3, 1, 0, 4, "0" );
	static MiscAddr m_zCurr = new MiscAddr( "Z", 5, 0, 3, 1, 0, 4, "0" );
	static MiscAddr m_iCurr = new MiscAddr( "I", 5, 0, 3, 1, 0, 4, "0" );
	static MiscAddr m_jCurr = new MiscAddr( "J", 5, 0, 3, 1, 0, 4, "0" );
	static MiscAddr m_rCurr = new MiscAddr( "R", 5, 0, 3, 1, 0, 4, "0" );
	static MiscAddr m_sCurr = new MiscAddr( "S", 5, 0, 3, 0, 0, 0, "0" );
	static MiscAddr m_fCurr = new MiscAddr( "F", 5, 0, 3, 1, 0, 2, "0" );

	static MiscAddr m_gNext = new MiscAddr( "G", 5, 0, 2, 0, 0, 0, "0" );
	static MiscAddr m_tNext = new MiscAddr( "T", 5, 0, 2, 0, 0, 0, "0" );
	static MiscAddr m_xNext = new MiscAddr( "X", 5, 0, 3, 1, 0, 4, "0" );
	static MiscAddr m_yNext = new MiscAddr( "Y", 5, 0, 3, 1, 0, 4, "0" );
	static MiscAddr m_zNext = new MiscAddr( "Z", 5, 0, 3, 1, 0, 4, "0" );
	static MiscAddr m_iNext = new MiscAddr( "I", 5, 0, 3, 1, 0, 4, "0" );
	static MiscAddr m_jNext = new MiscAddr( "J", 5, 0, 3, 1, 0, 4, "0" );
	static MiscAddr m_rNext = new MiscAddr( "R", 5, 0, 3, 1, 0, 4, "0" );
	static MiscAddr m_sNext = new MiscAddr( "S", 5, 0, 3, 0, 0, 0, "0" );
	static MiscAddr m_fNext = new MiscAddr( "F", 5, 0, 3, 1, 0, 2, "0" );
	
	static private int m_comp = 0;
	
	static private int m_defSpeed = (int) Const.UNDEFINED;
	static private int m_defCutside = (int) Const.UNDEFINED;
	static private double m_defFeed = Const.UNDEFINED;
	
	static private DbFeature m_dbFeature = null;
}