/*
 ***************************************************************************

  Biomolecular Interaction Network Database (BIND)

  The Blueprint Initiative
  522 University Avenue, 9th Floor, Suite 900
  Toronto, Ontario, Canada, M5G 1W7

  Hogue Lab - University of Toronto Biochemistry Department
  Samuel Lunenfeld Research Institute, Mount Sinai Hospital

  Publication to cite:
  Bader GD, Betel D, Hogue CW. (2003) BIND: the Biomolecular
  Interaction Network Database. Nucleic Acids Res. 31(1): 248-50
  PMID: 12519993

  Copyright Notice:

  Copyright 2003, 2004 Mount Sinai Hospital (MSH)

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of
  the License, or any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

  See the GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the
         Free Software Foundation, Inc.,
         59 Temple Place, Suite 330, Boston, MA
         02111-1307  USA
  or visit http://www.gnu.org/copyleft/gpl.html

 ***************************************************************************/

package org.blueprint.seqhound;

import java.util.*;

/**
 * Contains miscellaneous functions such as printing arrays,
 * copying arrays, merging 2 arrays, etc...
 *
 * @author hao lieu (hlieu@blueprint.org)
 */
public class SLRIMisc {

  /**
   * Saves an array of intergers as a comma delimited string.
   * Eg. If <code>intList</code> contains the integers 6 7 4,
   * then this function will return: 6,7,4 as a string.
   * If intList is an empty array, returns ""
   * @param intList an array of integers.
   * @return a comma delimited string of integers.
   */
  public static String SaveArrAsString(int[] intList) {
    if (intList.length == 0) {
      return "";
    }
    StringBuffer s = new StringBuffer();
    Integer j;
    for (int i = 0; i < intList.length; i++) {
      try {
        j = new Integer(intList[i]);
        s.append(j.toString().concat(","));
      }
      catch (NullPointerException e) {
        continue;
      }
    }
    if (s.length() == 0) {
      return "";
    }
    return s.substring(0, s.length() - 1);
  }

  /**
   * Saves an array of strings as a comma delimited string.
   * Eg if <code>strList</code> contains "hi" "there",
   * this function will return "hi,there"
   * @param strList an array of strings
   * @return a comma delimited string
   */
  public static String SaveArrAsString(String[] strList) {
    if (strList.length == 0) {
      return "";
    }
    StringBuffer s = new StringBuffer();
    for (int i = 0; i < strList.length; i++) {
      try {
        s.append(strList[i].concat(","));
      }
      catch (NullPointerException e) {
        continue;
      }
    }
    if (s.length() == 0) {
      return "";
    }
    return s.substring(0, s.length() - 1);
  }

  /**
   * Splits a string according to the <code>regex</code> string.
   * @param s the string to be split
   * @param regex the delimiter to split <code>s</code> by
   * @return an array of integers
   */
  public static int[] StrInt2IntArr(String s, String regex) {
    Integer i;
    String[] strArr = s.split(regex);
    int[] intArr = new int[strArr.length];
    for (int j = 0; j < strArr.length; j++) {
      i = new Integer(strArr[j]);
      intArr[j] = i.intValue();
    }
    return intArr;
  }

  /**
   * int array to Integer array
   * @param t int[]
   * @return Integer[]
   */
  public static Integer[] IntArr2IntegerArr(int[] t) {
    Integer[] integerArr = new Integer[t.length];
    for (int j = 0; j < t.length; j++) {
      integerArr[j] = new Integer(t[j]);
    }
    return integerArr;
  }

  /**
   * Integer array to int array
   * @param t Integer[]
   * @return int[]
   */
  public static int[] IntegerArr2intArr(Integer[] t) {
    int[] intArr = new int[t.length];
    for (int j = 0; j < t.length; j++) {
      intArr[j] = t[j].intValue();
    }
    return intArr;
  }

  /**
   * Splits a string according to <code>regex</code>.
   * @param s the string to be split
   * @param regex the delimiter to split <code>s</code> by
   * @return an array of strings
   */
  public static String[] StrStr2StrArr(String s, String regex) {
    String[] tmp = s.split(regex);
    if ( (s.indexOf("http:") >= 0) && (regex.equals("//"))) {
      for (int i = 0; i < tmp.length; i++) {
        if (tmp[i] != "") {
          String me = tmp[i].substring(tmp[i].length() - 5, tmp[i].length());
          if (me.equalsIgnoreCase("http:") && ( (i + 1) < tmp.length)) {
            tmp[i] = tmp[i] + regex + tmp[i + 1];
            tmp[i + 1] = "";
          }
        }
      }
    }
    return tmp;
  }

  /**
   * Copies an array of integers into a vector.
   * @param numArr the array to be copied.
   * @return a vector of integers that contains the exact same keys
   * in the same order as <code>numArr</code>
   */
  public static Vector CopyArray(int[] numArr) {
    Vector v = new Vector();
    for (int i = 0; i < numArr.length; i++) {
      v.add(new Integer(numArr[i]));
    }
    return v;
  }

  /**
   * Copies an array of integers into a vector.
   * @param numArr the array to be copied.
   * @return a vector of integers that contains the exact same keys
   * in the same order as <code>numArr</code>
   */
  public static Vector CopyArray(Integer[] numArr) {
    Vector v = new Vector();
    for (int i = 0; i < numArr.length; i++) {
      v.add(numArr[i]);
    }
    return v;
  }

  /**
   * Copies an array of strings into a vector.
   * @param strArr the array to be copied
   * @return a vector of strings that contains teh exact same keys
   * in the same order as <code>strArr</code>
   */
  public static Vector CopyArray(String[] strArr) {
    Vector v = new Vector();
    for (int i = 0; i < strArr.length; i++) {
      v.add(strArr[i]);
    }
    return v;
  }

  /**
   * Moves the integers in <code>v</code> into a new array and returns the array.
   * The vector input must contain only integers. The vector shrinks
   * for each element moved into the returned array.
   * @param v a vector containing integers that will be moved into the array
   * @return an array of integers
   */
  public static int[] MaxSizeIntList(Vector v) {
    int lim = Math.min(v.size(), MAXQ);
    int[] iArr = new int[lim];
    for (int i = 0; !v.isEmpty(); i++) {
      iArr[i] = ( (Integer) v.remove(0)).intValue();
      if (i + 1 == MAXQ) {
        break;
      }
    }
    return iArr;
  }

  /**
   * Moves the string elements in <code>v</code> into a new array and returns the array.
   * The vector input must contain only strings. The vector shrinks
   * for each element moved into the returned array.
   * @param v a vector containing only strings that will be moved into the array.
   * @return an array of strings.
   */
  public static String[] MaxSizeStrList(Vector v) {
    int lim = Math.min(v.size(), MAXQ);
    String[] iArr = new String[lim];
    for (int i = 0; !v.isEmpty(); i++) {
      iArr[i] = (String) v.remove(0);
      if (i + 1 == MAXQ) {
        break;
      }
    }
    return iArr;
  }

  /**
   * Merges to arrays of integers into one new array.
   * @param i1 an array of integers
   * @param i2 an array of integers
   * @return an new array of integers containing the elements in i1 then i2.
   */
  public static int[] MergeLists(int[] i1, int[] i2) {
    if (i1.length == 0) {
      return i2;
    }
    if (i2.length == 0) {
      return i1;
    }
    int[] iRet = new int[i1.length + i2.length];
    for (int i = 0; i < i1.length; i++) {
      iRet[i] = i1[i];
    }
    for (int i = 0; i < i2.length; i++) {
      iRet[i + i1.length] = i2[i];
    }
    return iRet;
  }

  /**
   * Merges two arrays of strings into a new array.
   * @param i1 an array of strings.
   * @param i2 an array of strings.
   * @return a new array of strings containing the elements of i1 then i2.
   */

  public static String[] MergeLists(String[] i1, String[] i2) {
    if (i1.length == 0) {
      return i2;
    }

    if (i2.length == 0) {
      return i1;
    }

    String[] iRet = new String[i1.length + i2.length];
    for (int i = 0; i < i1.length; i++) {
      iRet[i] = i1[i];
    }

    for (int i = 0; i < i2.length; i++) {
      iRet[i + i1.length] = i2[i];
    }
    return iRet;
  }

  /**
   * Prints an array of strings separated by <code>separator</code>
   * to System.out
   * @param strList an array of strings.
   * @param separator separates each string in <code>strList</code>
   */
  public static void PrintList(String[] strList, String separator) {

    /* TODO provide a handle to an OutputStream or Writer which is
       where output is directed
     */

    if (strList == null) {
      return;
    }
    if (strList.length == 0) {
      return;
    }
    for (int i = 0; i < strList.length; i++) {
      System.out.print(strList[i]);
      System.out.print(separator);
    }
    System.out.println();
  }

  /**
   * Prints an array of integers into System.out.
   * @param iList an array of integers.
   * @param separator separates each integer in iList
   */
  public static void PrintList(int[] iList, String separator) {

    /* TODO Provide a handle to an OutStream or Writer which
       is where the output is directed
     */

    if (iList == null) {
      return;
    }
    if (iList.length == 0) {
      return;
    }
    for (int i = 0; i < iList.length; i++) {
      System.out.print(iList[i]);
      System.out.print(separator);
    }
    System.out.println();
  }

  /**
   * Converts an string array to hashtable
   * a helper function for API list function handling
   * each entry in the sting array is separated by sep
   * split into two fields and then stored as key and element in the hash
   * @param strArr an array to be converted to hash
   * @param h is the hashtable
   * @param sep is the delimiter to split <code>s</code> by
   * @return a hashtable contains the information in strArr
   */
  public static Hashtable StrArr2Hash(String[] strArr, Hashtable h, String sep) {
    String[] pairs = new String[2];

    for (int j = 0; j < strArr.length; j++) {
      pairs = strArr[j].split(sep);
      h.put(pairs[0], pairs[1]);
    }

    return h;
  }

  /**
   * print out the contents of a hashtable
   * @param h is the hashtable
   */
  public static void PrintHashTable(Hashtable h) {

    Enumeration e = h.keys();
    Enumeration e1 = h.elements();

    while (e.hasMoreElements()) {
      System.out.println(e.nextElement());
      System.out.println("=>");
      System.out.println(e1.nextElement());
    }

  }

  /**
   * retrieve gi value from query result string
   * @param res String[] is the result of query
   * @param format int to decide which kind of result returned(ie. 0-defline; 1-FASTA...)
   * @return String[] is the GI value of String format
   */

  public static String[] getGiFromStrArray(String[] res, int format) {
    String[] s = new String[res.length];
    for (int i = 0; i < res.length; i++) {
      switch (format) {
        case 0:
          s[i] = res[i].substring(0, res[i].indexOf("|"));
          break;
        case 1:
          int pos = res[i].indexOf("|");
          int end = res[i].indexOf("|", pos + 1);
          s[i] = res[i].substring(pos, end);
          break;
        default:
          break;
      }
    }

    return s;
  }

  /**
   * wrap String lines by adding "\n" for formatting inputed string
   * @param s1 String is the input string to be wrapped
   * @param size int is the threshold value for setting up characters number per line
   * @return String is the result string has been wrapped
   */
  public static String wrapLines(String s1, int size) {
    int tmp = java.lang.Math.round(s1.length() / size);
    String cs = "";
    int end;
    for (int i = 0; i <= tmp; i++) {
      if ( (i + 1) * size > s1.length()) {
        end = s1.length();
      }
      else {
        end = (i + 1) * size;
      }
      cs += s1.substring(i * size, end) + "\n";
    }
    return cs.toString();
  }

  /**
   * according to input string param(line char) and linelimit
   * to format the input str(data)
   * @param data String
   * @param linelimit int
   * @param s1 String
   * @return String
   */
  public static String wrapCheck(String data, int linelimit, String s1) {
    String[] tmp = data.split(s1);
    String newdata = "";
    if (tmp != null) {
      for (int i = 0; i < tmp.length; i++) {
        if (tmp[i].length() > SLRIMisc.LINESIZE) {
          tmp[i] = SLRIMisc.wrapLines(tmp[i], linelimit);
        }
        newdata += tmp[i] + "\n";
      }
    }
    return newdata;
  }

  private static final int MAXQ = 700;
  //SeanC added for defining static @param of Wrapping Function
  //used for wrapping XML Format DATA
  public static final int LINESIZE = 95;
}