/*
 * GeoTools java GIS tookit (c) The Centre for Computational Geography 2002
 *
 * This library is free software; you can redistribute it and/or modify it under the terms
 * of the GNU Lesser General Public License as published by the Free Software Foundation version 2.1
 */

package uk.ac.leeds.ccg.geotools;

import java.io.*;
import java.util.*;
import uk.ac.leeds.ccg.shapefile.*;

/**
 * An extension of the DataInputStream that handles
 * the input of GeoPrimitives.
 * This version extracts polygon maps from Arc/Info Generate files.
 * Later versions may deal with higher format files.
 *
 * $Log: ArcInfoReader.java,v $
 * Revision 1.2  2002/02/22 18:36:38  loxnard
 * Updated JavaDoc comments and reformatted.
 *
 *
 * @author James Macgill
 * @version $Revision: 1.2 $ $Date: 2002/02/22 18:36:38 $
 * @since before 0.5
 */

public class ArcInfoReader extends BufferedReader {
    
    /**
     * switch
     */
    
    boolean ignoreIDs = false;
    int sequentialID = 0;
    
    /**
     * Set up new GeoDataStream.
     * @param in Input stream to take data from.
     */
    public ArcInfoReader(Reader in){
        super(in);
    }
    
    
    /**
     * Sets the ignoreIDs option.
     *
     * many of the file types read by this class come with an ID code for each entry
     * you may under some circumstances want to ignore this and use a
     * sequential one instead, if so use this method and set flag to
     * true, note that by default, if you do not call this method the flag will be
     * set to false, i.e. ids will be read from file.
     * NB, incompeat, only affects some read methods, contact author if required for others.
     *
     * @param flag Boolean switch.  Set to true to ignore IDs stored in files.
     */
    public void setIgnoreIDs(boolean flag){
        ignoreIDs = flag;
    }
    
    /**
     * Reads a GeoPolygon.
     * If the ignoreIDs flag is set to true, sequential IDs will be used.
     * @return The GeoPolygon read.
     * @throws IOException Thrown if there are any errors whilst reading the file.
     */
    public final synchronized GeoPolygon readGeoPolygon() throws IOException {
        /**
         * The empty GeoPolygon
         */
        GeoPolygon poly=null;
        
        /**
         * Polygon ID
         */
        int id = 0;
        
        /**
         * The polygons Centroid
         */
        float xcent = 0;
        float ycent = 0;
        
        /**
         * Temp storage for each point as loaded
         */
        float x,y;
        
        /**
         * String to hold the 'END' of Polygon and File
         * Markers found in the Ungenerate file format
         */
        String marker;
        
        /**
         * Holds one line of the Ungenerate file
         */
        String line;
        
        //Read first line
        line = readLine();
        marker = line.substring(0,3);
        if(marker.equals("END")) return null; //Finished i.e. end of file
        
        //Read polygon header
        try {
            id = Integer.parseInt(line.substring(4,10).trim());
            
            if(id !=-99999){ //Closed Polygon
                sequentialID++;
                if(ignoreIDs)
                    id = sequentialID;
                //System.out.println("ID was "+id);
                xcent = new Float(line.substring(11,28).trim()).floatValue();
                ycent = new Float(line.substring(29,44).trim()).floatValue();
                //poly = new GeoPolygon(id,xcent,ycent);
            }
            else{
                id = -99999;
                xcent=0;ycent=0;
                //poly = new GeoPolygon(-99999,0,0);
                System.out.println("!Null Polygon!");
            }
            
            
            
            double xtemp[],xpoints[];
            double ytemp[],ypoints[];
            xpoints = new double[500];
            ypoints = new double[500];
            int npoints = -1;//inc'd to 0 before first use...
            int limit = 500,grow = 20;
            while(true) {
                //Read co-ordinates
                line = readLine();
                if(line.substring(0,3).trim().equals("END")) break;//
                //Above line made from ...
                //marker = line.substring(0,3).trim();
                //if(marker.equals("END")) break; //End of polygon
                npoints++;
                if(npoints>=limit){//expand array to fit
                    xtemp = xpoints;
                    ytemp = ypoints;
                    xpoints = new double[limit+grow];
                    ypoints = new double[limit+grow];
                    limit+=grow;
                    System.arraycopy(xtemp,0,xpoints,0,npoints);
                    System.arraycopy(ytemp,0,ypoints,0,npoints);
                }
                x = new Float(line.substring(4,18).trim()).floatValue();
                y = new Float(line.substring(19,line.length()).trim()).floatValue();
                xpoints[npoints]=x;
                ypoints[npoints]=y;
                
            }
            if(npoints<limit){//pack array down to size
                xtemp = xpoints;
                ytemp = ypoints;
                xpoints = new double[npoints];
                ypoints = new double[npoints];
                limit+=grow;
                System.arraycopy(xtemp,0,xpoints,0,npoints);
                System.arraycopy(ytemp,0,ypoints,0,npoints);
            }
            return new GeoPolygon(id,xcent,ycent,xpoints,ypoints,npoints);
        }
        catch(NumberFormatException e) {
            System.err.println("Invalid Polygon ID");
            return null;
            // Should throw a PolygonFormatException
            // When I work out how!
        }
    }
    
    /**
     * Reads all of the data from the InputStream and produces
     * a PolygonLayer.
     *
     * @return The assembled PolygonLayer.
     * @throws IOException Thrown if there are any errors whilst reading the file.
     */
    public final synchronized PolygonLayer readUngenerateFile() throws IOException {
        PolygonLayer map = new PolygonLayer();
        GeoPolygon poly;
        //System.out.println("Reading Map Data");
        while(true) {
            
            poly = readGeoPolygon();
            if (poly == null) break;
            //System.out.println("Adding Polygon");
            map.addGeoPolygon(poly);
            //System.out.println("Bounds "+map.getBounds());
        }
        //System.out.println("Read "+sequentialID+" polys");
        return map;
        //Need to add 'InvalidPolygon throwing
    }
    
    /**
     * Reads an attribute file of the form
     * id,value
     * nb. IDs <= 0 are skipped.
     * If this is a problem, a switch will be added.
     * @return Hash with IDs in keys and data in values.
     * @throws IOException Thrown if there are any errors whilst reading the file.
     */
    public final synchronized Hashtable readAttributes() throws IOException{
        //Hashtable t = new Table();
        Hashtable col = new Hashtable();
        StreamTokenizer st = new StreamTokenizer(this);
        st.eolIsSignificant(false);
        st.whitespaceChars(',',',');
        boolean done = false;
        
        while (!done) {
            int c = StreamTokenizer.TT_EOF;
            c = st.nextToken();
            switch (c) {
                case StreamTokenizer.TT_EOF:
                    done = true;
                    break;
                case StreamTokenizer.TT_NUMBER:
                    int id = (int)st.nval;
                    c = st.nextToken();
                    double value = (int)st.nval;
                    if(id > 0){
                        col.put(new Integer(id),new Double(value));
                    }
                    break;
            }
        }
        
        return col;
    }
    
    /**
     * Reads an attribute file of the form
     * id,value
     * nb. IDs <= 0 are skipped.
     * If this is a problem, a switch will be added.
     * @return GeoData containing all loaded values.
     * @throws IOException Thrown if there are any errors whilst reading the file.
     */
    public final synchronized GeoData readGeoData() throws IOException{
        //Hashtable t = new Table();
        //Vector store = new Vector();
        SimpleGeoData store = new SimpleGeoData();
        StreamTokenizer st = new StreamTokenizer(this);
        st.eolIsSignificant(false);
        st.whitespaceChars(',',',');
        boolean done = false;
        
        while (!done) {
            int c = StreamTokenizer.TT_EOF;
            c = st.nextToken();
            switch (c) {
                case StreamTokenizer.TT_EOF:
                    done = true;
                    break;
                case StreamTokenizer.TT_NUMBER:
                    int id = (int)st.nval;
                    c = st.nextToken();
                    if(c==StreamTokenizer.TT_NUMBER){
                        double value = (int)st.nval;
                        store.setValue(id,value);
                    }
                    else{
                        String text = st.sval;
                        store.setText(id,text);
                    }
                    
                    break;
            }
        }
        
        return store;
    }
    
    
    /**
     * Reads a circle file of the form
     * id,x,y,r
     * nb. IDs <= 0 are skipped.
     * If this is a problem, a switch will be added.
     * @return The assembled CircleLayer.
     * @throws IOException Thrown if there are any errors whilst reading the file.
     */
    public final synchronized CircleLayer readCircles() throws IOException{
        //Hashtable t = new Table();
        CircleLayer cl = new CircleLayer();
        double x,y,r;
        int id;
        StreamTokenizer st = new StreamTokenizer(this);
        st.eolIsSignificant(false);
        st.whitespaceChars(',',',');
        boolean done = false;
        
        while (!done) {
            int c = StreamTokenizer.TT_EOF;
            c = st.nextToken();
            switch (c) {
                case StreamTokenizer.TT_EOF:
                    done = true;
                    break;
                case StreamTokenizer.TT_NUMBER:
                    id = (int)st.nval;
                    st.nextToken();
                    x = (double)st.nval;
                    st.nextToken();
                    y = (double)st.nval;
                    st.nextToken();
                    r = (double)st.nval;
                    if(id > 0){
                        cl.addGeoCircle(new GeoCircle(id,x,y,r));
                    }
                    break;
            }
        }
        
        return cl;
    }
    
    /**
     *
     * Test function for specific application: should be removed.
     * @return Application-specific data.
     * @throws IOException Thrown if there are any errors whilst reading the file.
     * @deprecated Not needed.
     */
    public final synchronized Table readZdes() throws IOException{
        Table t = new Table();
        double value;
        
        StreamTokenizer st = new StreamTokenizer(this);
        st.eolIsSignificant(false);
        st.whitespaceChars(',',',');
        boolean done = false;
        st.nextToken();
        int zones = (int)st.nval;
        int j = 1;
        Hashtable col;
        while (!done) {
            j++;
            col = new Hashtable();
            st.nextToken();//skip outer polygon...
            for(int i = 1;i <zones && !done;i++){
                int c = StreamTokenizer.TT_EOF;
                c = st.nextToken();
                switch (c) {
                    case StreamTokenizer.TT_EOF:
                        done = true;
                        break;
                    case StreamTokenizer.TT_NUMBER:
                        //c = st.nextToken();
                        value = st.nval;
                        //System.out.print(""+value+",");
                        col.put(new Integer(i),new Double(value));
                        break;
                }
                
            }//for
            t.addCol(""+j+" zones",col);
            // System.out.println("adding "+j+" zones file");
        }
        
        return t;
    }
    
    
    
    /**
     * Reads a GeoPolygon.
     * If the ignoreIDs flag is set to true, sequential IDs will be used.
     * (Alternative optimized version).
     * @return The assembled PolygonLayer.
     * @throws IOException Thrown if there are any errors whilst reading the file.
     */
    public final synchronized PolygonLayer readUngenerateFile2() throws IOException {
        /**
         * Polygon ID
         */
        int id = 0;
        
        /**
         * The polygons Centroid
         */
        float xcent = 0;
        float ycent = 0;
        
        /**
         * Temp storage for each point as loaded
         */
        float x,y;
        double point[] = {0,0};
        
        int pair = 1;
        
        double header[] = {0,0,0};
        int headerSegment = 0;
        
        PolygonLayer map = new PolygonLayer();
        GeoPolygon poly = null;
        //System.out.println("Reading Map Data (Tokenized Method)");
        StreamTokenizer st = new StreamTokenizer(this);
        st.eolIsSignificant(true);
        boolean done = false;
        boolean readingHeader = true; //Polygon centroid header/Point data switch
        
        while (!done) {
            int c = StreamTokenizer.TT_EOF;
            try {
                c = st.nextToken();
            } catch (IOException e) {break; } //Out of while loop
            switch (c) {
                case StreamTokenizer.TT_EOF:
                    done = true;
                    break;
                case StreamTokenizer.TT_EOL:
                    if(readingHeader){
                        poly = new GeoPolygon(-99999,0,0);
                        readingHeader=false;
                        break;
                    }
                    else{
                        poly.addPoint(point[0],point[1]);
                        break;
                    }
                case StreamTokenizer.TT_WORD:
                    if(readingHeader){
                        done = true;
                        break;
                    }
                    readingHeader = true;
                    headerSegment = 0;
                    map.addGeoPolygon(poly);
                    break;
                case StreamTokenizer.TT_NUMBER:
                    if(readingHeader){
                        header[headerSegment] = st.nval;
                        headerSegment++;
                        if (headerSegment > 2){
                            poly = new GeoPolygon((int)header[0],(float)header[1],(float)header[2]);
                            readingHeader = false;
                        }
                    }
                    else {
                        point[pair-1] = st.nval;
                        pair = 3-pair; //alternates 1-2-1-2-1-2-1....
                    }
                    break;
            }
        }
        return map;
    }
}