// tri_input.java  input each triangle into four similar triangles

import java.io.*;
 
class tri_input
{
  int nuniqueb, nuniquef, nuniquev;
  double xmin, xmax, ymin, ymax;
  int debug = 3;
  int ntri, nbound, ncoord, nvert, nfree;
  // tri_input  input triangles, root.tri  root.bound  root.coord
  //         all arrays must be big enough for return
  //         rtn[0] is ntri, rtn[1] is nbound, rtn[2] is ncoord
  //         rtn[3] is nvert, rtn[4] is nfree, rtn[5] is nuniqueb
  //         error if rtn[0]==0
  //         rtnx[0] is xmin, rtnx[1] is xmax, rtnx[2] is ymin, rtnx[3] is ymax
  //         ntri triangles, t1,t2,t3 are index into xc,yc
  //         nbound boundary edges, b1,b2 index into xc,yc
  //         ncoord vertices or nodes, index order, start at zero
  tri_input(String root, int t1[], int t2[], int t3[], // ntri of these
            int b1[], int b2[], // nbound of these
            double xc[], double yc[],  // ncoord
            int uniqueb[], int rtn[], double rtnx[])
  {
	String fname;
    int minvert=999999;
    int index, last, len;

    // read in triangles, set ntri 
    fname = root+".tri";
    if(debug>2) System.out.println("about to read triangles from "+fname);
    ntri=0;
    nvert=0;
    try
    {
      BufferedReader in = new BufferedReader(new FileReader(fname));
      String input_line;
      input_line = in.readLine();
      while(input_line != null)
      {
	    System.out.println(input_line);
        // have a line, extract 3 integers
        len = input_line.length();
        if(len<5)  // not enough data, ignore blank lines
	    {
	      input_line = in.readLine();
          continue;
        }
        index = 0;
        while(input_line.substring(index,index+1).equals(" ")){index++;}
        last = input_line.indexOf(' ',index+1);
        System.out.println("index="+index+", last="+last);
        t1[ntri] = Integer.parseInt(input_line.substring(index,last)); 
        index = last+1;
        while(input_line.substring(index,index+1).equals(" ")){index++;}
        last = input_line.indexOf(' ',index+1);
        System.out.println("index="+index+", last="+last);
        t2[ntri] = Integer.parseInt(input_line.substring(index,last)); 
        index = last+1;
        while(input_line.substring(index,index+1).equals(" ")){index++;}
        last = input_line.indexOf(' ',index+1);
        if(last<1) last = len;
        System.out.println("index="+index+", last="+last);
        t3[ntri] = Integer.parseInt(input_line.substring(index,last)); 
		
        if(debug>0) System.out.println("tri "+ntri+" has vertices "+t1[ntri]+
                                       "  "+t2[ntri]+"  "+t3[ntri]);
        if(t1[ntri]>nvert) nvert=t1[ntri];
        if(t2[ntri]>nvert) nvert=t2[ntri];
        if(t3[ntri]>nvert) nvert=t3[ntri];
        if(t1[ntri]<minvert) minvert=t1[ntri];
        if(t2[ntri]<minvert) minvert=t2[ntri];
        if(t3[ntri]<minvert) minvert=t3[ntri];
        ntri++;
	    input_line = in.readLine();
      } // end while input_line
    }
    catch(IOException exception)
    {
      System.out.println("can not open for reading "+fname);
      System.out.println(exception);
	  rtn[0] = 0;
      return;
    }
    if(debug>0) System.out.println(ntri+" triangles read from "+fname);

    System.out.println("subtracting minvert="+minvert+
                       " from all vertices, using base zero");
    nvert=nvert+1-minvert; // still must be dense sequence of numbers 
    int uniquev[] = new int[3*ntri];
    nuniquev=0;
    for(int i=0; i<ntri; i++)
    {
      t1[i]=t1[i]-minvert;
      t2[i]=t2[i]-minvert;
      t3[i]=t3[i]-minvert;
      uniquev[nuniquev]=t1[i];
      uniquev[nuniquev+1]=t2[i];
      uniquev[nuniquev+2]=t3[i];
      nuniquev=nuniquev+3;
    }
    nuniquev=uniqueint(nuniquev, uniquev);


    // read in dirichlet boundary, set nbound and nuniqueb 
    fname = root+".bound";
    if(debug>2) System.out.println("about to read boundary from "+fname);
    nbound=0;
    try
    {
      BufferedReader in = new BufferedReader(new FileReader(fname));
      String input_line;
      input_line = in.readLine();
      while(input_line != null)
      {
	    System.out.println(input_line);
        // have a line, extract 2 integers
        len = input_line.length();
        if(len<4)  // not enough data, ignore blank lines
	    {
	      input_line = in.readLine();
          continue;
        }
        index = 0;
        while(input_line.substring(index,index+1).equals(" ")){index++;}
        last = input_line.indexOf(' ',index+1);
        System.out.println("index="+index+", last="+last);
        b1[nbound] = Integer.parseInt(input_line.substring(index,last)); 
        index = last+1;
        while(input_line.substring(index,index+1).equals(" ")){index++;}
        last = input_line.indexOf(' ',index+1);
        if(last<1) last = len;
        System.out.println("index="+index+", last="+last);
        b2[nbound] = Integer.parseInt(input_line.substring(index,last)); 
        if(debug>0) System.out.println("boundary segment nbound="+nbound+
                              " has vertices "+b1[nbound]+", "+b2[nbound]);
        if(b1[nbound]>nvert) System.out.println("bad boundary vertex "+
                                                 b1[nbound]);
        if(b2[nbound]>nvert) System.out.println("bad boundary vertex "+
                                                 b2[nbound]);
        if(b1[nbound]<minvert) System.out.println("bad boundary vertex "+
                                                   b1[nbound]);
        if(b2[nbound]<minvert) System.out.println("bad boundary vertex "+
                                                   b2[nbound]);
        nbound++;
	    input_line = in.readLine();
      } // end while input_line
    }
    catch(IOException exception)
    {
      System.out.println("can not open for reading "+fname);
      System.out.println(exception);
	  rtn[0] = 0;
      return;
    }
    if(debug>0) System.out.println("read Dirichlet boundaries from "+fname);

    System.out.println("subtracting minvert="+minvert+
                       " from all vertices, using base zero");
    nuniqueb=0;
    for(int i=0; i<nbound; i++)
    {
      b1[i]=b1[i]-minvert;
      b2[i]=b2[i]-minvert;
      uniqueb[nuniqueb]=b1[i];
      uniqueb[nuniqueb+1]=b2[i];
      nuniqueb=nuniqueb+2;
    }
    nuniqueb=uniqueint(nuniqueb, uniqueb);
	int uniquef[] = new int[nuniquev];
    nuniquef=freevert(uniquef, nuniquev, uniquev, nuniqueb, uniqueb);
    if(debug>0)
      for(int i=0; i<nuniqueb; i++)
        System.out.println("unique boundary "+uniqueb[i]);
    if(debug>0) System.out.println("number of free vertices is "+nuniquef);
    if(debug>0) 
      for(int i=0; i<nuniquef; i++) 
        System.out.println("free vertex "+uniquef[i]);

    // read in coordinates, check consistency 
    fname = root+".coord";
    if(debug>2) System.out.println("about to read coordinates from "+ fname);
    ncoord=0;
    try
    {
      BufferedReader in = new BufferedReader(new FileReader(fname));
      String input_line;
      input_line = in.readLine();
      while(input_line != null)
      {
	    System.out.println(input_line);
        // have a line, extract 2 double
        len = input_line.length();
        if(len<5)  // not enough data, ignore blank lines
	    {
	      input_line = in.readLine();
          continue;
        }
        index = 0;
        while(input_line.substring(index,index+1).equals(" ")){index++;}
        last = input_line.indexOf(' ',index+1);
        System.out.println("index="+index+", last="+last);
        xc[ncoord] = Double.parseDouble(input_line.substring(index,last)); 
        index = last+1;
        while(input_line.substring(index,index+1).equals(" ")){index++;}
        last = input_line.indexOf(' ',index+1);
        if(last<1) last = len;
        System.out.println("index="+index+", last="+last);
        yc[ncoord] = Double.parseDouble(input_line.substring(index,last)); 
        if(debug>0) System.out.println("coordinate "+ncoord+" at  "+
                                       xc[ncoord]+", "+yc[ncoord]);
        if(ncoord==0)
        {
          xmax=xc[ncoord];
          xmin=xc[ncoord];
          ymax=yc[ncoord];
          ymin=yc[ncoord];
        }
        if(xc[ncoord]>xmax) xmax=xc[ncoord];
        if(xc[ncoord]<xmin) xmin=xc[ncoord];
        if(yc[ncoord]>ymax) ymax=yc[ncoord];
        if(yc[ncoord]<ymin) ymin=yc[ncoord];
        ncoord++;
	    input_line = in.readLine();
      } // end while input_line 
    }
    catch(IOException exception)
    {
      System.out.println("can not open for reading "+fname);
      System.out.println(exception);
      rtn[0] = 0; // error return
	  return;
    }
    if(debug>0) System.out.println("coordinates read from "+fname);


    if(ncoord!=nvert)
       System.out.println("**** wrong number of coordinates="+ncoord+
                          ", should be"+nvert);
    nfree=nvert-nuniqueb;

    System.out.println("xmin="+xmin+", xmax="+xmax+
                       ", ymin="+ymin+", ymax="+ymax);
    System.out.println("nvert="+nvert+", nbound="+nbound+", nuniqueb="+
                        nuniqueb+", nfree="+nfree+", ntri="+ntri);

    rtn[0] = ntri;
    rtn[1] = nbound;
    rtn[2] = ncoord;
    rtn[3] = nvert;
    rtn[4] = nfree;
    rtn[5] = nuniqueb;
    rtnx[0] = xmin;
    rtnx[1] = xmax;
    rtnx[2] = ymin;
    rtnx[3] = ymax;

  } // end tri_input


  int uniqueint(int nold, int a[])
  {
    int i, j;
    if(debug>2) System.out.println("finding unique of nold="+nold);
    sortint(nold,a);
    j=0;
    for(i=1; i<nold; i++)
    {
      if(a[i]>a[i-1])
      {
        j++;
        a[j]=a[i];
      }
    }
    j++;
    if(debug>2) System.out.println("found unique of n="+j);
    return j;
  } // end uniqueint 

  void sortint(int n, int a[])
  {
    int i, j, temp;
    for(i=0; i<n-1; i++)
      for(j=i+1; j<n; j++)
        if(a[i]>a[j]) {temp=a[i]; a[i]=a[j]; a[j]=temp;}
  } // end sortint 

  int freevert(int c[], int na, int a[], int nb, int b[])
  {
    // a and b sorted integer arrays, c will be from a, not in b 
    int ia=0;
    int ib=0;
    int ic=0;
    if(debug>2) System.out.println("freevert na="+na+", nb="+nb);
    while(true)
    {
      if(ib>=nb || a[ia]!=b[ib]) {c[ic]=a[ia]; ic++; ia++;}
      else             {ia++; ib++;}
      if(ia>=na) break;
    }
    if(debug>2) System.out.println("freevert nc free = "+ic);
    return ic;
  }

  boolean not_in(int i, int a[], int n)
  {
    boolean found = false;
    int j;

    for(j=0; j<n; j++)
    {
      if(i==a[j]) { found=true; break; }
    }
    return !found;
  } // end not_in 

} // end class tri_input