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

/*****************************************************************************
 * Description:  a base class for convert one file format to the other.
 * Company:      TIGR
 * @author       Jianwei (Jerry) Li
 * @version 1.0
 * @Date:  Created: 05/12/2003 and modified:  05/12/2003
 *****************************************************************************/

package org.tigr.microarray.converter;

import java.io.IOException;
import java.util.Vector;
import org.tigr.util.StringSplitter;
import org.tigr.util.io.MyIni;
import org.tigr.util.FileReading;

public class Converter extends Thread {

  public static boolean ready;
  public static boolean fetalError;
  public static boolean minorError;

  protected final int NUM_SORT = 3;  // array size for sorting key
  protected final int ROW = 1;
  protected final int COL = 2;

  protected Vector inFileNames, outFileNames;
  protected String msg, inFileNamePath;
  protected String[] outFile;
  protected boolean wantSort;
  protected int taskEnd;
  protected int counter;
  protected int[][] sortKeys;
  protected int[] sorted;
  protected int[][] oneGroup;

  public Converter() {
    msg = new String("");
    inFileNamePath = new String("");
    wantSort = true;
    ready = false;
    fetalError = false;
    minorError = false;
  }

  public int getCurrent() { return counter; }
  public String getErrorMsg() { return msg; }
  public String getFileName() { return inFileNamePath; }
  public int getTaskEnd() { return taskEnd; }
  public void setSortSpots(boolean b){ wantSort = b; }

  /***************************************************************************
   *<b>Description: </b>
   *   set the index in order base on the sorted slide_row and slide_col
   *<p><b>Parameters: </b>
   *<br>  start --- the beginning of the index to be ordered.
   *<br>  end --- the end of the index to be ordered.
   *<br>  keys --- the indecies to be ordered
   *<p><b>Return: </b>  the ordered indecies.
   **************************************************************************/
  protected int[] arrangeKeys(int start, int end, int[] keys){
    int temp[];
    int i, size, pIndex;

    temp = keys;

    size = end - start + 1;
    pIndex = start;

    for(i=0; i<size; i++){
      temp[pIndex] = oneGroup[0][i];
      pIndex++;
    }
    return temp;
  }

  /***************************************************************************
   * <b>Description: </b>
   *    calculates the end of entire task for a batch of files.
   * <p>Return: </b> the end of the task.
   ***************************************************************************/
  protected int determineTaskEnd(){
    int tempEnd, numFiles, i;
    FileReading fileReader;
    Vector fileContent = new Vector();

    numFiles = inFileNames.size();
    tempEnd = 0;
    for(i=0; i<numFiles; i++){
      try {
        fileReader = new FileReading((String)inFileNames.elementAt(i));
        if(fileReader.done){
          fileContent = fileReader.getFileContentInLines();
        } else {
          setErrorMessage(fileReader.getProcessMessage());
          tempEnd = 1;
          i = numFiles;
        }
      } catch (IOException e){
        setErrorMessage(e.getMessage());
        tempEnd = 1;
        i = numFiles;
      }
      tempEnd += fileContent.size();
    }
    return tempEnd;
  }

  /*****************************************************************************
   *<b>Description: </b>
   *  separates a group of number to be sorted into two group based on a number.
   *<p><b>Parameters: <b>
   *<br> left --- the minimum boundary.
   *<br> right --- the maximum boundary.
   *<br> pivot --- the number as the middle point for partition.
   *<br> sel --- the selection for slide_row or slide_col.
   *<p><b>Return: </b> the minimum after the patition.
   *****************************************************************************/
  protected int partitionIt(int left, int right, int pivot, int sel){
    int leftNum, rightNum;

    leftNum = left - 1;
    rightNum = right;

    while(true){
      if(sel == ROW) {
        while(sortKeys[1][++leftNum] < pivot);
        while(rightNum > 0 && sortKeys[1][--rightNum] > pivot);
      } else {
        while(oneGroup[2][++leftNum] < pivot);
        while(rightNum > 0 && oneGroup[2][--rightNum] > pivot);
      }

      if(leftNum >= rightNum){
        break;
      } else {
        swap(leftNum, rightNum, sel);
      }
    }

    swap(leftNum, right, sel);
    return leftNum;
  }

  /*****************************************************************************
   *<b>Description: </b>
   *  sorts a group of number with quick sort algorithm.
   *<p><b>Parameters: <b>
   *<br> left --- the minimum boundary.
   *<br> right --- the maximum boundary.
   *<br> sel --- the selection for slide_row or slide_col.
   *****************************************************************************/
  protected void quickSort(int left, int right, int sel){
    int pivot, partition;

    if(right - left <= 0){
      return;
    } else {
      if(sel == ROW){
        pivot = sortKeys[1][right];
      } else {
        pivot = oneGroup[2][right];
      }
      partition = partitionIt(left, right, pivot, sel);
      quickSort(left, partition - 1, sel);
      quickSort(partition+1, right, sel);
    }
  }

  /****************************************************************************
   *<b>Description: </b>
   *   splits a string and set the elemet to an array.
   *<p><b>Parameter: </b>
   *<br> str --- the input to be splited.
   *<br> num --- the number of columns.
   *<p><b>Return: </b> the name.
   ****************************************************************************/
  protected String[] separateLine(String str){
    StringSplitter spliter;
    String name[];
    String tempStr = new String("");
    spliter = new StringSplitter(str, "\t");
    int num = spliter.countTokens();
    int length = 0;
    name = new String[num];
    if(num > 0){
        while(spliter.hasMoreTokens()){
        tempStr = spliter.nextToken();
        tempStr = MyIni.removeAllEndSpaces(tempStr);
        tempStr = MyIni.removeAllHeadSpaces(tempStr);
        name[length++] = tempStr;
      }
    }
    return name;
  }

  protected void setErrorMessage(String eMsg){
    fetalError = true;
    System.out.println(eMsg);
    ExpressConverter.logFileContent.add("\n***********\n" + eMsg);
    msg += "*********\n";
    msg += eMsg + "\n";
  }

  /*****************************************************************************
   *<b>DESCRIPTION: </b>
   *   sort slide_row and then slide_col
   *<p><b>Parameters: </b>
   *<br>  bNum --- the number of block
   *<br>  bSize --- the number of columns per block
   *<p><b>RETRUNED: </b>  the sorted address for the outFile.
   ***************************************************************************/
  protected int[] sortRowCol(int bNum, int bSize) {
    int temp, ready[], max, min, i, j, numGroup, gSize, head, tail=0;

    max = outFile.length-1;
    min = sortKeys[1][0];
    quickSort(min, max, ROW);

    numGroup = outFile.length/(bNum*bSize);
    gSize = bNum*bSize;
    oneGroup = new int[3][gSize];

    max = gSize;
    ready = new int[outFile.length];
    for(i=0; i<numGroup; i++){
      head = i * gSize;
      for(j=0; j<gSize; j++){
        oneGroup[0][j] = sortKeys[0][i*gSize + j];
        oneGroup[1][j] = sortKeys[1][i*gSize + j];
        oneGroup[2][j] = sortKeys[2][i*gSize + j];
        tail = i * gSize + j;
      }
      min = 0;
      max = gSize - 1;
      quickSort(min, max, COL);
      ready = arrangeKeys(head, tail, ready);
    }

    return ready;
  }

  /*****************************************************************************
   *<b>DESCRIPTION: </b>
   *   sorts slide_row and then slide_col.  Some of slide_row and slide_col could
   *   miss in one block.
   * <p><b>Parameters: </b>
   * <p><b>RETRUNED: </b>  the sorted address for the outFile.
   ***************************************************************************/
  protected int[] sortUnbalancedRowCol() {
    int temp, max, min, i, gSize, head, tail=0;
    int[] colSize, ready;

    max = outFile.length-1;
    min = sortKeys[1][0];
    quickSort(min, max, ROW);
    ready = new int[outFile.length];

    colSize = new int[2];
    colSize[0] = 0;
    colSize[1] = min;

    do{
      colSize = getColNumber(colSize[0]);
      gSize = colSize[1];
      oneGroup = new int[3][gSize];
      head = colSize[0] - colSize[1];

      for(i=0; i<gSize; i++){
        oneGroup[0][i] = sortKeys[0][head + i];
        oneGroup[1][i] = sortKeys[1][head + i];
        oneGroup[2][i] = sortKeys[2][head + i];
      }

      tail = head + i - 1;
      min = 0;
      max = gSize - 1;
      if(head >= 0){
        quickSort(min, max, COL);
        ready = arrangeKeys(head, tail, ready);
      }
    } while(colSize[0] > 0);

    return ready;
  }

  /*****************************************************************************
   *<b>Description: </b>
   *  exchanges the contents of two elements to be sorted
   *<p><b>Parameters: <b>
   *<br> dexl --- the offset of one element.
   *<br> dex2 --- the offset of another element.
   *<br> sel --- the selection for slide_row or slide_col.
   *****************************************************************************/
  protected void swap(int dex1, int dex2, int sel){
    int[] temp = new int[3];

    for(int i=0; i<temp.length; i++){
      if(sel == ROW){
        temp[i] = sortKeys[i][dex1];
        sortKeys[i][dex1] = sortKeys[i][dex2];
        sortKeys[i][dex2] = temp[i];
      } else {
        temp[i] = oneGroup[i][dex1];
        oneGroup[i][dex1] = oneGroup[i][dex2];
        oneGroup[i][dex2] = temp[i];
      }
    }
  }

  /*****************************************************************************
   * <b>Description: </b>
   *   counts the number of columns for each row
   * <p><b>Parameters: <b>
   * <br> offset --- the offset of starting new colums.
   * <p><b>Return: </b> the number of columns and the start point of next column.
   *****************************************************************************/

  private int[] getColNumber(int offset){
    boolean go = true;
    int[] temp = new int[2];
    int ctr = 0;
    int addr = offset;
    int val;

    if(addr >= sortKeys[1].length){
      temp[0] = -1;
      return temp;
    } else {
      val = sortKeys[1][addr];
    }

    while(go){
      if(addr >= sortKeys[1].length){
        go = false;
        addr++;
      } else if(val == sortKeys[1][addr++]){
        ctr++;
      } else {
        go = false;
      }
    }

    temp[0] = addr - 1;
    temp[1] = ctr;

    return temp;
  }
}