package SesameGUI;

import java.io.*;
import javax.swing.*;
import java.text.*;
import java.util.Vector;

public class SpectrumMPSdFileReader
	{
	public SpectrumMPSdFileReader(Reader reader, Spectrum s1, Spectrum s2, Spectrum s3, Spectrum s4, Spectrum s5, Spectrum s6)
		{
    logFile = false;
    
		this.reader = reader;

		this.sp1 = s1;
    this.sp2 = s2;
    this.sp3 = s3;
    this.sp4 = s4;
    this.sp5 = s5;
    this.sp6 = s6;
		}

  public boolean read()
		{
    return read (null , null , null , null , null , null);
    }

  public String getUnitsSp ()
    {
    return unitsSp;    
    }

  public double getWindowLen ()
    {
    return window_len;    
    }

  public double getF0 ()
    {
    return F0;    
    }

  public double getF0_m_sd ()
    {
    return F0_m_sd;    
    }

  public double getF0_p_sd ()
    {
    return F0_p_sd;    
    }

	public boolean read(Spectrum s1, Spectrum s2, Spectrum s3, Spectrum s4, Spectrum s5, Spectrum s6)
		{
		boolean ret;

		ret = false;

		try
			{
			StreamTokenizer streamTokenizer;
      double scale;
      int    scaleT;
			double pos;
			double posInicial;
			double value_s1;
      double value_s2;
      double value_s3;
      double value_s4;
      double value_s5;
      double value_s6;
			int count;

      scale = 1.0;
      scaleT = 0;

      Vector tickers = new Vector();

			count = 0;

			streamTokenizer = new StreamTokenizer(reader);

			streamTokenizer.parseNumbers();
			streamTokenizer.wordChars(33, 255);
			streamTokenizer.whitespaceChars(1, 32);
			streamTokenizer.eolIsSignificant(true);
      //streamTokenizer.commentChar('#');

			pos = 0.0;
			posInicial = 0.0;

      int nt;
      
      nt = streamTokenizer.nextToken();

      unitsSp = new String ("");

      while (nt != StreamTokenizer.TT_EOF)
				{
        if (streamTokenizer.ttype != StreamTokenizer.TT_NUMBER)
          {
          int     cn , enter;

          cn = 0;
          enter = 0;
          nt = streamTokenizer.nextToken();
          
          while (nt != StreamTokenizer.TT_EOF && nt != StreamTokenizer.TT_EOL)
            {
            if (enter == 0 && streamTokenizer.ttype == StreamTokenizer.TT_WORD)
              {
              if (streamTokenizer.sval.equalsIgnoreCase(new String ("n_freq_samples:")))
                enter = 1;
              }

            if (enter == 0 && streamTokenizer.ttype == StreamTokenizer.TT_WORD)
              {
              if (streamTokenizer.sval.equalsIgnoreCase(new String ("window_len:")))
                enter = 2;
              }

            if (enter == 0 && streamTokenizer.ttype == StreamTokenizer.TT_WORD)
              {
              if (streamTokenizer.sval.equalsIgnoreCase(new String ("labels:")))
                {
                nt = streamTokenizer.nextToken();
                unitsSp = streamTokenizer.sval;
                }
              }

            if (enter == 2 && streamTokenizer.ttype == StreamTokenizer.TT_NUMBER)
              {
              window_len = streamTokenizer.nval;
              }
              
            if (enter == 1 && streamTokenizer.ttype == StreamTokenizer.TT_NUMBER)
              {
              cn++;

              if (cn == 2)
                F0 = streamTokenizer.nval;

              if (cn == 4)
                F0_m_sd = streamTokenizer.nval;

              if (cn == 5)
                F0_p_sd = streamTokenizer.nval;
              }
            
            nt = streamTokenizer.nextToken();
            }

          if (nt == StreamTokenizer.TT_EOL)
            nt = streamTokenizer.nextToken();

          continue;
          }
          
        if (streamTokenizer.ttype == StreamTokenizer.TT_NUMBER)
          {
        	pos = streamTokenizer.nval;

          if (count == 0)
            posInicial = pos;

          tickers.add (new Double (pos));

          streamTokenizer.nextToken();
          value_s1 = streamTokenizer.nval;

          streamTokenizer.nextToken();
          if (streamTokenizer.ttype == StreamTokenizer.TT_WORD)
            {
            value_s1 *= Math.pow(10.0 , Double.parseDouble (streamTokenizer.sval.substring(1)));
            streamTokenizer.nextToken();
            }
          value_s2 = streamTokenizer.nval;

          streamTokenizer.nextToken();
          if (streamTokenizer.ttype == StreamTokenizer.TT_WORD)
            {
            value_s2 *= Math.pow(10.0 , Double.parseDouble (streamTokenizer.sval.substring(1)));
            streamTokenizer.nextToken();
            }
          value_s3 = streamTokenizer.nval;

          streamTokenizer.nextToken();
          if (streamTokenizer.ttype == StreamTokenizer.TT_WORD)
            {
            value_s3 *= Math.pow(10.0 , Double.parseDouble (streamTokenizer.sval.substring(1)));
            streamTokenizer.nextToken();
            }
          value_s4 = streamTokenizer.nval;

          streamTokenizer.nextToken();
          if (streamTokenizer.ttype == StreamTokenizer.TT_WORD)
            {
            value_s4 *= Math.pow(10.0 , Double.parseDouble (streamTokenizer.sval.substring(1)));
            if (scale < Math.pow(10.0 , Double.parseDouble (streamTokenizer.sval.substring(1)) * -1.0))
              {
              scale = Math.pow(10.0 , Double.parseDouble (streamTokenizer.sval.substring(1)) * -1.0);
              scaleT = (int) (Double.parseDouble (streamTokenizer.sval.substring(1)));
              }
              
            streamTokenizer.nextToken();
            }
          value_s5 = streamTokenizer.nval;

          streamTokenizer.nextToken();
          if (streamTokenizer.ttype == StreamTokenizer.TT_WORD)
            {
            value_s5 *= Math.pow(10.0 , Double.parseDouble (streamTokenizer.sval.substring(1)));
            if (scale < Math.pow(10.0 , Double.parseDouble (streamTokenizer.sval.substring(1)) * -1.0))
              {
              scale = Math.pow(10.0 , Double.parseDouble (streamTokenizer.sval.substring(1)) * -1.0);
              scaleT = (int) (Double.parseDouble (streamTokenizer.sval.substring(1)));
              }
              
            streamTokenizer.nextToken();
            }
          value_s6 = streamTokenizer.nval;

          streamTokenizer.nextToken();

          if (streamTokenizer.ttype == StreamTokenizer.TT_WORD)
            {
            value_s6 *= Math.pow(10.0 , Double.parseDouble (streamTokenizer.sval.substring(1)));
            if (scale < Math.pow(10.0 , Double.parseDouble (streamTokenizer.sval.substring(1)) * -1.0))
              {
              scale = Math.pow(10.0 , Double.parseDouble (streamTokenizer.sval.substring(1)) * -1.0);
              scaleT = (int) (Double.parseDouble (streamTokenizer.sval.substring(1)));
              }
              
            streamTokenizer.nextToken();
            }

          sp1.add(value_s1);
          sp2.add(value_s2);
          sp3.add(value_s3);

          if (sp4 != null)
            {
            sp4.add(value_s4);
            sp5.add(value_s5);
            sp6.add(value_s6);          
            }
          else
            {
            if (s1 != null)
              {
              s1.add(value_s1 * value_s4);
              if (value_s4 != 0.0)
                s2.add(value_s1 / value_s4);
              else
                s2.add(0.0);
              s3.add(value_s2 * value_s5);
              if (value_s5 != 0.0)
                s4.add(value_s2 / value_s5);
              else
                s4.add(0.0);
              s5.add(value_s3 * value_s6);
              if (value_s6 != 0.0)
                s6.add(value_s3 / value_s6);
              else
                s6.add(0.0);
              }
            }

          nt = streamTokenizer.nextToken(); // nl

          count++;
          }
        else
          {
          nt = streamTokenizer.nextToken();
          }
				}

      if (scale != 1.0)
        {
        if (sp4 != null)
          {
          for (int i = 0 ; i < sp4.samples.size() ; i++)
            {
            sp4.setScale (scale , scaleT);
            sp5.setScale (scale , scaleT);
            sp6.setScale (scale , scaleT);
            }
          }  
         else if (s1 != null)
          {
          for (int i = 0 ; i < s1.samples.size() ; i++)
            {
            s1.setScale (scale , scaleT);
            s2.setScale (scale , scaleT);
            s3.setScale (scale , scaleT);
            s4.setScale (scale , scaleT);
            s5.setScale (scale , scaleT);
            s6.setScale (scale , scaleT);
            }
          }
        }

      if (Math.abs(((pos - posInicial) / count) - (((Double)(tickers.get(1))).doubleValue() - posInicial)) > 0.01)
        logFile = true;

      double sra , post;
      
      sra = (pos - posInicial) / count;
      post = posInicial - sra;

      ignoreTo = 0;
      
      while (post > 0.0)
        {
        ignoreTo++;
        tickers.insertElementAt (new Double (post) , 0);

        sp1.insertAt (0.0 , 0);
        sp2.insertAt (0.0 , 0);
        sp3.insertAt (0.0 , 0);

        if (sp4 != null)
          {
          sp4.insertAt (0.0 , 0);
          sp5.insertAt (0.0 , 0);
          sp6.insertAt (0.0 , 0);
          }
        else
          {
          if (s1 != null)
            {
            s1.insertAt (0.0 , 0);
            s2.insertAt (0.0 , 0);
            s3.insertAt (0.0 , 0);
            s4.insertAt (0.0 , 0);
            s5.insertAt (0.0 , 0);
            s6.insertAt (0.0 , 0);
            }
          }
        
        post -= sra;
        }

      if (ignoreTo > 0)
        {
        sp1.setIgnoreTo (ignoreTo);
        sp2.setIgnoreTo (ignoreTo);
        sp3.setIgnoreTo (ignoreTo);

        if (sp4 != null)
          {
          sp4.setIgnoreTo (ignoreTo);
          sp5.setIgnoreTo (ignoreTo);
          sp6.setIgnoreTo (ignoreTo);
          }
        else
          {
          if (s1 != null)
            {
            s1.setIgnoreTo (ignoreTo);
            s2.setIgnoreTo (ignoreTo);
            s3.setIgnoreTo (ignoreTo);
            s4.setIgnoreTo (ignoreTo);
            s5.setIgnoreTo (ignoreTo);
            s6.setIgnoreTo (ignoreTo);
            }
          }
        }

      posInicial = post + sra;

			sp1.setSamplingRate((pos - posInicial) / count);
      sp1.setOrigOffset (posInicial);
      sp2.setSamplingRate((pos - posInicial) / count);
      sp2.setOrigOffset (posInicial);
			sp3.setSamplingRate((pos - posInicial) / count);
      sp3.setOrigOffset (posInicial);

      if (logFile)
        {
        sp1.setTickers (tickers);
        sp2.setTickers (tickers);
        sp3.setTickers (tickers);
        }

      if (sp4 != null)
        {
        sp4.setSamplingRate((pos - posInicial) / count);
        sp4.setOrigOffset (posInicial);
        sp5.setSamplingRate((pos - posInicial) / count);
        sp5.setOrigOffset (posInicial);
        sp6.setSamplingRate((pos - posInicial) / count);
        sp6.setOrigOffset (posInicial);

        if (logFile)
          {
          sp4.setTickers (tickers);
          sp5.setTickers (tickers);
          sp6.setTickers (tickers);
          }
        }
      else
        {
        if (s1 != null)
          {
          s1.setSamplingRate((pos - posInicial) / count);
          s1.setOrigOffset (posInicial);
          s2.setSamplingRate((pos - posInicial) / count);
          s2.setOrigOffset (posInicial);
          s3.setSamplingRate((pos - posInicial) / count);
          s3.setOrigOffset (posInicial);
          s4.setSamplingRate((pos - posInicial) / count);
          s4.setOrigOffset (posInicial);
          s5.setSamplingRate((pos - posInicial) / count);
          s5.setOrigOffset (posInicial);
          s6.setSamplingRate((pos - posInicial) / count);
          s6.setOrigOffset (posInicial);

          if (logFile)
            {
            s1.setTickers (tickers);
            s2.setTickers (tickers);
            s3.setTickers (tickers);
            s4.setTickers (tickers);
            s5.setTickers (tickers);
            s6.setTickers (tickers);
            }
          }
        }

			ret = true;
			}
		catch (Exception e)
			{
			}

		return ret;
		}

	private Spectrum sp1;
  private Spectrum sp2;
  private Spectrum sp3;

  private Spectrum sp4;
  private Spectrum sp5;
  private Spectrum sp6;

  private double    F0;
  private double    F0_m_sd;
  private double    F0_p_sd;

  private double    window_len;
  
	private Reader reader;

  private boolean logFile;

  private String unitsSp;

  private int ignoreTo;
	}