/***************************************************************************
 * Author:  Jianwei(Jerry) Li.
 * Name:  AlignetMev (Version 1.0)
 * Date:  Created: 07/01/2004 and modified: 07/01/2004
 * Descp: A Java class that reads an Agilent file and write it as a .mev file
 ***************************************************************************/

package org.tigr.microarray.converter;

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

import org.tigr.microarray.MevAttributes;
import org.tigr.util.FileReading;
import org.tigr.util.StringSplitter;
import org.tigr.util.io.MyIni;
import org.tigr.util.io.IOUtil;
import org.tigr.util.MyTimer;

public class AgilentMev extends MevConverter implements MevAttributes{

  final String BG_MED_SIGNAL = "BGMedianSignal";
  final String BG_NUM_PIX  = "BGNumPix";
  final String COL = "Col";
  final String DESC = "Description";
  final String FEATURES = "FEATURES";
  final String FEATURE_NUM = "FeatureNum";
  final String MED_SIGNAL = "MedianSignal";
  final String NUM_PIX = "NumPix";
  final String POS_X = "PositionX";
  final String RW = "Row";

  String gBkgMedSignalA, gBkgMedSignalB;
  String gBkgPixelA, gBkgPixelB;
  String gChApixel, gChBpixel;
  String gMedSignalA, gMedSignalB;

  private JFrame parent;
  private String inFileNamePath;
  private String mevFileName;
  private String barTitle;
  int gAnnType;
  int gPosX, gColIndex;

  private final int TOTAL = 0;
  private final int MEAN = 1;
  private final int MODE = 2;
  private final int MEDIAN = 3;

  /****************************************************************************
   *<b>Constructor: </b>
   *<p><b>Parameters: </b>
   *<br> afName --- the name of Agilent file to be converted.
   *<br> mfName --- the name of mev file that is an output.
   *<br> title -- the string showed on the window bar.
   *****************************************************************************/
  public AgilentMev(String afName, String mfName, String title) {
    super();
    inFileNames = new Vector(1);
    outFileNames = new Vector(1);
    inFileNames.add(afName);
    outFileNames.add(mfName);
    barTitle = title;
  }

  /****************************************************************************
   *<b>Constructor: </b>
   *<p><b>Parameters: </b>
   *<br> afNames --- the names of Agilent files to be converted.
   *<br> mfNames --- the names of mev files that are outputs.
   *<br> title -- the string showed on the window bar.
   *<br> annNum --- the ann file type, one for one / many for one.
   *****************************************************************************/
  public AgilentMev(JFrame p, Vector afNames, Vector mfNames, String title, int annNum) {
    super();
    parent = p;
    inFileNames = afNames;
    outFileNames = mfNames;
    barTitle = title;
    gAnnType = annNum;
  }

  /***************************************************************************
   * <b>Description: </b>
   *   overrides an abstract method to implement the main function of class.
   **************************************************************************/
  public void run () {
    boolean noError;
    String aLine = new String("");
    String densA = new String("");
    String densB = new String("");
    String bgA = new String("");  // background info for channel A
    String bgB = new String("");  // background info for channel B
    String medA = new String("null");
    String medB = new String("null");
    String unid = new String("");
    String spAreaA, spAreaB;
    String annoFileNamePath;
    String aligentFileName;
    String colValues[];
    String colNames[];
    String channels[] = {"g", "r"};
    String dataStart[];
    String annoFile[] = null;
    String mevFileHeader[];
    StringBuffer mevLine = new StringBuffer(200);
    StringBuffer extraInfo = new StringBuffer(200);
    int numOfFiles;
    int hLines;    // the index of  header of data section
    int lastLine;  // the index of last line of data
    int row, col, metaRow, metaCol, slideRow, slideCol, unidLoc;
    int i, j, k, flagInt, rowIndex, annAddr;
    int ch1IntenLoc, ch1Bkg, ch1AreaLoc, ch2IntenLoc, ch2Bkg, ch2AreaLoc;
    int ch1BkgArea, ch2BkgArea;
    int numSpot;
    Vector aligentFile;
    BufferedWriter mevWriter = null;
    BufferedWriter annoWriter = null;
    FileOutputStream mevFileOut = null;
    FileReading fileReader;

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

    counter = 0;
    numOfFiles = inFileNames.size();

    for(i=0; i<numOfFiles; i++){
      noError = true;
      inFileNamePath = (String)inFileNames.elementAt(i);
      mevFileName = (String)outFileNames.elementAt(i);
      try {
        fileReader = new FileReading(inFileNamePath);

        if(fileReader.done){
          aligentFile = fileReader.getFileContentInLines();
        } else {
          setErrorMessage(fileReader.getProcessMessage());
          taskEnd = 1;
          counter = 1;
          return;
        }
      } catch (IOException e){
        setErrorMessage(e.getMessage());
        taskEnd = 1;
        counter = 1;
        return;
      }

        // find the data section in the Agilent file
      dataStart = getValueAndIndex(aligentFile, FEATURES);
      hLines = Integer.parseInt(dataStart[1]);
      lastLine = aligentFile.size() - 1;
      numSpot = lastLine - hLines;

      aLine = (String)aligentFile.elementAt(hLines);
      defineKeys(channels);
      colNames = separateLine(aLine);

      aLine = (String)aligentFile.elementAt(lastLine);
      colValues = separateLine(aLine);

      if(colValues.length < 2){
        JOptionPane.showMessageDialog(parent,
          "You might add extra space at the end of file.\nPlease "
          + "remove it and try again.", parent.getTitle(), JOptionPane.ERROR_MESSAGE);
        noError = false;
        counter += numOfFiles;
      }

      if(noError){
        // find the locations of required columns of data
        rowIndex = findRightCol(colNames, RW);
        gColIndex = findRightCol(colNames, COL);

        unidLoc = findRightCol(colNames, FEATURE_NUM);
        ch1AreaLoc = findRightCol(colNames, gChApixel);
        ch2AreaLoc = findRightCol(colNames, gChBpixel);

        ch1IntenLoc = findRightCol(colNames, gMedSignalA);
        ch1Bkg = findRightCol(colNames, gBkgMedSignalA);
        ch2IntenLoc = findRightCol(colNames, gMedSignalB);
        ch2Bkg = findRightCol(colNames, gBkgMedSignalB);

        ch1BkgArea = findRightCol(colNames, gBkgPixelA);
        ch2BkgArea = findRightCol(colNames, gBkgPixelB);

        // annotation addresses
        gPosX = findRightCol(colNames, POS_X);

        annoFileNamePath = IOUtil.dropExtension(mevFileName);
        annoFileNamePath += ".ann";

        try{
          mevFileOut = new FileOutputStream(mevFileName);
          mevWriter = new BufferedWriter(new OutputStreamWriter(mevFileOut));

          sortKeys = new int[NUM_SORT][numSpot];
          outFile = new String[numSpot];

          // generate MEV file header
          aligentFileName = IOUtil.extractFileNameFromPath(inFileNamePath);
          mevFileHeader = generateHeader(colNames, aligentFileName, numSpot, true);

          for(j=0; j<mevFileHeader.length; j++){
            mevWriter.write(mevFileHeader[j]);
            mevWriter.newLine();
            mevWriter.flush();
          }

          if(gAnnType == ExpressConverter.ONE_FILE){
            annoFile = new String[numSpot];
            annoWriter = createAnnoWriter(colNames, annoFileNamePath, aligentFileName, numSpot);
          } else if (i < 1){
            annoFile = new String[numSpot];
            annoWriter = createAnnoWriter(colNames, annoFileNamePath, aligentFileName, numSpot);
          }

          counter += hLines;
          metaRow = 1;
          metaCol = 1;

          for(j = hLines + 1, k=0; j<=lastLine; j++, k++){
            aLine = (String)aligentFile.elementAt(j);
            colValues = separateLine(aLine);

            unid = colValues[unidLoc];

            col = Integer.parseInt(colValues[gColIndex]);
            row = Integer.parseInt(colValues[rowIndex]);
            slideRow = row;
            slideCol = col;

            spAreaA = colValues[ch1AreaLoc];
            spAreaB = colValues[ch2AreaLoc];

            bgA = calculateBackground(colValues, ch1Bkg, ch1BkgArea);
            bgB = calculateBackground(colValues, ch2Bkg, ch2BkgArea);

            mevLine.append(unid).append(TAB);

            if(gBkgCorrect){
              densA = getIntegrateIntensity(colValues, ch1IntenLoc, ch1Bkg,
                                            ch1AreaLoc, true);
              densB = getIntegrateIntensity(colValues, ch2IntenLoc, ch2Bkg,
                                            ch2AreaLoc, true);
              medA = getMedianIntensity(colValues, ch1IntenLoc, ch1Bkg, true);
              medB = getMedianIntensity(colValues, ch2IntenLoc, ch2Bkg, true);
            } else {
              densA = getIntegrateIntensity(colValues, ch1IntenLoc, ch1Bkg,
                                            ch1AreaLoc, false);
              densB = getIntegrateIntensity(colValues, ch2IntenLoc, ch2Bkg,
                                            ch2AreaLoc, false);
              medA = getMedianIntensity(colValues, ch1IntenLoc, ch1Bkg, false);
              medB = getMedianIntensity(colValues, ch2IntenLoc, ch2Bkg, false);
            }

            if(gUseMedian){
              mevLine.append(medA).append(TAB).append(medB);
              aLine = densA + TAB + densB;
            } else {
              mevLine.append(densA).append(TAB).append(densB);
              aLine = medA + TAB + medB;
            }

            mevLine.append(TAB).append(slideRow).append(TAB).append(slideCol);
            mevLine.append(TAB).append(metaRow).append(TAB).append(metaCol);
            mevLine.append(TAB).append(row).append(TAB).append(col).append(TAB);
            mevLine.append(bgA).append(TAB).append(bgB).append(TAB).append(spAreaA);
            mevLine.append(TAB).append(spAreaB).append(TAB).append(aLine);

            outFile[k] = new String(mevLine.toString());
            mevLine.delete(0, mevLine.length());

            if(gAnnType == ExpressConverter.ONE_FILE){
              extraInfo.append(unid).append(TAB).append(slideRow).append(TAB);
              extraInfo.append(slideCol).append(TAB);

              for(annAddr = gColIndex+1; annAddr<(gPosX-1); annAddr++){
                extraInfo.append(colValues[annAddr]).append(TAB);
              }
              extraInfo.append(colValues[annAddr]);
              annoFile[k] = extraInfo.toString();
              extraInfo.delete(0, extraInfo.length());

            } else if (i < 1){
              extraInfo.append(unid).append(TAB).append(slideRow).append(TAB);
              extraInfo.append(slideCol).append(TAB);
              for(annAddr = gColIndex+1; annAddr<(gPosX-1); annAddr++){
                extraInfo.append(colValues[annAddr]).append(TAB);
              }
              extraInfo.append(colValues[annAddr]);
              annoFile[k] = extraInfo.toString();
              extraInfo.delete(0, extraInfo.length());
            }

            sortKeys[0][k] = k;
            sortKeys[1][k] = slideRow;
            sortKeys[2][k] = slideCol;

            counter++;
          }

          if(wantSort){
            sorted = sortUnbalancedRowCol();
            // write to file
            for(j = 0; j<outFile.length; j++){
              mevWriter.write(outFile[sorted[j]]);
              mevWriter.newLine();
              mevWriter.flush();

              if(gAnnType == ExpressConverter.ONE_FILE){
                annoWriter.write(annoFile[sorted[j]]);
                annoWriter.newLine();
                annoWriter.flush();
              } else if (i < 1){
                annoWriter.write(annoFile[sorted[j]]);
                annoWriter.newLine();
                annoWriter.flush();
              }
              counter++;
            }
          } else {
            for(j = 0; j<outFile.length; j++){
              mevWriter.write(outFile[j]);
              mevWriter.newLine();
              mevWriter.flush();

              if(gAnnType == ExpressConverter.ONE_FILE){
                annoWriter.write(annoFile[j]);
                annoWriter.newLine();
                annoWriter.flush();
              } else if (i < 1){
                annoWriter.write(annoFile[j]);
                annoWriter.newLine();
                annoWriter.flush();
              }
              counter++;
            }
          }
          mevFileOut.close();
          if(gAnnType == ExpressConverter.ONE_FILE){
            annoWriter.close();
          } else if (i<1){
            annoWriter.close();
          }
        } catch (IOException ie){
          setErrorMessage( "Error in writing file: " + ie.getMessage() + "\n");
        }
      }
    } // end of the for loop for each file
    ready = true;
    counter = taskEnd;
  }

  /****************************************************************************
   * <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
   * <br> area -- the address of GBNumPix.
   * <p><b>Return: </b> the background information
   ***************************************************************************/
  private String calculateBackground(String[] tuple, int backg, int area){
    float fPix, bMedian, temp;
    String bg = new String("");

    try{
      fPix = Float.parseFloat(tuple[area]);
      bMedian = Float.parseFloat(tuple[backg]);
      temp = bMedian * fPix;
      bg += (int)temp;
    } catch (NumberFormatException nfex) {
      minorError = true;
      bg = "null";
      msg += "**********\n";
      msg += "There is an unacceptable value to calculate background;\n";
      msg += "and the background was set to null.\n";
    }
    return bg;
  }

  /****************************************************************************
   * <b>Description: </b>
   *   calculates median 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> backg -- address for background medien column
   * <br> bgSub -- indicate if an intensity should subtract backgroud.
   * <p><b>Return: </b> the density
   ***************************************************************************/
  private String getMedianIntensity(String[] tuple, int med, int backg, boolean bgSub){
    float fMedian, bMedian;
    String den = new String("");

    try{
      fMedian = Float.parseFloat(tuple[med]);
      bMedian = Float.parseFloat(tuple[backg]);

      if(bgSub){
        den += (int)(fMedian - bMedian);
      } else {
        den += (int)fMedian;
      }
    } 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>
   *   creates a header for both mev and dat(annotation) file.
   * <p><b>Parameter: </b>
   * <br> cNames -- the header of agilent file.
   * <br> fName -- the mev file name that should be written to the file.
   * <br> numRow -- the number of spots (genes/row).
   * <br> mev -- indicate if the header is for ann or mev.
   * <p><b>Return: </b> the header as an array.
   **************************************************************************/
  private String[] generateHeader(String[] cNames, String fName, int numRow, boolean mev){
    int i;
    String[] tempHeader;
    String bkgVal;

    if(mev){
      tempHeader = new String[8];
    } else {
      tempHeader = new String[7];
    }

    if(gBkgCorrect){
      bkgVal = ON;
    } else {
      bkgVal = OFF;
    }

    tempHeader[0] = new String(PAN + SPACE + VERSION + COLON + " V1.0");
    tempHeader[1] = new String(PAN + SPACE + FORMAT_VERSION + COLON + ExpressConverter.MEV_VER);
    tempHeader[2] = new String(PAN + SPACE + DATE + COLON + SPACE + MyTimer.getCurrentDateAndTime('.'));
    tempHeader[3] = new String(PAN + SPACE + CREATED_BY + COLON + SPACE + barTitle);
    tempHeader[4] = new String(PAN + SPACE + ROW_COUNT + COLON + numRow);
    tempHeader[5] = new String(PAN + " converted from Agilent file: " + fName);

    if(mev){
      tempHeader[6] = new String(PAN + SPACE + BKG_CORRECT + COLON + bkgVal);
      if(gUseMedian){
        tempHeader[7] = UID + TAB + MEDA + TAB + MEDB + TAB + R + TAB + C + TAB +
          MR + TAB + MC + TAB + SR + TAB + SC + TAB + BKGA + TAB + BKGB + TAB +
          SAA + TAB + SAB + TAB + IA + TAB + IB;
      } else {
        tempHeader[7] = UID + TAB + IA + TAB +	IB + TAB + R + TAB + C + TAB +
          MR + TAB + MC + TAB + SR + TAB + SC + TAB + BKGA + TAB + BKGB + TAB +
          SAA + TAB + SAB + TAB + MEDA + TAB + MEDB;
      }
    } else {
      tempHeader[6] = UID + TAB + R + TAB + C + TAB;
      for(i=gColIndex+1; i<(gPosX-1); i++){
        tempHeader[6] += cNames[i] + TAB;
      }
      tempHeader[6] += cNames[i];
    }
   return tempHeader;
  }

  /****************************************************************************
   * <b>Description: </b>
   *   calculates integrate density for a channel
   * <p><b>Parameters: </b>
   * <br> tuple -- all information in one row
   * <br> med -- address for median column for either of the channels.
   * <br> backg -- address for background medien column
   * <br> areaIndx -- the address for spot area column.
   * <br> bgSub -- indicate if an intensity should subtract backgroud.
   * <p><b>Return: </b> the density
   ***************************************************************************/
  private String getIntegrateIntensity(String[] tuple, int med, int backg,
                                       int areaIndx, boolean bgSub){
    float median, bMed, pix, temp;
    String den = new String("");

    try{
      median = Float.parseFloat(tuple[med]);
      bMed = Float.parseFloat(tuple[backg]);
      pix = Float.parseFloat(tuple[areaIndx]);

      if(bgSub){
        temp = (median - bMed) * pix;
      } else {
        temp = median * pix;
      }

      den += (int)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>
   *   retrieve a value from the ScanArray file base on the passed key.
   *<p><b>Parameter: </b>
   *<br>  fileCont --- whole content of file.
   *<br>  key --- to match the wanted value.
   *<p><b>Return: </b>  the value and its line number (address) in the file.
   ***************************************************************************/
  private String[] getValueAndIndex(Vector fileCont, String key){
    StringTokenizer token = null;
    int size = fileCont.size();
    String temp = new String("");
    String wantKey = new String("");
    String value[] = new String[2];

    for(int i=0; i<size; i++){
      temp = (String)fileCont.elementAt(i);
      if(!temp.equals("")){
        if(isChar(temp.charAt(0))){
          token = new StringTokenizer(temp, "\t");
          wantKey = token.nextToken();
          if(wantKey.equalsIgnoreCase(key)){
            value[0] = new String(MyIni.removeEndSpace(wantKey));
            value[1] = "" + i;
            i = size;
          }
        }
      }
    }
    return value;
  }

  /**************************************************************************
   * <b>Description: </b>
   *    instantiates a writer object for ann file writing.
   * <p><b>Parameters: </b>
   * <br> cNames --- the header of agilent file.
   * <br> fName --- ann file name to be written.
   * <br> inName --- the input file name.
   * <br> numSpots --- the number of rows in the input file.
   * <p><b>Return: </b>  the writer
   ****************************************************************************/
  private BufferedWriter createAnnoWriter(String[] cNames, String fName, String inName,
                                          int numSpots){
    BufferedWriter out;
    FileOutputStream fOut;
    String annoFileHeader[];

    try {
      fOut = new FileOutputStream(fName);
      out = new BufferedWriter(new OutputStreamWriter(fOut));
      annoFileHeader = generateHeader(cNames, inName, numSpots, false);

      for(int i=0; i<annoFileHeader.length; i++){
        out.write(annoFileHeader[i]);
        out.newLine();
        out.flush();
      }
    } catch (IOException ie){
      fetalError = true;
      ready = false;
      System.out.println("Error in creating ann file: " + ie.getMessage());
      msg += "**********\n";
      msg += "Error in creating ann file: " + ie.getMessage() + "\n";
      return null;
    }

    return out;
  }

  /****************************************************************************
   * <b>Description: </b>
   *    assignes values to the keys for searching right columns.
   * <p><b>Parameter: </b>
   * <br> chs --- the names of channels, g = chA; r = chB.
   ***************************************************************************/
  private void defineKeys(String[] chs) {
    gMedSignalA = new String(chs[0] + MED_SIGNAL);
    gMedSignalB = new String(chs[1] + MED_SIGNAL);
    gChApixel = new String(chs[0] + NUM_PIX);
    gChBpixel = new String(chs[1] + NUM_PIX);
    gBkgMedSignalA = new String(chs[0] + BG_MED_SIGNAL);
    gBkgMedSignalB = new String(chs[1] + BG_MED_SIGNAL);
    gBkgPixelA = new String(chs[0] + BG_NUM_PIX);
    gBkgPixelB = new String(chs[1] + BG_NUM_PIX);
  }

  /****************************************************************************
   * <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
   * <P><b>Return: </b> the index of the column
   ****************************************************************************/
  private int findRightCol(String str[], String key){
    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)){
        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;
  }
}