import java.io.*;
import java.util.*;

// This class support the creation of database relations, several
// relational algebra operators and basic data manipulation operators.

public class Relation implements Serializable {

  // F I E L D S

  // Name of the relation.
  private String     relName=null;

  // Attribute names for the relation
  private Vector  attributes=null;

  // Domain classes (types of attributes)
  private Vector   domains=null;

  // Actual data storage (list of tuples) for the relation.
  private Vector       table=null;

  // Counter to facilitate creating uniques names.
  private int      counter=0;

  // Map associating relation names with relation memory images.
  private static Map   catalogMap;

  // Static block to load the system catalog and all relations listed
  // in the catalog.
    
  static {
    catalogMap=new HashMap();

    FileInputStream fin,fin2 = null;
    BufferedReader infile,infile2 = null;

    try {
      fin = new FileInputStream("catalog.dat");
      infile = new BufferedReader(new InputStreamReader(fin));

      int numRelations=0;
      String s = infile.readLine();
      try {
        numRelations = Integer.parseInt(s);
      } catch (NumberFormatException e) {
          System.out.println("Invalid number");
        }
      for (int i=0; i<numRelations; i++) {
        // Code to set Relation Scheme in Catalog
        String rname = infile.readLine();
        s = infile.readLine();
        int numAttributes=0;
        try {
          numAttributes = Integer.parseInt(s);
        } catch (NumberFormatException e) {
            System.out.println("Invalid number");
          }
        Vector attrs = new Vector();
        Vector doms = new Vector();
        for (int j=0; j<numAttributes; j++) {
          String aname = infile.readLine();
          String atype = infile.readLine();
          attrs.addElement(aname);
          doms.addElement(atype);
        }
        Relation r = new Relation(rname,attrs,doms);

        // Code to populate r with tuples
        String fname="db/"+rname+".dat";
        fin2 = new FileInputStream(fname);
        infile2 = new BufferedReader(new InputStreamReader(fin2));
        s = infile2.readLine();
        int numTuples=0;
        try {
          numTuples = Integer.parseInt(s);
        } catch (NumberFormatException e) {
            System.out.println("Invalid number 1");
          }
        for (int k=0; k<numTuples; k++) {
          Comparable [] tuple = new Comparable[numAttributes]; 
          for (int j=0; j<numAttributes; j++) {
            s = infile2.readLine();
            if (r.domains.elementAt(j).equals("varchar")) // is varchar
              tuple[j] = s;
            else if (r.domains.elementAt(j).equals("integer")) { // is integer
              Integer ival = null;
              try {
                ival = new Integer(Integer.parseInt(s));
              } catch (NumberFormatException e) {
                  System.out.println("Invalid number 2");
                }
              tuple[j] = ival;
            } else { // is  decimal
                Double dval = null;
                try {
                  dval = new Double(Double.parseDouble(s));
                } catch (NumberFormatException e) {
                    System.out.println("Invalid number 3");
                  }
                tuple[j] = dval;
              }
          }
          r.table.addElement(tuple);
        } 
        catalogMap.put(rname,r);
      }

    } catch (IOException e) {
      }
  }

  // C O N S T R U C T O R S

  /*******************************************************************
   * Construct a relation with given domain names.
   * @param  relName     name of the relation
   * @param  attributes  attribute names for the relation
   * @param  dNames      domain names (type names of attributes)
   * @param  primaryKey  attribute making up the primary key
   */
  public Relation (String    relName, Vector attributes, Vector dNames) {
    counter = 0;
    this.relName = relName;
    this.attributes = attributes;
    this.domains = dNames;
    table = new Vector ();
  }; // Relation

  // M E T H O D S

  /*******************************************************************
   * Method gets  access to the memory image of the relation named 'relName'.
   * @param   relName   name of the relation
   * @return  Relation  reference to relation in memory, null if not there
   */
  public static Relation getRelation (String relName) {
    if (catalogMap.containsKey(relName)) {
      Relation x = (Relation) catalogMap.get(relName);
      return x;
    } else
        return null;
  }; // getRelation

  public static boolean relationExists(String rname) {
    Relation r = getRelation(rname);
    return (r != null);
  }

  public static boolean attributeExists(String rname, String aname) {
    Relation r = getRelation(rname);
    if (r != null) {
      for (int i=0; i<r.attributes.size(); i++) {
        String a = (String) r.attributes.elementAt(i);
        if (a.equals(aname))
          return true;
      }
      return false;
    }
    else
      return false;
  }

  public static String attributeType(String rname, String aname) {
    Relation r = getRelation(rname);
    if (r != null) {
      for (int i=0; i<r.attributes.size(); i++) {
        String a = (String) r.attributes.elementAt(i);
        if (a.equals(aname))
          return (String) r.domains.elementAt(i);
      }
      return null;
    }
    else
      return null;
  }

  public static void saveCatalog() {
    try {
      OutputStream f = new FileOutputStream("catalog.dat");
      PrintStream outfile = new PrintStream(f);
  
      int numRelations=catalogMap.size();
      outfile.println(""+numRelations);
      Set s = catalogMap.entrySet();
      Iterator i=s.iterator();
      while (i.hasNext()) {
        Map.Entry e = (Map.Entry) i.next();
        String rname = (String) e.getKey();
        Relation r= (Relation) e.getValue();
        outfile.println(rname);
        outfile.println(""+r.attributes.size());
        for (int j=0; j<r.attributes.size(); j++) {
          String aname = (String) r.attributes.elementAt(j);
          String atype = (String) r.domains.elementAt(j);
          outfile.println(aname); 
          outfile.println(atype); 
        }
        String fname="db/"+rname+".dat";
        OutputStream f2 = new FileOutputStream(fname);
        PrintStream outfile2 = new PrintStream(f2);
        int nTuples = r.table.size(); 
        outfile2.println(nTuples);
        for (int k=0; k<nTuples; k++) {
          Comparable [] tup = (Comparable []) r.table.elementAt(k);
          for (int m=0; m<r.attributes.size(); m++) {
            String atype = (String) r.domains.elementAt(m);
            if (atype.equals("varchar")) {
              String sval = (String) tup[m];
              outfile2.println(sval);
            }
            else if (atype.equals("integer")) {
              Integer ival = (Integer) tup[m];
              outfile2.println(ival.intValue());
            } else {
                Double dval = (Double) tup[m];
                outfile2.println(dval.doubleValue());
              }
          } // for m
        } // for k
      } // while
    } catch (IOException e) {
      }

  }

  public static void printCatalog() {
    Relation r=null;
    Set s = catalogMap.entrySet();
    Iterator i=s.iterator();
    while (i.hasNext()) {
      Map.Entry e = (Map.Entry) i.next();
      String rname = (String) e.getKey();
      r = (Relation) e.getValue();
      System.out.print(rname+"(");
      for (int j=0; j<r.attributes.size(); j++) {
        String aname = (String) r.attributes.elementAt(j);
        String atype = (String) r.domains.elementAt(j);
        System.out.print(aname+":"); 
        System.out.print(atype); 
        if (j<(r.attributes.size()-1))
          System.out.print(",");
      }
      System.out.println(")");
      //printRelation(rname);
      int nTuples = r.table.size(); 
      System.out.println("Number of tuples = "+nTuples);
      for (int k=0; k<nTuples; k++) {
        Comparable [] tup = (Comparable []) r.table.elementAt(k);
        for (int m=0; m<r.attributes.size(); m++) {
          String atype = (String) r.domains.elementAt(m);
          if (atype.equals("varchar")) {
            String sval = (String) tup[m];
            System.out.print(sval+":");
          }
          else if (atype.equals("integer")) {
            Integer ival = (Integer) tup[m];
            System.out.print(ival.intValue()+":");
          } else {
              Double dval = (Double) tup[m];
              System.out.print(dval.doubleValue()+":");
            }
        } // for m
        System.out.println("");
      } // for k
    } // while
  }

} // Relation