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

/*****************************************************************************
 * Description:  A class that reads a set of tav files and write to MEV files.
 * Company:      TIGR
 * @author       Jianwei (Jerry) Li
 * @version 1.0
 * @Date:  Created: 05/12/2003 and modified:  06/07/2004
 * Modified History
 * 06/07/04: Provide the option to make one ann file for a set of slide that
 *           were produced with the same array design.
 *****************************************************************************/

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 TavMev extends Converter implements MevAttributes{

  private String title;
  int gAnnType;

  /****************************************************************************
   *<b>Constructor: </b>
   *<p><b>Parameters: </b>
   *<br> gfNames --- the names of GenePix files to be converted.
   *<br> mfNames --- the names of .mev files that is an output.
   *****************************************************************************/
  public TavMev(Vector inNames, Vector mfNames, String barTitle, int annNum) {
    super();
    inFileNames = inNames;
    outFileNames = mfNames;
    title = barTitle;
    gAnnType = annNum;
  }

  /***************************************************************************
   * <b>Description: </b>
   *   overrides an abstract method to implement the main function of class.
   **************************************************************************/
  public void run () {
    boolean noError;
    String mevFileName;
    String aLine = new String("");
    String extraInfo = new String("");
    String annoFileNamePath;
    String tavFileName, mevLine;
    String colValues[];
    String annoFile[] = null;
    String mevFileHeader[];
    String annoFileHeader[];
    int numOfFiles, fSize;
    int i, j, k;
    int slideRow, slideCol;
    int maxMetaCol, maxCol;
    Vector tavFile;
    FileReading fileReader;
    BufferedWriter mevWriter = null;
    BufferedWriter annoWriter = null;
    FileOutputStream mevFileOut = null;

    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){
          tavFile = fileReader.getFileContentInLines();
        } else {
          setErrorMessage(fileReader.getProcessMessage());
          taskEnd = 1;
          counter = 1;
          return;
        }
      } catch (IOException e){
        setErrorMessage(e.getMessage());
        taskEnd = 1;
        counter = 1;
        return;
      }

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

      if(colValues.length < 2){
        JOptionPane.showMessageDialog(null,
          "You might add extra space at the end of file.\n(" + inFileNamePath +
          "). \nPlease remove it and try again. Converting will continue " +
          "\nfor remaining files", title + " -- Tav-Mev",
          JOptionPane.ERROR_MESSAGE);
        noError = false;
        counter += numOfFiles;
      }

      if(noError){
           // check if the original file has been modified.
        if(!isOriginal(tavFile, colValues)){
          JOptionPane.showMessageDialog(null,
            "You might have dropped some of your spots in the file \n(" +
            inFileNamePath + ".\nThe converter requires an file with all spots." +
            "\nConverting will continue for the remaining files",
            title + " -- Tav-Mev", JOptionPane.ERROR_MESSAGE);
          noError = false;
          counter += numOfFiles;
        }
      }

      if(noError){
        if(!isTavFile(colValues)){
          JOptionPane.showMessageDialog(null,
            "You might have added more columns into the file \n(" +
            inFileNamePath + ".\nThe converter requires an file with correct columns." +
            "\nConverting will continue for the remaining files",
            title + " -- Tav-Mev", JOptionPane.ERROR_MESSAGE);
          noError = false;
          counter += numOfFiles;
        }
      }

      if(noError){
        try{
          annoFileNamePath = IOUtil.dropExtension(mevFileName);
          annoFileNamePath += ".ann";

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

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

          tavFileName = IOUtil.extractFileNameFromPath(inFileNamePath);

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

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

          int unid = 1;
          maxMetaCol = Integer.parseInt(colValues[3]);
          maxCol = Integer.parseInt(colValues[5]);

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

            slideRow = Integer.parseInt(colValues[0]);
            slideCol = Integer.parseInt(colValues[1]);

            mevLine = setMevLine(unid, colValues);
            outFile[k] = new String(mevLine);

            if(gAnnType == ExpressConverter.ONE_FILE){
              extraInfo = setAnnoLine(unid, colValues);
              annoFile[k] = new String(extraInfo);
            } else if (i < 1){
              extraInfo = setAnnoLine(unid, colValues);
              annoFile[k] = new String(extraInfo);
            }

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

            counter++;
            unid++;
          } // 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++){
              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){
          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>
   *    instantiates a writer object for ann file writing.
   * <p><b>Parameters: </b>
   * <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 fName, String inName, int numSpots,
                                          String[] cValues){
    BufferedWriter out;
    FileOutputStream fOut;
    String annoFileHeader[];

    try {
      fOut = new FileOutputStream(fName);
      out = new BufferedWriter(new OutputStreamWriter(fOut));

      annoFileHeader = generateHeader(inName, numSpots, cValues.length, 1);

      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>
   *   creates a header for both mev and dat(annotation) file.
   * <p><b>Parameter: </b>
   * <br> fName -- the mev file name that should be written to the file.
   * <br> numRow -- the number of spots (genes/row).
   * <br> numCol -- the number of columns that can determine the version of tav file.
   * <br> type -- the type of header (mev or dat).
   * <p><b>Return: </b> the header as an array.
   **************************************************************************/
  private String[] generateHeader(String fName, int numRow, int numCol, int type){
    String[] tempHeader = new String[6];

    for(int i=0; i<tempHeader.length; i++){
      tempHeader[i] = new String("");
    }

    tempHeader[0] = new String(PAN + SPACE + VERSION + COLON + " V1.0");
    tempHeader[1] = new String(PAN + SPACE + DATE + COLON + SPACE + MyTimer.getCurrentDate('.'));
    tempHeader[2] = new String(PAN + SPACE + CREATED_BY + COLON + SPACE + title);
    tempHeader[3] = new String(PAN + SPACE + ROW_COUNT + COLON + numRow);
    tempHeader[4] = PAN + " Converted from tav file: " + fName;

    if(type == 0){
      switch (numCol){
        case 8:
          tempHeader[5] = UID + TAB + IA + TAB + IB + TAB + R + TAB + C + TAB + MR +
            TAB + MC + TAB + SR + TAB + SC;
          break;

        case 14: case 17:
          tempHeader[5] = UID + TAB + IA + TAB + IB + TAB + R + TAB + C + TAB +
            MR + TAB + MC + TAB + SR + TAB + SC + TAB + BKGA + TAB + BKGB + TAB +
            FLAGA + TAB + FLAGB + TAB + SAA + TAB + SAB;
        break;

        case 24:
          tempHeader[5] = UID + TAB + IA + TAB + IB + TAB + R + TAB + C + TAB +
            MR + TAB + MC + TAB + SR + TAB + SC + TAB + BKGA + TAB + BKGB + TAB +
            SA + TAB + FLAGA + TAB + FLAGB;
          break;

        default: msg = "**********\nConverter needs to know the definitions of each column.\n" +
          "Please contact the author to solve this problem.";
          JOptionPane.showMessageDialog(null, msg, title + " -- Tav-Mev",
            JOptionPane.ERROR_MESSAGE);
          fetalError = true;
      }
    } else {
      switch (numCol){
        case 8: case 14: case 17:
          tempHeader[5] = UID + TAB + R + TAB + C;
          break;

        case 24:
          tempHeader[5] = UID + TAB + R + TAB + C + TAB + PLATE_NUM + TAB +
            WELL_NUM + TAB + CLONE_NAME + TAB + AMP + TAB + GB_NUM + TAB + TC_NUM +
            TAB + ROLE_GUESS + TAB + CLUSTER + TAB + GENE_NAME + TAB + COM_NAME;
      }
    }
    return tempHeader;
  }

  /***************************************************************************
   * <b>Description: </b>
   *   checks if the tav file has been modified by droping some spots.
   * <p><b>Parameter: </b>
   * <br> inFile -- the file to be checked.
   * <br> lastLine -- the last spot of the array.
   * <p><b>Return: </b> true if it is not modified; otherwise, false.
   ***************************************************************************/
  private boolean isOriginal(Vector inFile, String[] lastLine){
    boolean noChange = true;
    int numSpot = inFile.size();
    int mr=0, mc=0, sr=0, sc=0;

    try{
      mr = Integer.parseInt(lastLine[2]);
      mc = Integer.parseInt(lastLine[3]);
      sr = Integer.parseInt(lastLine[4]);
      sc = Integer.parseInt(lastLine[5]);
    } catch (NumberFormatException nfex){
      noChange = false;
      return noChange;
    }

    if((mr * mc * sr * sc) != numSpot){
      noChange = false;
    }
    return noChange;
  }

  /****************************************************************************
   * <b>Description: </b>
   *   checks if the input file is a tav file.
   * <p><b>Parameters: </b>
   * <br> oneLine -- one spot from the file.
   * <p><b>Return: </b> ture if it is; otherwise, false.
   **************************************************************************/
  private boolean isTavFile(String[] oneLine){
    boolean itIs;
    switch(oneLine.length){
      case 8: case 9: case 10: case 14: case 16: case 17: case 24:
        itIs = true;
        break;

      default: itIs = false;
    }
    return itIs;
  }

  /****************************************************************************
   * <b>Description: </b>
   *   sets one row of the anno file.
   * <p><b>Parameters: </b>
   * <br> val -- the tav values of a spot.
   * <p><b>Return: </b>  the row.
   ***************************************************************************/
  private String setAnnoLine(int uid, String[] val){
    String temp = new String("");

    switch(val.length){
      case 14: case 17:
        temp = uid + TAB + val[0] + TAB + val[1];
        break;

      case 24:
        temp = val[23] + TAB + val[0] + TAB + val[1];
        for(int i=13; i<val.length -1; i++){
          temp += TAB + val[i];
        }
      break;
    }
    return temp;
  }

  /****************************************************************************
   * <b>Description: </b>
   *   sets one row of the mev file.
   * <p><b>Parameters: </b>
   * <br> id -- the unique id.
   * <br> val -- the tav values of a spot.
   * <p><b>Return: </b>  the row.
   ***************************************************************************/
  private String setMevLine(int uid, String[] val){
    String temp = new String("");
    int i;

    if(val.length == 24){
      temp = val[23] + TAB + val[6] + TAB + val[7] + TAB;
    } else {
      temp = uid + TAB + val[6] + TAB + val[7] + TAB;
    }

    for(i=0; i<6; i++){
      temp += val[i] + TAB;
    }
    switch(val.length){

      case 14:
        temp += val[10] + TAB + val[11] + TAB + val[12] + TAB + val[13] + TAB +
                val[8] + TAB + val[9];
        break;

      case 17:
        temp += val[13] + TAB + val[14] + TAB + val[15] + TAB + val[16] + TAB +
                val[8] + TAB + val[9];
        break;

      case 24:
        temp += val[10] + TAB + val[11] + TAB + val[12] + TAB + val[8] + TAB + val[9];
        break;
    }

    return temp;
  }
}