/***************************************************************************
 * Author:  Jianwei(Jerry) Li.
 * Name:  CustomerMev (Version 1.0)
 * Date:  Created: 10/11/2004 and modified: 10/11/2004
 * Descp: A Java class that reads an input file and write it as a .mev file base
 *        on what the user defined.
 ***************************************************************************/

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.formula.node.EvaluateException;
import org.tigr.util.formula.MathExpression;
import org.tigr.util.formula.Variant;
import org.tigr.util.MyStringTokenizer;
import org.tigr.util.StringSplitter;
import org.tigr.util.io.IOUtil;
import org.tigr.util.MyTimer;

public class CustomerMev extends MevConverter implements MevAttributes, Variant {

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

  private final String DESC = "Description";

  private int gAnnType;
  private int gNumMevCols; // the number of mev columns
  private int gInHeaderAddr;
  private int[] gSelCols, gSelAnnHd;
  private JFrame parent;
  private MathExpression[] gFormulas;
  private String inFileNamePath;
  private String gMevFileName;
  private String barTitle;
  private String[] gMevHeaders, gConvEquation, gInputHeader;

  /****************************************************************************
   *<b>Constructor: </b>
   *<p><b>Parameters: </b>
   *<br> cfName --- the name of input 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 CustomerMev(String cfName, String mfName, String title) {
    super();
    inFileNames = new Vector(1);
    outFileNames = new Vector(1);
    inFileNames.add(cfName);
    outFileNames.add(mfName);
    barTitle = title;
  }

  /****************************************************************************
   *<b>Constructor: </b>
   *<p><b>Parameters: </b>
   *<br> cfNames --- the names of input 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 CustomerMev(JFrame p, Vector cfNames, Vector mfNames, String title, int annNum) {
    super();
    parent = p;
    inFileNames = cfNames;
    outFileNames = mfNames;
    barTitle = title;
    gAnnType = annNum;
    gInHeaderAddr = -1;
  }

  /***************************************************************************
   * <b>Description: </b>
   *   overrides an abstract method to implement the main function of class.
   **************************************************************************/
  public void run () {
    boolean noError;
    boolean consqId = false;
    BufferedWriter annoWriter = null;
    BufferedWriter mevWriter = null;
    FileReading fileReader;
    FileOutputStream mevFileOut = null;
    int lastLine;  // the index of last line of data
    String aLine = new String("");
    String annoFileNamePath;
    String unid = new String("");
    String inputFileName;
    String colNames[];
    String colValues[];
    String custFile[];
    String annoFile[] = null;
    String mevFileHeader[];
    StringBuffer mevLine = new StringBuffer(200);
    StringBuffer extraInfo = new StringBuffer(200);
    int numOfFiles;
    int slideRow = 0;
    int slideCol = 0;
    int i, j, k, flagInt, numSpot;

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

    counter = 0;
    numOfFiles = inFileNames.size();
    gNumMevCols = getMevValidColumns();
    gFormulas = new MathExpression[gConvEquation.length];

    for(i=0; i<gConvEquation.length; i++){
      gFormulas[i] = new MathExpression(gConvEquation[i]);
      gFormulas[i].IntegerResult(true);
    }

    for(i=0; i<numOfFiles; i++){
      noError = true;
      inFileNamePath = (String)inFileNames.elementAt(i);
      gMevFileName = (String)outFileNames.elementAt(i);

      try {
        fileReader = new FileReading(inFileNamePath, FileReading.OUT_AS_ARRAY);

        if(fileReader.done){
          custFile = fileReader.getFileContentAsArray();
        } 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 input file
      lastLine = custFile.length - 1;
      numSpot = lastLine - gInHeaderAddr;

      aLine = custFile[gInHeaderAddr];
      colNames = separateLine(aLine);

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

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

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

        // generate MEV file header
        inputFileName = IOUtil.extractFileNameFromPath(inFileNamePath);
        mevFileHeader = generateHeader(colNames, inputFileName, 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, inputFileName, numSpot);
        } else if (i < 1){
          annoFile = new String[numSpot];
          annoWriter = createAnnoWriter(colNames, annoFileNamePath, inputFileName, numSpot);
        }

        counter += gInHeaderAddr;
        if(gConvEquation[0].length() <= 0){
          consqId = true;
        }

        for(j=gInHeaderAddr+1, k=0; j<=lastLine; j++, k++){
          aLine = custFile[j];
          colValues = separateLine(aLine);

          if(consqId){
            unid = "" + (k+1);
          } else {
            unid = convertCell(colValues, gFormulas[0]);
          }

          if(wantSort){
            slideRow = Integer.parseInt(convertCell(colValues, gFormulas[gSelCols[3]]));
            slideCol = Integer.parseInt(convertCell(colValues, gFormulas[gSelCols[4]]));
          }

          mevLine.append(unid);
          for(int l=1; l<gSelCols.length; l++){
            mevLine.append(TAB);
            mevLine.append(convertCell(colValues, gFormulas[gSelCols[l]]));
          }
          outFile[k] = new String(mevLine.toString());
          mevLine.delete(0, mevLine.length());

          if(gAnnType == ExpressConverter.ONE_FILE){
            extraInfo = setAnnRow(extraInfo, unid, slideRow, slideCol, colValues);
            annoFile[k] = extraInfo.toString();
            extraInfo.delete(0, extraInfo.length());
          } else if (i < 1){
            extraInfo = setAnnRow(extraInfo, unid, slideRow, slideCol, colValues);
            annoFile[k] = extraInfo.toString();
            extraInfo.delete(0, extraInfo.length());
          }

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

          counter++;
        }  // end of the FOR loop for each genes

        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;
  }

  public void setCustomerEquation(String[] eq) { gConvEquation = eq; }
  public void setInputHeader(String[] h) { gInputHeader = h; }
  public void setInputHeaderOffset(int offset) { gInHeaderAddr = offset; }
  public void setSelectedColumnsForAnn(int[] cols) { gSelAnnHd = cols; }
  public void setMevHeaders(String[] header) { gMevHeaders = header; }

  /***************************************************************************
   * <b>Description: </b>
   *   convert the selected input cell to a mev cell.
   * <p><b>Parameters: </b>
   * <br> aRow -- the data of a row (gene) of input file.
   * <br> equation -- a formula based on which the conversion processed.
   * <p><b>Return: </b> the value of cell for mev.
   **************************************************************************/
  private String convertCell(String[] aRow, MathExpression equation){
    int indx;
    String val = new String("0");

    try{
      val = equation.evaluate(aRow);
    } catch (EvaluateException ee){
      val = "0";
    }

    /*String formula[];

    if(formula.length > 1){

    } else {
      indx = getInputFileHeaderOffset(formula[0]);
      if(indx > 0){
        val = aRow[indx];
      }
    }*/
    return val;
  }

  /****************************************************************************
   * <b>Description: </b>
   *   creates a header for both mev and dat(annotation) file.
   * <p><b>Parameter: </b>
   * <br> cNames -- the header of the input 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, j, k, indx, inAddr, count;
    int[] cols;
    String[] tempHeader, formula;

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

    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 the file: " + fName);

    indx = 6;
    if(mev){
      count = 0;
      for(i=0; i<gConvEquation.length; i++){
        if(gConvEquation[i].length() > 0){
          if(i != 0 && i != 1 && i != 2 && i != gMevHeaders.length-2 && i != gMevHeaders.length-1){
            count++;
          }
          formula = parseEquation(gConvEquation[i]);
          tempHeader[indx] = new String(PAN + SPACE + gMevHeaders[i] + " = ");
          for(j=0; j<formula.length; j++){
            inAddr = getInputFileHeaderOffset(formula[j]);
            if(inAddr < 0){
              tempHeader[indx] += formula[j];
            } else {
              tempHeader[indx] += cNames[inAddr];
            }
          }
          indx++;
        }
      }
      cols = new int[count];
      k = 0;
      for(j=0; j<gConvEquation.length; j++){
        if(j != 0 && j != 1 && j != 2 && j != gMevHeaders.length-2 && j != gMevHeaders.length-1){
          if(gConvEquation[j].length() > 0){
            cols[k++] = j;
          }
        }
      }

      gSelCols = new int[cols.length + 5];
      gSelCols[0] = 0;
      k = 1;
      if(gUseMedian){
        for(j=gMevHeaders.length-2; j<gMevHeaders.length; j++){
          gSelCols[k++] = j;
        }
        for(j=0; j<cols.length; j++){
          gSelCols[k++] = cols[j];
        }
        for(j=1; j<3; j++){
          gSelCols[k++] = j;
        }

      } else {
        for(j=1; j<3; j++){
          gSelCols[k++] = j;
        }
        for(j=0; j<cols.length; j++){
          gSelCols[k++] = cols[j];
        }
        for(j=gMevHeaders.length-2; j<gMevHeaders.length; j++){
          gSelCols[k++] = j;
        }
      }

      tempHeader[indx] = gMevHeaders[0];
      for(j=1; j<gSelCols.length; j++){
        tempHeader[indx] += TAB + gMevHeaders[gSelCols[j]];
      }
    } else { // for ann file header
      if(wantSort){
        tempHeader[indx] = gMevHeaders[0] + TAB + gMevHeaders[3] + TAB + gMevHeaders[4];
      } else {
        tempHeader[indx] = gMevHeaders[0];
      }
      for(i=0; i<gSelAnnHd.length; i++){
        tempHeader[indx] += TAB + gInputHeader[gSelAnnHd[i]];
      }
    }
   return tempHeader;
  }

  /***************************************************************************
   * <b>Description: </b>
   *    converts the number items in a formula to number, which is the index of
   *    input file headers.
   * <p><b>Parameter: </b>
   * <br> item -- the item to be converted.
   * <p><b>Return: </b> the number, otherwise, -1.
   **************************************************************************/
  private int getInputFileHeaderOffset(String item){
    int num;
    try{
      num = Integer.parseInt(item);
    } catch (NumberFormatException nfe){
      return -1;
    }
    return num;
  }

  /**************************************************************************
   * <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>
   *   checks the number of mev columns that users has defined.
   **************************************************************************/
  private int getMevValidColumns(){
    int num = 0;

    for(int i=0; i<gConvEquation.length; i++){
      if(gConvEquation[i].length() > 0){
        num++;
      }
    }
    return num;
  }

  /**************************************************************************
   * <b>Description: </b>
   *   splittes an quation to its operators and operants.
   * <p><b>Parameter: </b>
   * <br> eq -- the equation to be splitted.
   * <p><b>Return: </b> an string array that contains the operators and operants.
   ***************************************************************************/
  private String[] parseEquation(String eq){
    int count = 0;
    String[] temp;
    MyStringTokenizer token = new MyStringTokenizer(eq, OPERATORS, true);

    temp = new String[token.countTokens()];
    while(token.hasMoreTokens()){
      temp[count++] = token.nextToken();
    }
    return temp;
  }

  /***************************************************************************
   * <b>Description: </b>
   *    sets the values of a row for ann file.
   **************************************************************************/
  private StringBuffer setAnnRow(StringBuffer sb, String id, int r, int c, String[] vals){
    sb.append(id);
    if(wantSort){
      sb.append(TAB).append(r).append(TAB).append(c);
    }

    for(int i = 0; i<gSelAnnHd.length; i++){
      sb.append(TAB).append(vals[gSelAnnHd[i]]);
    }
    return sb;
  }
}