/*
 * GridDataReaderAndWriter.java
 *
 * Created on August 1, 2002, 10:40 PM
 */

package uk.ac.leeds.ccg.projects.MedAction.FuzzyInference;

/**
 *
 * @author  ma0101
 */
import uk.ac.leeds.ccg.andyt.grids.*;
import uk.ac.leeds.ccg.geotools.*;
import java.io.*;
import uk.ac.leeds.ccg.raster.*;
import com.sun.java.util.collections.*;
import uk.ac.leeds.ccg.geotools.classification.*;
import uk.ac.leeds.ccg.widgets.*;
import java.awt.*;
public class GridDataReaderAndWriter {
    private String[] allFileName = null;
    private String[] inputFileName = null;
    private String outFileName = null;
    
    private AbstractGrid2DSquareCellDouble[] allReadGrid = null;
    static public final int WRITEOUTFILE = 1;
    static public final int READOUTFILE = 0;
    private double[] outValue = null;
    private AbstractGrid2DSquareCellDouble[] inputGrid = null;
    
    /** Creates a new instance of GridDataReaderAndWriter */
    public GridDataReaderAndWriter( String[] allFileName,int outType ) {
        this.setAllFileName(allFileName,outType);
        
    }
    
    /**
     *
     * @param inputFileName
     * @param outFileName
     * @param outType
     */    
    public GridDataReaderAndWriter(String[] inputFileName,String outFileName,int outType) {
        this.setInputFileName(inputFileName);
        this.setOutFileName(outFileName);
        iniGrid2DSquareCellDoubleArray(outType);
    }
    
    public GridDataReaderAndWriter() {
    }
    
    /**
     *
     * @param id
     * @return
     */    
    public double[] readAllGridOrAllInputGrid(int id){
        if(this.allReadGrid==null&&this.inputGrid==null) return null;
        
        if(this.allReadGrid!=null) {
            return readGrids(this.allReadGrid,id);
        }
        else if(this.inputGrid!=null) {
            return readGrids(this.inputGrid,id);
        }
        else return null;
        
    }
    
    private double[] readGrids(AbstractGrid2DSquareCellDouble[] grids,int id){
        double[] temp=new double[grids.length];
        for(int i=0;i<temp.length;i++) {
            temp[i]=grids[i].getCell(id);
        }
        return temp;
    }
    
    private void iniGrid2DSquareCellDoubleArray(int outType){
        if(outType==this.READOUTFILE){
            String[] allFileName=this.getAllFileName();
            allReadGrid=new Grid2DSquareCellDouble[allFileName.length];
            File[] allFile=new File[allFileName.length];
            for(int i=0;i<allReadGrid.length;i++) {
                allFile[i]=new File(allFileName[i]);
                allReadGrid[i] = new Grid2DSquareCellDoubleFactory().createGrid2DSquareCellDouble( allFile[i] );
            }
        }
        else if(outType==this.WRITEOUTFILE){
            String[] inputFileName=this.getInputFileName();
            
            File[] inputFile=new File[inputFileName.length];
            inputGrid=new Grid2DSquareCellDouble[inputFile.length];
            for(int i=0;i<inputFile.length;i++) {
                inputFile[i]=new File(inputFileName[i]);
                inputGrid[i]=new Grid2DSquareCellDoubleFactory().createGrid2DSquareCellDouble( inputFile[ i ] );
            }
            
            
        }
        
    }
    /**
     *
     * @return
     */    
    public int getGridNcols(){
        int temp=0;
        if(this.allReadGrid!=null)
        {return this.allReadGrid[0].getNcols();}
        else if(this.inputGrid!=null)
        { temp= this.inputGrid[0].getNcols();
          return temp;}
        else
            return 0;
    }
    
    /**
     *
     * @return
     */    
    public int getGridNrows(){
        int temp=0;
        if(this.allReadGrid!=null)
        {return this.allReadGrid[0].getNrows();}
        else if(this.inputGrid!=null)
        {temp= this.inputGrid[0].getNrows();
         return temp;}
        else
            return 0;
    }
    /**
     *
     * @param fireGridFile
     * @param fire
     * @param column
     * @param row
     */    
    public static void OutputToGridFile(File fireGridFile,double[] fire, int column,int row){
        
        
        try {
            System.out.println( "trying to create inGrid in memory..." );
            /*
            f = new Grid2DSquareCellDoubleFactory();
             
            fireGrid = f.createGrid2DSquareCellDouble(row,column,0.0,0.0,1000,-9999.0d,false );
             
            for(int i=0;i<fire.length;i++)
            {fireGrid.setCell(i,fire[i]);}
             
             
            fireGrid.toAsciiFile(fireGridFile);
             */
            writeOut(iniCellArray(fire,row,column),fireGridFile);
            
            System.out.println( "...done" );
        } catch ( java.lang.OutOfMemoryError e ) {
            System.out.println( e + " creating inGrid as file..." );
            //ff = new Grid2DSquareCellDoubleFileFactory();
            //ff.setFile( new File("f") );
            //fireGrid = f.createGrid2DSquareCellDouble(row,column,0.0,0.0,1000,-9999.0,false );
            //inGrid = ff.createGrid2DSquareCellDouble( inGridFile );
            System.out.println( "...done" );
        }
        
    }
    
    private static double[][] iniCellArray(double[] fire,int rows,int cols){
        double[][] temp=new double[rows][cols];
        for(int i=0;i<rows;i++) {
            for(int j=0;j<cols;j++)
                temp[i][j]=fire[i*cols+j];
        }
        return temp;
    }
    
    private static void writeOut(double[][] cellArray,File file){
        try {
            PrintWriter pw = new PrintWriter( new BufferedWriter( new OutputStreamWriter( new FileOutputStream( file ) ) ) );
            // Write header info
            int nrows = cellArray.length;
            int ncols = cellArray[0].length;
            pw.println( "ncols " + ncols );
            pw.println( "nrows " + nrows );
            pw.println( "xllcorner " + 0.0 );
            pw.println( "yllcorner " + 0.0 );
            pw.println( "cellsize " + 1000.0 );
            pw.println( "noDataValue "+ -9999.0 );
            // Write values
            for ( int i = 0; i < nrows; i ++ ) {
                for ( int j = 0 ; j < ncols; j ++ ) {
                    pw.print( cellArray[i][j] + " " );
                }
                pw.println( "" );
            }
            // Close output
            pw.flush();
            pw.close();
        } catch ( java.io.FileNotFoundException e ) {
            System.out.println( e.toString() + " in toAsciiFile( File(" + file + ") )" );
            System.exit( 0 );
        }
        
        
    }
    /**
     *
     * @param outValue
     */    
    public void setOutputValue(double[] outValue){
        this.outValue=new double[outValue.length];
        for(int i=0;i<outValue.length;i++)
        {this.outValue[i]=outValue[i];}
    }
    /**
     *
     * @param in
     */    
    public void setInputFileName(String[] in){
        inputFileName=new String[in.length];
        for(int i=0;i<in.length;i++) {
            inputFileName[i]=in[i];
        }
    }
    
    /**
     *
     * @param out
     */    
    public void setOutFileName(String out){
        outFileName=out;
    }
    
    
    /**
     *
     * @param all
     * @param outType
     */    
    public void setAllFileName(String[] all,int outType){
        inputFileName=new String[all.length-1];
        this.allFileName=new String[all.length];
        for(int i=0;i<inputFileName.length;i++) {
            inputFileName[i]=all[i];
            allFileName[i]=all[i];
        }
        outFileName=all[all.length-1];
        
        this.allFileName[all.length-1]=all[all.length-1];
        iniGrid2DSquareCellDoubleArray(outType);
    }
    
    
    /**
     *
     * @return
     */    
    public String[] getInputFileName(){
        return this.inputFileName;
    }
    
    
    /**
     *
     * @return
     */    
    public String getOutFileName(){
        return this.outFileName;
    }
    
    
    /**
     *
     * @return
     */    
    public String[] getAllFileName(){
        if(inputFileName==null||outFileName==null)
        {return null;}
        
        else{
            String[] all=new String[inputFileName.length+1];
            for(int i=0;i<inputFileName.length;i++) {
                all[i]=inputFileName[i];
            }
            all[all.length-1]=outFileName;
            return all;
        }
    }
    
    /**
     *
     * @param parentContainer
     * @param gridFile
     */    
    public static void showGrid(java.awt.Container parentContainer, File gridFile) {
        File displayFile = gridFile;
        
        // Display GeometricDensity output as a raster on screen
        // Get output
        Raster r2;
        try{r2 = new Raster( displayFile.toString() );}
        catch(Exception e){e.printStackTrace();return;}
        r2.setMissingValueCode(-9999.0d);
        System.out.println("(min,max)=("+r2.getMin()+","+r2.getMax()+")");
        // Set Frame
        parentContainer.setLayout(new BorderLayout());
        // Set RasterLayer
        RasterLayer rl1 = new RasterLayer(r2);
        // Set a Shader and Key
        //HSVShader hsvs1 = new HSVShader(Color.black,Color.red,true);
        //hsvs1.setMissingValueColor(Color.white);
        //hsvs1.setMissingValueCode((double)r1.getMissingValueCode());
        //hsvs1.setRange(r1.getMin()+r1.getTol()+(r1.getMax()-r1.getMin())/100.0d,r1.getMax());
        //t1.setShader(hsvs1);
        //Key k1=hsvs1.getKey();
        //ClassificationShader cs1=new ClassificationShader(r2,6,ClassificationShader.QUANTILE);
        ClassificationShader cs1 = new ClassificationShader( r2, 4, ClassificationShader.EQUAL_INTERVAL );
        cs1.setRange( r2.getMin(), r2.getMax() );
        cs1.setMissingValueColor( Color.white );
        Key k1 = cs1.getKey();
        // Add key to frame
        parentContainer.add(k1,"East");
        // Set theme
        Theme t1=new Theme(rl1,cs1);
        // Set viewer
        Viewer v1=new Viewer();
        v1.setBackground(Color.white);
        v1.addTheme(t1);
        // Add viewer to theme
        parentContainer.add(v1,"Center");
        // Set Toolbar
        ToolBar tb1=new ToolBar(v1);
        // Add Toolbar to frame
        parentContainer.add(tb1,"South");
        // Display frame
        
        parentContainer.setVisible(true);
        parentContainer.validate();
        // Annonymous inner class set up for closing frame.
        
    }
    
    /**
     *
     * @return
     */    
    public double getNoDataValue() {
        
        double temp=0;
        if(this.allReadGrid!=null)
        {return this.allReadGrid[0].getNoDataValue();}
        else if(this.inputGrid!=null)
        { temp= this.inputGrid[0].getNoDataValue();
          return temp;}
        else
            return -9999.0;
    }
    
    /**
     *
     * @param gridFile
     * @return
     */    
    public static double[] readGridAsciiFile(File gridFile) {
        double[] value=null;
        try{
            BufferedReader reader=new BufferedReader(new FileReader(gridFile));
            StreamTokenizer st=new StreamTokenizer(reader);
            
            st.wordChars( '_', '_' );
            st.parseNumbers();
            st.eolIsSignificant( false );
            st.lowerCaseMode( false );
            
            // Read header and set parameters from inputGridgridascii
            int type=st.nextToken();
            st.nextToken();
            int cols = (int) st.nval;
            if(cols!=720) throw new Exception("wrong column number " + cols);
            System.out.println("cols" + cols);
            st.nextToken();
            st.nextToken();
            int rows=(int) st.nval;
            
            if(rows!=1260) throw new Exception("wrong row number " + rows);
            System.out.println("rows" + rows);
            st.nextToken();
            st.nextToken();
            double x=st.nval;
            
            if(x!=0.0) throw new Exception("wrong x corner data " + x);
            System.out.println("x " + x);
            st.nextToken();
            st.nextToken();
            
            double y=st.nval;
            if(y!=0.0) throw new Exception("wrong y corner data " + y);
            System.out.println("y " + y);
            st.nextToken();
            st.nextToken();
            
            double cellSize=st.nval;
            if(cellSize!=1000.0) throw new Exception("wrong cellSize data " + cellSize);
            System.out.println("cellSize " + cellSize);
            st.nextToken();
            st.nextToken();
            
            
            double nodatavalue=st.nval;
            if(nodatavalue!=-9999.0) throw new Exception("wrong nodatavalue " + nodatavalue);
            System.out.println("nodatavalue " + nodatavalue);
            
            st.ordinaryChar('E');
            value = new double[rows*cols];
            int i=0;
            
            while((type=st.nextToken())!=st.TT_EOF) {
                if(type=='E') {
                    st.nextToken();
                    --i;
                    value[i] = value[i] * Math.pow( 10.0, st.nval );i++; continue;
                }
                if(type==st.TT_NUMBER) {
                    value[i]=st.nval;++i;
                }
            }
            
            
            if(i!=(rows*cols)) throw new Exception("something wrong in data, the number of data is only " + i);
            
        }
        catch(Exception e){System.out.println(e);return null;}
        
        return value;
        
    }
    
    /**
     *
     * @param indatadir
     * @param outdatadir
     */    
    public void rerange(String indatadir,String outdatadir){
        
        String[] allInputFileName = new File(indatadir).list();
        File[] allInputFile=new File[allInputFileName.length];
        File[] allOutFile =new File[allInputFile.length];
        for(int i=0;i<allInputFileName.length;i++) {
            
            allInputFile[i]=new File(indatadir+allInputFileName[i]);
            allOutFile[i]=new File(outdatadir+"reranged"+allInputFile[i].getName());
            
            reranging(allInputFile[i],allOutFile[i]);
            System.out.println(allInputFile[i].toString()+"done ....");
            
            System.out.println();
            System.out.println();
            System.out.println();
            
        }
    }
    
    private void reranging(File in, File out){
        double[] ingrid = null;
        double min=0.0;
        double max = 0.0;
        int IDN=0;
        try {
            System.out.println("read Source file " + in.getName());
            double[] temp= this.readGridAsciiFile(in);
            ingrid=new double[temp.length];
            for(int i=0;i<temp.length;i++)
                ingrid[i]=temp[i];
            
            int rows=1260;
            int cols=720;
            IDN=rows*cols;
            
            double nodatavalue=-9999.0;
            
            System.out.println("get cell value");
            
            min=getMin(ingrid);
            System.out.println(min);
            max=getMax(ingrid);
            System.out.println(max);
            System.out.println("start reranging");
            for(int i=0;i<IDN;i++) {
                if(ingrid[i]!=nodatavalue){
                    ingrid[i] = (ingrid[i]-min)/(max-min);
                    
                }
                // if(ingrid[i]>1.0) throw new Exception("problem with reranging" + i);
                
            }
            
            GridDataReaderAndWriter.OutputToGridFile(out,ingrid,cols,rows);
            
        } catch (Exception e ) {
            System.out.println(e);
            e.printStackTrace();
            // ingrid = ff.createGrid2DSquareCellDouble( new File("d:/temp/arc/minor.asc"), true );
            // ff.setFile(new File(in.getPath()+"temp"));
            // outgrid.toAsciiFile(new File("d:/temp/arc/minorden.asc"));
        }
    }
    
    private double getMin(double[] value){
        int length=value.length;
        double min=1.0;
        for(int i=0;i<length;i++) {
            if((value[i]!=-9999.0)&&(value[i]<min)){min=value[i];}
        }
        return min;
    }
    private double getMax(double[] value){
        int length=value.length;
        double max=value[0];
        for(int i=1;i<length;i++) {
            if((value[i]!=-9999.0)&&(value[i]>max)){max=value[i];}
        }
        return max;
    }
    
    private static synchronized void writeTrainingData(double[][] x, double[] y, File file) {
        try {
            PrintWriter pw = new PrintWriter( new BufferedWriter( new FileWriter(  file ) ) );
            // Write header info
            int inputFileNumber = x[0].length;
            int inputNumber = x.length;
            pw.println( "inputFileNumber " + inputFileNumber );
            pw.println( "inputNumber " + inputNumber );
            // Write  x[][] values
            for ( int i = 0; i < inputNumber; i ++ ) {
                for ( int j = 0 ; j < inputFileNumber; j ++ ) {
                    pw.print( x[i][j] + " " );
                }
                pw.println( "" );
            }
            // write y[] value
            for(int i=0;i<inputNumber;i++){
                pw.print(y[i]+" ");
            }
            pw.println("");
            // Close output
            pw.flush();
            pw.close();
        } catch ( Exception e ) {
            System.out.println( e.toString() + " in toAsciiFile( File(" + file + ") )" );
            System.exit( 0 );
        }
        
    }
    
    private static Object[] readTrainingData(File file) {
        Object[] array=new Object[2];
        double[][] xvalue=null;
        double[] yvalue=null;
        try{
            BufferedReader reader=new BufferedReader(new FileReader(file));
            StreamTokenizer st=new StreamTokenizer(reader);
            
            st.wordChars( '_', '_' );
            st.parseNumbers();
            st.eolIsSignificant( false );
            st.lowerCaseMode( false );
            // Read header and set parameters from training data ascii file
            int type=st.nextToken();
            st.nextToken();
            int inputFileNumber = (int) st.nval;
            System.out.println("inputFileNumber " + inputFileNumber );
            st.nextToken();
            st.nextToken();
            int inputNumber=(int) st.nval;
            System.out.println("inputNumber" + inputNumber);
            
            // construct training data array;
            xvalue=new double[inputNumber][inputFileNumber];
            yvalue=new double[inputNumber];
            
            //start reading data
            st.ordinaryChar('E');
            type=st.nextToken();
            int i=0;
            
            while((type=st.nextToken())!=st.TT_EOF){
                if(type=='E') {
                    st.nextToken();
                    --i;
                    if((i/inputFileNumber)<inputNumber)
                    {xvalue[i/inputFileNumber][i%inputFileNumber]=xvalue[i/inputFileNumber][i%inputFileNumber]*Math.pow( 10.0, st.nval );++i;}
                    else {
                        yvalue[i-inputFileNumber*inputNumber]=yvalue[i-inputFileNumber*inputNumber]*Math.pow( 10.0, st.nval ); ++i;
                    }
                    continue;
                }
                if(type==st.TT_NUMBER) {
                    
                    if((i/inputFileNumber)<inputNumber)
                    {xvalue[i/inputFileNumber][i%inputFileNumber]=st.nval;++i;}
                    else {
                        yvalue[i-inputFileNumber*inputNumber]=st.nval; ++i;
                    }
                    
                }
                
            }
           
            
            if(i!=((inputFileNumber+1)*inputNumber)) throw new Exception("something wrong in data, the number of data is only " + i);
            
        }
        catch(Exception e){System.out.println(e);return null;}
        array[0]=xvalue;
        array[1]=yvalue;
        
        return array;
    }
    
    /**
     *
     * @param fire
     * @param target
     * @return
     */    
    public static double[] getResultStatistics(double[] fire, double[] target) {
        double meanE=0.0;
        double maxE=0.0;
        double minE=0.0;
        double rmsE=0.0;
        double totalAbsError=0.0;
        double arrayLength=fire.length;
            
        double[] eachCellError=null;
        Vector withdataid = new Vector();
        double ySum=0.0;
        for(int i=0;i<arrayLength;i++)
        {if(fire[i]!= -9999.0) withdataid.add(new Integer(i));}
        
        eachCellError=new double[withdataid.toArray().length];
        
        //get all the error for each cell;
        for(int i=0;i<eachCellError.length;i++)
              {
                 eachCellError[i] =Math.abs( fire[((Integer)withdataid.get(i)).intValue()] - target[((Integer)withdataid.get(i)).intValue()]);
                 ySum=ySum + target[((Integer)withdataid.get(i)).intValue()];
              }
        
        // get minError and maxError
        minE=eachCellError[0];
        maxE=eachCellError[0];
        for(int i=1;i<eachCellError.length;i++){
            if(eachCellError[i]<minE) {minE=eachCellError[i];}
            if(eachCellError[i]>maxE) {maxE=eachCellError[i];}
            
        }
        
        // get meanError
        for(int i=0;i<eachCellError.length;i++){
            meanE= meanE + eachCellError[i];  
            
        }
         meanE=meanE/eachCellError.length;
       
         
       // get RMS Error
         for(int i=0;i<eachCellError.length;i++){
            rmsE= rmsE + eachCellError[i]*eachCellError[i];  
            
        }
         rmsE=Math.sqrt(rmsE/eachCellError.length);
       
           
       // get RMS Error
         
         for(int i=0;i<eachCellError.length;i++){
            totalAbsError = totalAbsError + Math.abs(eachCellError[i]);  
            
        }
         rmsE=Math.sqrt(rmsE/eachCellError.length);
       
         
         double[] allE = {minE,maxE,meanE,rmsE,totalAbsError};
         return allE;
    
    }
    
    /**
     *
     * @param populationAtRisk
     * @param result
     * @param file
     */    
    public static void writeOutForGam(double[] populationAtRisk, double[] result, File file) {
        try {
            PrintWriter pw = new PrintWriter( new BufferedWriter( new FileWriter(  file ) ) );
            int count=0;
            int col=0;
            int row=0;
            // Write  out all value
            for ( int i = 0; i < populationAtRisk.length; i ++ ) {
                 if(populationAtRisk[i]!=-9999.0){
                    ++count;
                    pw.print(count+",");
                    col=GridDataReaderAndWriter.getCol(i);
                    row=GridDataReaderAndWriter.getRow(i);
                    
                    pw.print( col * 1000 + 500 + "," );
                    pw.print((1259 - row)*1000 + 500 + "," );
                    
                    if(col<100) {System.out.println(i);}
                    
                    if(populationAtRisk[i]==0.0){
                    pw.print(populationAtRisk[i]+0.0001+",");}
                    else {pw.print(populationAtRisk[i]+",");}
                                    
                    pw.print(Math.abs(result[i]-populationAtRisk[i]));
                    pw.println( "" );
                 }
            }
            // write y[] value
            pw.flush();
            pw.close();
        } catch ( Exception e ) {
            System.out.println( e.toString() + " in toAsciiFile( File(" + file + ") )" );
            System.exit( 0 );
        }
    }
    private static int getCol(int id){
        return id % 720;
        
    }
    private static int getRow(int id){
        return (int) id / 720;
    }
    
    /**
     *
     * @param in
     * @param out
     * @param min
     * @param max
     */    
    public static void rerangeBack(File in, File out, double min, double max) {
       double[] inValue=GridDataReaderAndWriter.readGridAsciiFile(in);
       double[] outValue = new double[inValue.length];
       for(int i=0;i<inValue.length;i++)
       {
           if(inValue[i]!=-9999.0)
           {outValue[i]=inValue[i]*(max-min)+min;}
           else{outValue[i]=inValue[i];}
       }
       
       GridDataReaderAndWriter.OutputToGridFile(out,outValue,720,1260);
       
    }
    
}