/*
Copyright @ 2003, The Institute for Genomic Research (TIGR).
All rights reserved.
*/

/***************************************************************************
 * Author:  Jianwei (Jerry) Li and Joe White
 * Name:  TavConverter (Version 1.3)
 * Date:  Created: 03/29/2002 and modified: 04/04/2003
 * Descp: A Java class that reads a GenePix file and write it as a .tav file
 * 07/10/02: Modified calculateDensity() to make correct intensisty
 * 07/31/02: To meet the new version (4.0) of grp file, modified to automatically
 *           pick up the required values for conversion.
 * 09/25/02: The wave-lengths in the header could be changed based on what kind
 *           of filter is used for scanning.  So the key for densities is not
 *           stable and program should dynamically change the key.
 * 11/22/02: Because .tav file alway has Cy3-Cy5 order for 7-8 columns, modifed
 *           the order of 532 and 635 to follow the way.  Here we suppose 532 is
 *           for Cy3 and 635 for Cy5.
 * 02/10/03: Added a contructor to accept mutiple files to process at one time.
 ***************************************************************************/

package org.tigr.microarray.converter;

import java.util.*;
import java.awt.*;
import java.io.*;
import javax.swing.*;
import org.tigr.util.FileReading;
import org.tigr.util.StringSplitter;
import org.tigr.util.io.MyIni;

public class TavConverter extends Converter {

  private String bgChA, bgChB, bgChAn, bgChBn, bgChAmean, bgChAnMean, bgChBnMean, bgChBmean;
  private String chA, chAn, chB, chBn, chAMean, chAnMean, chBMean, chBnMean;
  private String chAMedian, chBMedian, chAnMedian, chBnMedian;
  private String chAs, chAsn, chBs, chBsn;
  private String gpFileName;
  private int fPixAddr;
  private boolean keepAll;
  private boolean useMean;
  private boolean tavIntensity; // the output needs to calculation.

  private final int FIRST_NUM = 1;

  private final String FLAG = "\"Flags\"";
  private final String BLOCK = "\"Block\"";
  private final String COLUMN = "\"Column\"";
  private final String RW = "\"Row\"";
  private final String F_PIX = "\"F Pixels\"";
  private final String FLAG_N = "Flags";
  private final String BLOCK_N = "Block";
  private final String COLUMN_N = "Column";
  private final String ROW_N = "Row";

  private final String F_PIX_N = "F Pixels";
  private final String WAVE_KEY_1 = "ImageName";
  private final String WAVE_KEY_2 = "Wavelengths";

  /****************************************************************************
   *<b>Constructor: </b>
   *<p><b>Parameters: </b>
   *<br> gfName --- the name of GenePix file to be converted.
   *<br> tfName --- the name of .tav file that is an output.
   *****************************************************************************/
  public TavConverter(String gfName, String tfName) {
    super();
    inFileNames = new Vector(1);
    outFileNames = new Vector(1);
    inFileNames.add(gfName);
    outFileNames.add(tfName);
    msg = new String("");
    ready = false;
    wantSort = true;
    keepAll = true;
    fetalError = false;
    minorError = false;
    useMean = true;
    tavIntensity = true;
  }

  /****************************************************************************
   *<b>Constructor: </b>
   *<p><b>Parameters: </b>
   *<br> gfNames --- the names of GenePix files to be converted.
   *<br> tfNames --- the names of .tav files that is an output.
   *****************************************************************************/
  public TavConverter(Vector gfNames, Vector tfNames) {
    super();
    inFileNames = gfNames;
    outFileNames = tfNames;
    msg = new String("");
    ready = false;
    wantSort = true;
    keepAll = true;
    fetalError = false;
    minorError = false;
    useMean = true;
    tavIntensity = true;
  }

  public int getTaskEnd() { return taskEnd; }
  public int getCurrent() { return counter; }
  public String getErrorMsg() { return msg; }
  public String getFileName() { return gpFileName; }
  public void useMeanForIntensity(boolean b) { useMean = b; }

  /***************************************************************************
   * <b>Description: </b>
   *   overrides an abstract method to implement the main function of class.
   **************************************************************************/
  public void run () {
    boolean going, noError;
    String aLine = new String("");
    String densA = new String("");
    String densB = new String("");
    String tavLine = new String("");
    String flagA = new String("");
    String flagB = new String("");
    String bgA = new String("");  // background info for channel A
    String bgB = new String("");  // background info for channel B
    String tavFileName;
    String colValues[];
    String extraInfo = new String("");
    String colNames[];
    String waves[] = new String[2]; // first for channel A and second for B.
    int hLines;
    int max = 0;
    int maxRow = 0;
    int maxCol = 0;
    int maxMetaCol, block, row, col, metaRow, metaCol, slideRow, slideCol, spAreaA, spAreaB;
    int i, j, k, flagInt, flagIndex, blockIndex, colIndex, rowIndex;
    int f635m, b635m, f635s, f532m, f532s, b532m;
    int bgCh1Mean, bgCh2Mean, fCh1Mean, fCh2Mean, fCh1Median, fCh2Median;
    int numOfFiles;
    int fSize;
    BufferedWriter bufWriter = null;
    FileOutputStream fileOut = null;
    FileReading fileReader;
    Vector genepixFile;

    taskEnd = determineTaskEnd();
    if(taskEnd == 1){
      return;
    }
    taskEnd <<= 1;

    counter = 0;
    numOfFiles = inFileNames.size();
    for(i=0; i<numOfFiles; i++){
      noError = true;
      gpFileName = (String)inFileNames.elementAt(i);
      tavFileName = (String)outFileNames.elementAt(i);
      try{
        fileReader = new FileReading(gpFileName);
        if(fileReader.done){
          genepixFile = fileReader.getFileContentInLines();
        } else {
          setErrorMessage(fileReader.getProcessMessage());
          taskEnd = 1;
          counter = 1;
          return;
        }
      } catch (IOException e){
        setErrorMessage(e.getMessage());
        taskEnd = 1;
        counter = 1;
        return;
      }


      fSize = genepixFile.size();
        // determing the number of lines for header info
      hLines = 0;
      going = true;
      while(going){
        aLine = (String)genepixFile.elementAt(hLines);
        if(aLine.charAt(0) == '"' || isChar(aLine.charAt(0))){
          // scanner could use different wavelength for the two chennels
          if(isWaveLengthDefination(aLine)){
            waves = getWaveLengths(aLine);
          }
          going = true;
          hLines++;
        } else {
          if(hLines == FIRST_NUM){
            going = true;
            hLines++;
          } else{
            going = false;
          }
        }
      }

      defineKeys(waves);
      aLine = (String)genepixFile.elementAt(hLines-1);
      colNames = separateLine(aLine);

      blockIndex = findRightCol(colNames, BLOCK, BLOCK_N);
      colIndex = findRightCol(colNames, COLUMN, COLUMN_N);
      rowIndex = findRightCol(colNames, RW, ROW_N);

      aLine = (String)genepixFile.elementAt(fSize-1);
      colValues = separateLine(aLine);

      if(colValues.length > 2){
        max = Integer.parseInt(colValues[blockIndex]);
        maxCol = Integer.parseInt(colValues[colIndex]);
        maxRow = Integer.parseInt(colValues[rowIndex]);
      } else {
        JOptionPane.showMessageDialog(null,
          "You might add extra space at the end of file.\n(" + gpFileName +
          "). \nPlease remove it and try again. Converting will continue " +
          "\nfor remaining files", "GenePix-Tav Converter",
          JOptionPane.ERROR_MESSAGE);
        noError = false;
        counter += numOfFiles;
      }

      if(noError){
        if(max <= 12){
          maxMetaCol = 2;
        } else {
          maxMetaCol = 4;
        }

          // check if the original file has been modified.
        noError = true;
        if((max * maxCol * maxRow) + hLines != genepixFile.size()){
          JOptionPane.showMessageDialog(null,
            "You might have dropped some of your spots in the file \n(" +
            gpFileName + ".\nThe converter requires an original GenePix file." +
            "\nConverting will continue for the remaining files", "GenePix-Tav Converter",
            JOptionPane.ERROR_MESSAGE);
          noError = false;
          counter += numOfFiles;
        }

        if(noError){
          flagIndex = findRightCol(colNames, FLAG, FLAG_N);
          fPixAddr = findRightCol(colNames, F_PIX, F_PIX_N);

          f635m = findRightCol(colNames, chA, chAn);
          f635s = findRightCol(colNames, chAs, chAsn);
          fCh1Mean = findRightCol(colNames, chAMean, chAnMean);
          fCh1Median = findRightCol(colNames, chAMedian, chAnMedian);
          b635m = findRightCol(colNames, bgChA, bgChAn);
          bgCh1Mean = findRightCol(colNames, bgChAmean, bgChAnMean);

          f532m = findRightCol(colNames, chB, chBn);
          f532s = findRightCol(colNames, chBs, chBsn);
          fCh2Mean = findRightCol(colNames, chBMean, chBnMean);
          fCh2Median = findRightCol(colNames, chBMedian, chBnMedian);
          b532m = findRightCol(colNames, bgChB, bgChBn);
          bgCh2Mean = findRightCol(colNames, bgChBmean, bgChBnMean);

          try{
            fileOut = new FileOutputStream(tavFileName);
            bufWriter = new BufferedWriter(new OutputStreamWriter(fileOut));
            sortKeys = new int[NUM_SORT][fSize - hLines];
            outFile = new String[fSize - hLines];

            counter += hLines;
            for(j = hLines, k=0; j<fSize; j++, k++){
              aLine = (String)genepixFile.elementAt(j);
              colValues = separateLine(aLine);

              block = Integer.parseInt(colValues[blockIndex]);
              col = Integer.parseInt(colValues[colIndex]);
              row = Integer.parseInt(colValues[rowIndex]);

                // channel A is always for Cy3 and B for Cy3 in .tav file
              spAreaA = calculateSpotDimeter(colValues, f532s);
              spAreaB = calculateSpotDimeter(colValues, f635s);

              //densA = calculateDensity(colValues, f532m, spAreaA, b532m);
              //densB = calculateDensity(colValues, f635m, spAreaB, b635m);
              if(tavIntensity){
                bgA = calculateBackground(colValues, b532m);
                bgB = calculateBackground(colValues, b635m);
                densA = calculateDensity(colValues, f532m, f532s, b532m);
                densB = calculateDensity(colValues, f635m, f635s, b635m);
              } else {
                if(useMean){
                  bgA = colValues[bgCh2Mean];
                  bgB = colValues[bgCh1Mean];
                  densA = colValues[fCh2Mean];
                  densB = colValues[fCh1Mean];

                } else {
                  bgA = colValues[b532m];
                  bgB = colValues[b635m];
                  densA = colValues[fCh2Median];
                  densB = colValues[fCh1Median];
                }
              }
              flagA = setFlag(colValues, f532s, flagIndex);
              flagB = setFlag(colValues, f635s, flagIndex);

              metaRow = ((block -1) / maxMetaCol) + 1;
              metaCol = ((block -1) % maxMetaCol) + 1;
              slideRow = (metaRow - 1) * maxRow + row;
              slideCol = (metaCol -1 ) * maxCol + col;

              tavLine = slideRow +"\t"+ slideCol +"\t"+ metaRow +"\t"+ metaCol
                +"\t"+ row +"\t"+ col +"\t"+ densA +"\t"+ densB
                + "\t" + spAreaA + "\t" + spAreaB + "\tnull\tnull\tnull\t" + bgA
                + "\t" + bgB + "\t" + flagA + "\t" + flagB;

              if(keepAll){
                extraInfo = setAnnotaionInfo(colValues, flagIndex);
                tavLine += extraInfo.toString();
              }

              outFile[k] = new String(tavLine);
              sortKeys[0][k] = k;
              sortKeys[1][k] = slideRow;
              sortKeys[2][k] = slideCol;

              counter++;
            } // end of the for loop for a single file.

            if(wantSort){
              sorted = sortRowCol(maxMetaCol, maxCol);
              // write to file
              for(j = 0; j<outFile.length; j++){
                bufWriter.write(outFile[sorted[j]]);
                bufWriter.newLine();
                bufWriter.flush();
                counter++;
              }
            } else {
              for(j = 0; j<outFile.length; j++){
                bufWriter.write(outFile[j]);
                bufWriter.newLine();
                bufWriter.flush();
                counter++;
              }
            }
            fileOut.close();
          } catch (IOException ie){
            fetalError = true;
            System.out.println("Error in writing file: " + ie.getMessage());
            msg += "**********\n";
            msg += "Error in writing file: " + ie.getMessage() + "\n";
          }
        }
      }
    } // end of for loop for number of files.
    ready = true;
    counter = taskEnd;
  }

  public void setSortSpots(boolean b){ wantSort = b; }
  public void setKeepAllInformation(boolean b) { keepAll = b; }

  /****************************************************************************
   * <b>Description: </b>
   *   calculate background for a channel with bg = median * area
   * <p><b>Parameters: </b>
   * <br> tuple -- all information in one row
   * <br> backg -- address for background medien column
   * <p><b>Return: </b> the background information
   ***************************************************************************/
  private String calculateBackground(String[] tuple, int backg){
    float fPix, bMedian;
    int temp;
    //float temp;
    String bg = new String("");

    try{
      fPix = Float.parseFloat(tuple[fPixAddr]);
      bMedian = Float.parseFloat(tuple[backg]);
      temp = (int)(bMedian * fPix);
      //temp = (bMedian * fPix);
      bg += temp;
    }  catch (NumberFormatException nfex) {
      minorError = true;
      bg = "null";
      msg += "**********\n";
      msg += "There is an unacceptable value for either F Pixcel or B Median;\n";
      msg += "and the intensity was set to null.\n";
    }
    return bg;
  }

  /*****************************************************************************
   * <b>Description: </b>
   *   calculates the spot area in terms of pixel number.
   * <p><b>Parameters: </b>
   * <br> tuple -- all information in one row.
   * <br> sat -- address for saturated pixels column.
   * <p><b>Return: </b> the spot area.
   ***************************************************************************/
  private int calculateSpotDimeter(String[] tuple, int sat){
    float fSat, fPix;
    int temp;

    fPix = Float.parseFloat(tuple[fPixAddr]);
    fSat = Float.parseFloat(tuple[sat]);
    fSat = fSat / 100;
    temp = (int) (fPix * (1 - fSat));
    return temp;
  }

  /****************************************************************************
   * <b>Description: </b>
   *   calculate density for a channel
   * <p><b>Parameters: </b>
   * <br> tuple -- all information in one row
   * <br> med -- address for either channel A or B median column
   * <br> area -- spot area in number of pixels
   * <br> backg -- address for background medien column
   * <p><b>Return: </b> the density
   ***************************************************************************/
 // private String calculateDensity(String[] tuple, int med, int area, int backg){
  private String calculateDensity(String[] tuple, int med, int sat, int backg){
    float fMedian, bMedian, fPix, bPix, fSat;
    int temp;
    String den = new String("");

    try{
      fMedian = Float.parseFloat(tuple[med]);
      bMedian = Float.parseFloat(tuple[backg]);
      //temp = (int)((fMedian - bMedian) * area);

      fPix = Float.parseFloat(tuple[fPixAddr]);
      fSat = Float.parseFloat(tuple[sat]);
      fSat = fSat / 100;
      temp = (int)(fPix * (fMedian - bMedian) * ( 1 - fSat));
      //temp = (fPix * (fMedian - bMedian) * ( 1 - fSat));

      den += temp;
    } catch (NumberFormatException nfex) {
      minorError = true;
      den = "null";
      msg += "**********\n";
      msg += "There is an unacceptable value to calculate intensity; and the intensity was set to null.\n";
    }
    return den;
  }

  /****************************************************************************
   * <b>Description: </b>
   *    find the wave lengths from the header information
   * <p><b>Parameters: </b>
   * <br> str -- a line of the file that contains wave lengths.
   * <P><b>Return: </b> the wave lengths as an array.
   ****************************************************************************/
  private String[] getWaveLengths(String str){
    int num;
    String wv;
    String tempWave[] = new String[2];
    String wavStr = new String(str.substring(str.indexOf('=')+1, str.lastIndexOf('\"')));
    StringTokenizer token = new StringTokenizer(wavStr);

    num = 0;
    while(token.hasMoreTokens()){
      wv = token.nextToken();
      if(isNumber(wv)){
        tempWave[num] = new String(wv);
        num++;
      }
    }
    return tempWave;
  }

  /****************************************************************************
   * <b>Description: </b>
   *    assignes values to the keys for searching right columns.
   * <p><b>Parameter: </b>
   * <br> wvs --- the wave lenghts.
   ***************************************************************************/
  private void defineKeys(String[] wvs) {
    chA = new String("\"F" + wvs[0] + " Median\"");
    chB = new String("\"F" + wvs[1] + " Median\"");
    chAMean = new String("\"F" + wvs[0] + " Mean - B" + wvs[0] + "\"");
    chBMean = new String("\"F" + wvs[1] + " Mean - B" + wvs[1] + "\"");
    chAMedian = new String("\"F" +wvs[0] + " Median - B" + wvs[0] + "\"");
    chBMedian = new String("\"F" + wvs[1] + " Median - B" + wvs[1] + "\"");
    chAs = new String("\"F" + wvs[0] + " % Sat.\"");
    chBs = new String("\"F" + wvs[1] + " % Sat.\"");
    bgChA = new String("\"B" + wvs[0] + " Median\"");
    bgChB = new String("\"B" + wvs[1] + " Median\"");
    bgChAmean = new String("\"B" + wvs[0] + " Mean\"");
    bgChBmean = new String("\"B" + wvs[1] + " Mean\"");

    chAn = new String("F" + wvs[0] + " Median");
    chBn = new String("F" + wvs[1] + " Median");
    chAnMean = new String("F" + wvs[0] + " Mean - B" + wvs[0]);
    chBnMean = new String("F" + wvs[1] + " Mean - B" + wvs[1]);
    chAnMedian = new String("F" + wvs[0] + " Median - B" + wvs[0]);
    chBnMedian = new String("F" + wvs[1] + " Median - B" + wvs[1]);
    chAsn = new String("F" + wvs[0] + " % Sat.");
    chBsn = new String("F" + wvs[1] + " % Sat.");
    bgChAn = new String("B" + wvs[0] + " Median");
    bgChBn = new String("B" + wvs[1] + " Median");
    bgChAnMean = new String("B" + wvs[0] + " Mean");
    bgChBnMean = new String("B" + wvs[1] + " Mean");
  }

  /****************************************************************************
   * <b>Description: </b>
   *    find the address of the column that is interested.
   * <p><b>Parameters: </b>
   * <br> str -- a line of the file
   * <br> key -- column name to be searched
   * <br> noQuato -- column name withouth quato.
   * <P><b>Return: </b> the index of the column
   ****************************************************************************/
  private int findRightCol(String str[], String key, String noQuato){
    int addr = 0;
    int size = str.length;
    int i;
    String temp = new String("");

    for(i=0; i<str.length; i++){
      if(str[i].equalsIgnoreCase(key) || str[i].equalsIgnoreCase(noQuato)){
        addr = i;
        i = str.length;
      }
    }
    return addr;
  }

  /****************************************************************************
   *<b>Description: </b>
   *  check if a parameter is a character.
   *<p><b>Parameter: </b>
   *<br> x --- the input to be checked.
   *<p><b>Return: </b> true if the input is a character; otherwise, false.
   ****************************************************************************/
  private boolean isChar(char x){
    boolean b = true;

    switch(x) {
      case '1': case '2': case '3': case '4': case '5': case '6': case '7':
      case '8': case '9': case '0':
      b = false;
      break;

      default: b = true;
    }
    return b;
  }

  /****************************************************************************
   *<b>Description: </b>
   *  check if a input string is a number.
   *<p><b>Parameter: </b>
   *<br> x --- the input to be checked.
   *<p><b>Return: </b> true if the input is a character; otherwise, false.
   ****************************************************************************/
  private boolean isNumber(String x){
    boolean b = true;
    int length = x.length();

    for(int i=0; i<length; i++){
      if(isChar(x.charAt(i))){
        b = false;
        i = length;
      }
    }
    return b;
  }

  /****************************************************************************
   *<b>Description: </b>
   *  check if a string contains wave length information.
   *<p><b>Parameter: </b>
   *<br> str --- the input to be checked.
   *<p><b>Return: </b> true if the input contains the info; otherwise, false.
   ****************************************************************************/
  private boolean isWaveLengthDefination(String str){
    String temp = str;
    if(temp.charAt(0) == '\"' && temp.indexOf('=') > 0){
      temp = temp.substring(1, temp.indexOf('='));
      if(temp.equalsIgnoreCase(WAVE_KEY_1) || temp.equalsIgnoreCase(WAVE_KEY_2)){
        return true;
      } else {
        return false;
      }
    } else {
      return false;
    }
  }

  /*****************************************************************************
   *<b>DESCRIPTION: </b>
   *   set all other annotation information to a string for attaching
   *<p><b>Parameters: </b>
   *<br>  val --- all info of a spot
   *<br>  fAddr --- the index for the flag
   *<p><b>RETRUNED: </b>  the annotation info
   ***************************************************************************/
  private String setAnnotaionInfo(String[] val, int fAddr){
    StringBuffer temp = new StringBuffer();
    int i;

    for(i=3; i<val.length; i++){
      if(i != fAddr){
        temp.append("\t" + val[i]);
      }
    }
    return temp.toString();
  }

  /*****************************************************************************
   *<b>DESCRIPTION: </b>
   *   set flag based on saturated pixels
   *<p><b>Parameters: </b>
   *<br>  tuple --- the information of one spot
   *<br>  sat --- the address of satureated pixels
   *<br>  indx --- the address of orginal flag
   *<p><b>RETRUNED: </b>  the flag
   ***************************************************************************/
  private String setFlag(String[] tuple, int sat, int indx){
    String f = new String("");
    int flagInt;
    float test, fPix, fSat;

    flagInt = Integer.parseInt(tuple[indx]);
    if(flagInt < 0){
      f = "X";
    } else {
      fPix = Float.parseFloat(tuple[fPixAddr]);
      fSat = Float.parseFloat(tuple[sat]);
      test = fPix * (1 - fSat);
      if(test < 10){
        f = "A";
      } else if (test >= 10 || test < 50){
        f = "B";
      } else {
        f = "C";
      }
    }
    return f;
  }
}