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

/*****************************************************************************
 * Description:  A class that reads a set of ArrayVision files and write to
 *               MEV files.
 * Company:      TIGR
 * @author       Jianwei (Jerry) Li
 * @version 1.0
 * @Date:  Created: 06/07/2004 and modified:  08/12/2004
 * Modified History
 *****************************************************************************/

package org.tigr.microarray.converter;

import java.io.IOException;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.util.Vector;
import javax.swing.JOptionPane;
import org.tigr.microarray.MevAttributes;
import org.tigr.util.FileReading;
import org.tigr.util.MyTimer;
import org.tigr.util.io.IOUtil;

public class ArrayVersionMev extends MevConverter implements MevAttributes{

  final String AREA = "Area - mm2";
  final String BKGD = "Bkgd";
  final String DATA_1 = "Data 1";
  final String DATA_2 = "Data 2";
  final String FLAG = "Flag";
  final String SPOT_LABEL = "Spot labels";
  final String VOL = "VOL - Levels x mm2";
  final String AR_VOL = "AR VOL - Levels x mm2";

  final int M_VOL = 0;
  final int M_AR_VOL = 1;
  final int M_DENS = 2;
  final int M_MTM_DENS = 3;
  final int M_ARM_DNES = 4;
  final int M_MED_DENS = 5;

  int gMeasureType;

  String title;
  String gChannelNames[];

  /****************************************************************************
   * <b>Constructor: </b>
   * <p><b>Parameters: </b>
   * <br> inNames --- the names of ArrayVersion files to be converted.
   * <br> mfNames --- the names of .mev files that is an output.
   * <br> barTitle --- the string showed on the window bar.
   *****************************************************************************/
  public ArrayVersionMev(Vector inNames, Vector mfNames, String barTitle) {
    super();
    inFileNames = inNames;
    outFileNames = mfNames;
    title = barTitle;
  }

  /***************************************************************************
   * <b>Description: </b>
   *   overrides an abstract method to implement the main function of class.
   **************************************************************************/
  public void run () {
    boolean noSpotArea = false;
    String mevFileName;
    String aLine = new String("");
    String bgA = new String("");  // background info for channel A
    String bgB = new String("");  // background info for channel B
    String densA = new String("");
    String densB = new String("");
    String flagA = new String("");
    String flagB = new String("");
    String medA = new String("0");
    String medB = new String("0");
    String avFileName;
    String colNames[], colValues[];
    String mevFileHeader[], annoFileHeader[];
    String avFile[];
    StringBuffer mevLine = new StringBuffer(150);
    int numOfFiles, fSize, hLine, flag;
    int i, j, k;
    int flag1Index, flag2Index, inten1Addr, inten2Addr, sa1Addr, sa2Addr;
    int bg1Addr, bg2Addr, labelIndex;
    int spAreaA = 0;
    int spAreaB = 0;
    FileReading fileReader;
    BufferedWriter mevWriter = null;
    FileOutputStream mevFileOut = null;

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

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

    for(i=0; i<numOfFiles; i++){
      inFileNamePath = (String) inFileNames.elementAt(i);
      mevFileName = (String) outFileNames.elementAt(i);
      try {
        fileReader = new FileReading(inFileNamePath, FileReading.OUT_AS_ARRAY);
        if (fileReader.done) {
          avFile = fileReader.getFileContentAsArray();
        } else {
          fetalError = true;
          System.out.println(fileReader.getProcessMessage());
          msg += "**********\n";
          msg += fileReader.getProcessMessage() + "\n";
          taskEnd = 1;
          counter = 1;
          return;
        }
      } catch (IOException e){
        fetalError = true;
        msg += "**********\n";
        msg += e.getMessage() + "\n";
        taskEnd = 1;
        counter = 1;
        return;
      }

      hLine = 2;                            // the first two lines are header
      fSize = avFile.length;
      aLine = avFile[0]; // get the channel names
      gChannelNames = separateLine(aLine);
      aLine = avFile[1]; // get the header names
      colNames = separateLine(aLine);

      flag1Index = findRightCol(colNames, FLAG, DATA_1);
      flag2Index = findRightCol(colNames, FLAG, DATA_2);
      inten1Addr = determineMeasureType(colNames, DATA_1);
      if(inten1Addr < 0){
        fetalError = true;
        msg += "**********************\n";
        msg += "Converter could not recognize the Principal Measurement from which " +
          "\nthe data file was generated.  Please contact the developer at jli@tigr.org.";
        return;
      }
      inten2Addr = inten1Addr;
      if(gMeasureType == M_VOL){
        inten2Addr = findRightCol(colNames, VOL, DATA_2);
      } else if (gMeasureType == M_AR_VOL){
        inten2Addr = findRightCol(colNames, AR_VOL, DATA_2);
      }

      sa1Addr = findRightCol(colNames, AREA, DATA_1);
      sa2Addr = findRightCol(colNames, AREA, DATA_2);
      if(sa1Addr == 0 || sa2Addr == 0){
        noSpotArea = true;
      }
      bg1Addr = findRightCol(colNames, BKGD, DATA_1);
      bg2Addr = findRightCol(colNames, BKGD, DATA_2);
      labelIndex = findRightCol(colNames, SPOT_LABEL, 0);

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

        avFileName = IOUtil.extractFileNameFromPath(inFileNamePath);

        // generate MEV file header
         mevFileHeader = generateHeader(avFileName, fSize - hLine, noSpotArea);
         for(j=0; j<mevFileHeader.length; j++){
           mevWriter.write(mevFileHeader[j]);
           mevWriter.newLine();
           mevWriter.flush();
         }

         for(j=hLine, k=0; j<fSize; j++, k++){
           aLine = avFile[j];
           colValues = separateLine(aLine);

           flagA = getFlagValue(flagA, Integer.parseInt(colValues[flag1Index]));
           flagB = getFlagValue(flagB, Integer.parseInt(colValues[flag2Index]));
           if(!noSpotArea){
             spAreaA = calculateSpotArea(colValues, sa1Addr);
             spAreaB = calculateSpotArea(colValues, sa2Addr);
           }

           bgA = calculateBackground(colValues, bg1Addr);
           bgB = calculateBackground(colValues, bg2Addr);

           mevLine.append(colValues[labelIndex]).append(TAB);

           if(gBkgCorrect){
             densA = calculateIntegrateDensity(colValues, inten1Addr, bg1Addr, true);
             densB = calculateIntegrateDensity(colValues, inten2Addr, bg2Addr, true);
             if(!noSpotArea){
               medA = calculateMedianIntensity(colValues, inten1Addr, bg1Addr, sa1Addr, true);
               medB = calculateMedianIntensity(colValues, inten2Addr, bg2Addr, sa2Addr, true);
             }
           } else {
             densA = calculateIntegrateDensity(colValues, inten1Addr, bg1Addr, false);
             densB = calculateIntegrateDensity(colValues, inten2Addr, bg2Addr, false);
             if(!noSpotArea){
               medA = calculateMedianIntensity(colValues, inten1Addr, bg1Addr, sa1Addr, false);
               medB = calculateMedianIntensity(colValues, inten2Addr, bg2Addr, sa2Addr, 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;
           }
           if(noSpotArea){
             mevLine.append(TAB).append(bgA).append(TAB).append(bgB).append(TAB);
             mevLine.append(flagA).append(TAB).append(flagB).append(TAB).append(aLine);
           } else {
             mevLine.append(TAB).append(bgA).append(TAB).append(bgB).append(TAB);
             mevLine.append(flagA).append(TAB).append(flagB).append(TAB).append(spAreaA);
             mevLine.append(TAB).append(spAreaB).append(TAB).append(aLine);
           }
           //System.out.println("noSpot: " + noSA + " header: " + tempHeader[7]);


           mevWriter.write(mevLine.toString());
           mevWriter.newLine();
           mevWriter.flush();
           mevLine.delete(0, mevLine.length());

           counter++;
         }  // end of the for loop for a single file.
         mevWriter.close();

      } catch (IOException ie){
        fetalError = true;
        ready = false;
        System.out.println("Error in writing file: " + ie.getMessage());
        msg += "**********\n";
        msg += "Error in writing file: " + ie.getMessage() + "\n";
        return;
      } catch (Exception e){
        fetalError = true;
        ready = false;
        msg += "**********\n";
        msg += "Error: " + e.getMessage() + ". Please report the developer.\n";
        return;
      }
    } // end of for loop for number of files.
    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 colum.
   * <p><b>Return: </b> the background information
   ***************************************************************************/
  private String calculateBackground(String[] tuple, int backg){
    float bkg;
    String bg = new String("");

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

  /****************************************************************************
   * <b>Description: </b>
   *   calculate integrate intensity for a channel
   * <p><b>Parameters: </b>
   * <br> tuple -- all information in one row
   * <br> volIndx -- address for either channel A or B density column
   * <br> bkgIndx -- address for background volum.
   * <br> bgSub -- indicate if an intensity should subtract backgroud.
   * <p><b>Return: </b> the density
   ***************************************************************************/
  private String calculateIntegrateDensity(String[] tuple, int volIndx, int bkgIndx,
                                           boolean bgSub){
    float vol, bg, temp;
    String den = new String("");

    try{
      vol = Float.parseFloat(tuple[volIndx]);
      bg = Float.parseFloat(tuple[bkgIndx]);

      if(bgSub){
        temp = vol - bg;
      } else {
        temp = vol;
      }
      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>
   *   calculate median intensity for a channel
   * <p><b>Parameters: </b>
   * <br> tuple -- all information in one row
   * <br> volIndx -- address for either channel A or B density column
   * <br> bkgIndx -- address for background volum.
   * <br> areaIndx -- address for spot area (mm2).
   * <br> bgSub -- indicate if an intensity should subtract backgroud.
   * <p><b>Return: </b> the density
   ***************************************************************************/
  private String calculateMedianIntensity(String[] tuple, int volIndx, int bkgIndx,
                                           int areaIndx, boolean bgSub){
     float vol, bg, area, temp;
     String den = new String("");

     try{
       vol = Float.parseFloat(tuple[volIndx]);
       bg = Float.parseFloat(tuple[bkgIndx]);
       area = Float.parseFloat(tuple[areaIndx]) * 10000;

       if(bgSub){
         temp = (vol - bg) / area;
       } else {
         temp = vol/area;
       }

       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>
   *   calculates the spot area in terms of pixel number.
   * <p><b>Parameters: </b>
   * <br> tuple -- all information in one row.
   * <br> indx -- address for Area.
   * <p><b>Return: </b> the spot area.
   ***************************************************************************/
  private int calculateSpotArea(String[] tuple, int indx){
    float fPix = Float.parseFloat(tuple[indx]);
    int temp = (int)(fPix * 10000);
    return temp;
  }

  /****************************************************************************
   * <b>Description: </b>
   *    checks what the principal measure the data file used.
   * <p><b>Parameters: </b>
   * <br>  hd -- the header names.
   * <p><b>Return: </b> the address of the density column; otherwise -1;
   ***************************************************************************/
  private int determineMeasureType(String[] hd, String channel){
    int addr = -1;

    addr = findRightCol(hd, VOL, channel);
    if(addr != 0){
      gMeasureType = M_VOL;
    } else {
      addr = findRightCol(hd, AR_VOL, channel);
      if(addr != 0){
        gMeasureType = M_AR_VOL;
      } else {
        addr = -1;
      }
    }
    return addr;
  }

  /****************************************************************************
   * <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> start -- the starting column to be checked.
   * <P><b>Return: </b> the index of the column
   ****************************************************************************/
  private int findRightCol(String str[], String key, int start){
    int addr = 0;

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

  /****************************************************************************
   * <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> chName -- channel name.
   * <P><b>Return: </b> the index of the column
   ****************************************************************************/
  private int findRightCol(String str[], String key, String chName){
    int addr = findRightCol(str, key, 0);
    String temp = gChannelNames[addr];

    if(temp.equalsIgnoreCase(chName)){
      return addr;
    } else {
      addr = findRightCol(str, key, addr + 1);
    }
    return addr;
  }

  /****************************************************************************
   * <b>Description: </b>
   *   creates a header for both mev and dat(annotation) file.
   * <p><b>Parameter: </b>
   * <br> fName -- the ArrayVersion file name that should be converted.
   * <br> numRow -- the number of spots (genes/row).
   * <p><b>Return: </b> the header as an array.
   **************************************************************************/
  private String[] generateHeader(String fName, int numRow, boolean noSA){
    String[] tempHeader = new String[8];
    String bkgVal;

    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.getCurrentDate('.'));
    tempHeader[3] = new String(PAN + SPACE + CREATED_BY + COLON + SPACE + title);
    tempHeader[4] = new String(PAN + SPACE + ROW_COUNT + COLON + numRow);
    tempHeader[5] = new String(PAN + " converted from ArrayVersion file: " + fName);

    tempHeader[6] = new String(PAN + SPACE + BKG_CORRECT + COLON + bkgVal);
    if(noSA){
      if(gUseMedian){
        tempHeader[7] = UID + TAB + MEDA + TAB + MEDB + TAB + BKGA + TAB + BKGB +
          TAB + FLAGA + TAB + FLAGB + TAB + IA + TAB + IB;
      } else {
        tempHeader[7] = UID + TAB + IA + TAB +	IB + TAB + BKGA + TAB + BKGB + TAB +
          FLAGA + TAB + FLAGB + TAB + MEDA + TAB + MEDB;
      }
    } else {
      if(gUseMedian){
        tempHeader[7] = UID + TAB + MEDA + TAB + MEDB + TAB + BKGA + TAB + BKGB +
          TAB + FLAGA + TAB + FLAGB + TAB + SAA + TAB + SAB + TAB + IA + TAB + IB;
      } else {
        tempHeader[7] = UID + TAB + IA + TAB +	IB + TAB + BKGA + TAB + BKGB + TAB +
          FLAGA + TAB + FLAGB + TAB + SAA + TAB + SAB + TAB + MEDA + TAB + MEDB;
      }
    }
    return tempHeader;
  }

  /**************************************************************************
   * <b>Description: </b>
   *    asignes value to flag.
   * <b>Parameters: </b>
   * <br>  f -- the flag the value to be assigned.
   * <br>  val -- the value from the original file.
   * <p><b> Return: </b> the value.
   **************************************************************************/
  private String getFlagValue(String f, int val){
    if(val == 0){
      f = "B";
    } else {
      f = "X";
    }
    return f;
  }
}