/** ModuleRawData.java  Pixel database, java application PDB query. 

Ancillary class to recover raw data from module test

Author   : Attilio.Andreazza@mi.infn.it
Created  : 08-08-2005
Updated  : 10-11-2005 (missing closing statement)
Updated  : 14-11-2005 (GotData() function to keep track if raw data access
                       was successful)
**/

import PIXLibrary.*;

import java.util.StringTokenizer;

import java.lang.*;
import java.sql.*;
import java.io.*;

public class ModuleRawData { 

    final static int ALL=-1;
    final static int OR = 1;
    final static int AND= 2;

    final static int CHIPS= 16;
    final static int COLS = 18;
    final static int ROWS =160;

    private boolean gotData = false;
    public boolean GotData() { return gotData; }

    // Array of failed cuts, not directly accessible
    protected long [][][] FailedCuts= new long [CHIPS][COLS][ROWS];

    //------------------------------------------------
    // Default constructor: whole array set to 0
    //------------------------------------------------
    public ModuleRawData() {
	gotData=false;
	for (int i=0; i<CHIPS; i++) {
	    for (int j=0; j<COLS; j++) {
		for (int k=0; k<ROWS; k++) {
		    FailedCuts[i][j][k]=0;
		}
	    }
	}
    }

    //------------------------------------------------
    // Full constructor, reading from a raw data file.
    //------------------------------------------------
    public ModuleRawData(Connection conn, String TestSN) {
	gotData = false;
	int lines = GetRawDataFile(conn, TestSN);
	// If there are errors in RawDataFile, the array may not
        // be initialize, to reset it now. 
	if (lines<0) {
	    for (int i=0; i<CHIPS; i++) {
		for (int j=0; j<COLS; j++) {
		    for (int k=0; k<ROWS; k++) {
			FailedCuts[i][j][k]=0;
		    }
		}
	    }
	}
    }

    //------------------------------------------------
    // Main function to access the PDB and fill the
    // array of failed cuts
    //------------------------------------------------
    public int GetRawDataFile(Connection conn, String TestSN) {
	InputStream is;                  // Input stream (database)
	String inputLine;
	PreparedStatement statement;  
	CallableStatement callStatement;
	ResultSet result;    
	StringTokenizer strT;
	String attribute;
	long [] attributes = new long [4];
	int chip,column,row;
	
	try {
	    statement = conn.prepareStatement ("SELECT RAW_DATA FROM P_test_rawdata WHERE TEST_NO=?"); 
	    statement.setString(1,TestSN);
	    result = statement.executeQuery();      
	    if (result.next()) {
		is  = result.getBinaryStream(1);        // open the data stream
		BufferedReader BR = new BufferedReader(new InputStreamReader(is));
		// If arrived here, the file has been found:
                // reset the data array before reading it.
		for (int i=0; i<CHIPS; i++) {
		    for (int j=0; j<COLS; j++) {
			for (int k=0; k<ROWS; k++) {
			    FailedCuts[i][j][k]=0;
			}
		    }
		}
		int line=0;   // line number in the raw data file (header excluded), not more than 50000.
		while ((inputLine = BR.readLine()) != null) {  // read line by line
		    inputLine = PDB_Lib.remExtraBlank(inputLine);
		    if (inputLine.length()==0)            continue;
		    if (inputLine.startsWith("chip"))     continue;
		    strT = new StringTokenizer(inputLine," "); // blank separator 
		    for (int index=0; strT.hasMoreElements(); index++)  {
			attribute = (String) strT.nextElement();
			attributes[index] = Long.parseLong(attribute);  
		    }
		    line++;
		    chip    = (int) attributes[0];
		    column  = (int) attributes[1];
		    row     = (int) attributes[2];
		    FailedCuts[chip][column][row] = attributes[3];
		}
		BR.close();
		statement.close();
		gotData = true;
		return line;
	    } else {
		System.err.println("Missing or empty raw data file for test " + TestSN);
		statement.close();
		return -1;
	    } 
	}
        catch (Exception exception) {
	    System.err.println("GetRawDataFile failed ! " + exception);
	    return -1;
	}
    }

    //------------------------------------------------
    // Dump module raw data information to a file.
    //------------------------------------------------
    public int PrintRawData(String Filename) {
	try {
	    FileOutputStream fos = new FileOutputStream(Filename);
	    PrintStream outfile =new PrintStream(fos);
	    outfile.println("chip column row code");
	    int line = 0;
	    for (int i=0; i<CHIPS; i++) {
		for (int j=0; j<COLS; j++) {
		    for (int k=0; k<ROWS; k++) {
			if ( FailedCuts[i][j][k]>0 ) {
			    outfile.println(i+" "+j+" "+k+" "
					    +FailedCuts[i][j][k]);
			    line++;
			}
		    }
		}
	    }
	    outfile.close();
	    return line;
	}
        catch (Exception exception) {
	    System.err.println("Unable to write to file" +Filename+": "
			       +exception);
	    return -1;
	}
    }

    //------------------------------------------------
    // Access information for a single pixel
    //------------------------------------------------
    public long GetCode(int chip, int column, int row) {
	return FailedCuts[chip][column][row];
    }

    //------------------------------------------------
    // Count pixels failing a certain set cuts.
    // chip can be:
    // a number for 0 to ModuleRawData.CHIPS-1
    //                   if a apecific chip is requested
    // ModuleRawData.ALL if all chips are to be checked.
    // operation can be: 
    // ModuleRawData.OR  (the pixel fails at least one 
    //                    cut of the bitted word) 
    // ModuleRawData.AND (the pixel fails all the 
    //                    cuts of the bitted word) 
    //------------------------------------------------
    public int Count(int chip, long bittedCuts, int operation) {
	int counter = 0;
	int minchip, maxchip;
	if ( chip==ALL) {
	    minchip=0;
	    maxchip=CHIPS;
	} else if ( chip>=0 && chip<CHIPS) {
	    minchip=chip;
	    maxchip=minchip+1;
	} else {
	    System.err.println("Not valid chip#: "+chip);
	    return -1;
	}
	switch (operation) {
	case OR:
	    for (int i=minchip; i<maxchip; i++) {
		for (int j=0; j<COLS; j++) {
		    for (int k=0; k<ROWS; k++) {
			if ( (FailedCuts[i][j][k]&bittedCuts)!=0 ) counter++;
		    }
		}
	    }
	    return counter;
	case AND:
	    for (int i=minchip; i<maxchip; i++) {
		for (int j=0; j<COLS; j++) {
		    for (int k=0; k<ROWS; k++) {
			if ( (FailedCuts[i][j][k]&bittedCuts)==bittedCuts ) counter++;
		    }
		}
	    }
	    return counter;
	default:
	    System.err.println("Not valid operation: "+operation);
	    return -1;
	}
    }

    //------------------------------------------------
    // Count pixels failing the set of cuts "failed",
    // but not failing the set of cuts "notfailed".
    // chip can be:
    // a number for 0 to ModuleRawData.CHIPS-1
    //                   if a apecific chip is requested
    // ModuleRawData.ALL if all chips are to be checked.
    // failedOp and notfailedOp can be: 
    // ModuleRawData.OR  (the pixel fails at least one 
    //                    cut of the bitted word) 
    // ModuleRawData.AND (the pixel fails all the 
    //                    cuts of the bitted word) 
    //------------------------------------------------
    public int Count(int chip, long failed, int failedOp, long notfailed, int notfailedOp) {
	int counter = 0;
	int minchip, maxchip;
	if ( chip==ALL) {
	    minchip=0;
	    maxchip=CHIPS;
	} else if ( chip>=0 && chip<CHIPS) {
	    minchip=chip;
	    maxchip=minchip+1;
	} else {
	    System.err.println("Not valid chip#: "+chip);
	    return -1;
	}
	switch (failedOp) {
	case OR:
	    switch (notfailedOp) {
	    case OR:
		for (int i=minchip; i<maxchip; i++) {
		    for (int j=0; j<COLS; j++) {
			for (int k=0; k<ROWS; k++) {
			    if ( (FailedCuts[i][j][k]&failed)!=0 
				 && (FailedCuts[i][j][k]&notfailed)==0 ) 
				counter++;
			}
		    }
		}
		return counter;
	    case AND:
		for (int i=minchip; i<maxchip; i++) {
		    for (int j=0; j<COLS; j++) {
			for (int k=0; k<ROWS; k++) {
			    if ( (FailedCuts[i][j][k]&failed)!=0 
				 && (FailedCuts[i][j][k]&notfailed)!=notfailed ) 
				counter++;
			}
		    }
		}
		return counter;
	    default:
		System.err.println("Not valid operation: "+notfailedOp);
		return -1;
	    }
	case AND:
	    switch (notfailedOp) {
	    case OR:
		for (int i=minchip; i<maxchip; i++) {
		    for (int j=0; j<COLS; j++) {
			for (int k=0; k<ROWS; k++) {
			    if ( (FailedCuts[i][j][k]&failed)==failed 
				 && (FailedCuts[i][j][k]&notfailed)==0 ) 
				counter++;
			}
		    }
		}
		return counter;
	    case AND:
		for (int i=minchip; i<maxchip; i++) {
		    for (int j=0; j<COLS; j++) {
			for (int k=0; k<ROWS; k++) {
			    if ( (FailedCuts[i][j][k]&failed)==failed 
				 && (FailedCuts[i][j][k]&notfailed)!=notfailed ) 
				counter++;
			}
		    }
		}
		return counter;
	    default:
		System.err.println("Not valid operation: "+notfailedOp);
		return -1;
	    }
	default:
	    System.err.println("Not valid operation: "+failedOp);
	    return -1;
	}
    }

}