* Copyright 1998-2009 University Corporation for Atmospheric Research/Unidata

*

* Portions of this software were developed by the Unidata Program at the

* University Corporation for Atmospheric Research.

*

* Access and use of this software shall impose the following obligations

* and understandings on the user. The user is granted the right, without

* any fee or cost, to use, copy, modify, alter, enhance and distribute

* this software, and any derivative works thereof, and its supporting

* documentation for any purpose whatsoever, provided that this entire

* notice appears in all copies of the software, derivative works and

* supporting documentation.  Further, UCAR requests that the user credit

* UCAR/Unidata in any publications that result from the use of this

* software or in any product that includes this software. The names UCAR

* and/or Unidata, however, may not be used in any advertising or publicity

* to endorse or promote any products or commercial entity unless specific

* written permission is obtained from UCAR/Unidata. The user also

* understands that UCAR/Unidata is not obligated to provide the user with

* any support, consulting, training or assistance of any kind with regard

* to the use, operation and performance of this software nor to provide

* the user with any updates, revisions, new versions or "bug fixes."

*

* THIS SOFTWARE IS PROVIDED BY UCAR/UNIDATA "AS IS" AND ANY EXPRESS OR

* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

* DISCLAIMED. IN NO EVENT SHALL UCAR/UNIDATA BE LIABLE FOR ANY SPECIAL,

* INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING

* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,

* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION

* WITH THE ACCESS, USE OR PERFORMANCE OF THIS SOFTWARE.

*/

* NMC Office Note 29

*

* @author caron

* @since Feb 22, 2008

*/

  static private org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(NmcObsLegacy.class);

  private RandomAccessFile raf;

  private NetcdfFile ncfile;

  //private Structure reportVar;

  private List<Station> stations = new ArrayList<Station>();

  private List<Report> reports  = new ArrayList<Report>();

  //private Map<String, List<Report>> map = new HashMap<String, List<Report>>();

  //private List<String> stations;

  // private int nobs = 0, nstations = 0;

  private Calendar cal = null;

  private DateFormatter dateFormatter = new DateFormatter();

  private Date refDate; // from the header

  private String refString; // debug

  private List<StructureCode> catStructures = new ArrayList<StructureCode>(10);

  private boolean showObs = false, showSkip = false, showOverflow = false, showData = false,

      showHeader = false, showTime = false;

  private boolean readData = false, summarizeData = false, showTimes = false;

  private boolean checkType = false, checkSort = false, checkPositions = false;

  public boolean isValidFile(RandomAccessFile raf) throws IOException {

    raf.seek(0);

    if (raf.length() < 60) return false;

    byte[] h = raf.readBytes(60);

    // 32 - 56 are X's

    for (int i = 32; i < 56; i++)

      if (h[i] != (byte) 'X') return false;

    try {

      short hour = Short.parseShort(new String(h, 0, 2));

      short minute = Short.parseShort(new String(h, 2, 2));

      short year = Short.parseShort(new String(h, 4, 2));

      short month = Short.parseShort(new String(h, 6, 2));

      short day = Short.parseShort(new String(h, 8, 2));

      if ((hour < 0) || (hour > 24)) return false;

      if ((minute < 0) || (minute > 60)) return false;

      if ((year < 0) || (year > 100)) return false;

      if ((month < 0) || (month > 12)) return false;

      if ((day < 0) || (day > 31)) return false;

    } catch (Exception e) {

      return false;

    }

    return true;

  }

    public String getFileTypeId() {

      return "NMCon29";

    }

    public String getFileTypeDescription() {

      return "NMC Office Note 29";

    }

  public void open(RandomAccessFile raf, NetcdfFile ncfile, CancelTask cancelTask) throws IOException {

    this.raf = raf;

    this.ncfile = ncfile;

    init();

    ncfile.addAttribute(null, new Attribute("history", "Direct read of NMC ON29 by CDM"));

    ncfile.addAttribute(null, new Attribute("Conventions", "Unidata"));

    ncfile.addAttribute(null, new Attribute("cdm_data_type", FeatureType.STATION_PROFILE.toString()));

    try {

      ncfile.addDimension(null, new Dimension("station", stations.size()));

      Structure station = makeStationStructure();

      ncfile.addVariable(null, station);

      ncfile.addDimension(null, new Dimension("report", reports.size()));

      Structure reportIndexVar = makeReportIndexStructure();

      ncfile.addVariable(null, reportIndexVar);

      Structure reportVar = makeReportStructure();

      ncfile.addVariable(null, reportVar);

    } catch (InvalidRangeException e) {

      log.error("open ON29 File", e);

      throw new IllegalStateException(e.getMessage());

    }

  }

  public void close() throws IOException {

    raf.close();

  }

  public Array readData(Variable v, Section section) throws IOException, InvalidRangeException {

    if (v.getShortName().equals("station"))

      return readStation(v, section);

    else if (v.getShortName().equals("report"))

      return readReport(v, section);

    else if (v.getShortName().equals("reportIndex"))

      return readReportIndex(v, section);

    throw new IllegalArgumentException("Unknown variable name= "+v.getShortName());

  }

  ///////////////////////////////////////////////////////////////////////////////////

  private Structure makeStationStructure() throws IOException, InvalidRangeException {

    Structure station = new Structure(ncfile, null, null, "station");

    station.setDimensions("station");

    station.addAttribute(new Attribute("long_name", "unique stations within this file"));

    int pos = 0;

    Variable v = station.addMemberVariable(new Variable(ncfile, null, station, "stationName", DataType.CHAR, ""));

    v.setDimensionsAnonymous(new int[]{6});

    v.addAttribute(new Attribute("long_name", "name of station"));

    v.addAttribute(new Attribute("standard_name", "station_name"));

    v.setSPobject(new Vinfo(pos));

    pos += 6;

    v = station.addMemberVariable(new Variable(ncfile, null, station, "lat", DataType.FLOAT, ""));

    v.addAttribute(new Attribute("units", "degrees_north"));

    v.addAttribute(new Attribute("long_name", "geographic latitude"));

    v.addAttribute(new Attribute("accuracy", "degree/100"));

    v.addAttribute(new Attribute(_Coordinate.AxisType, AxisType.Lat.toString()));

    v.setSPobject(new Vinfo(pos));

    pos += 4;

    v = station.addMemberVariable(new Variable(ncfile, null, station, "lon", DataType.FLOAT, ""));

    v.addAttribute(new Attribute("units", "degrees_east"));

    v.addAttribute(new Attribute("long_name", "geographic longitude"));

    v.addAttribute(new Attribute("accuracy", "degree/100"));

    v.addAttribute(new Attribute(_Coordinate.AxisType, AxisType.Lon.toString()));

    v.setSPobject(new Vinfo(pos));

    pos += 4;

    v = station.addMemberVariable(new Variable(ncfile, null, station, "elev", DataType.FLOAT, ""));

    v.addAttribute(new Attribute("units", "meters"));

    v.addAttribute(new Attribute("long_name", "station elevation above MSL"));

    v.addAttribute(new Attribute(_Coordinate.AxisType, AxisType.Height.toString()));

    v.setSPobject(new Vinfo(pos));

    pos += 4;

    v = station.addMemberVariable(new Variable(ncfile, null, station, "nrecords", DataType.INT, ""));

    v.addAttribute(new Attribute("long_name", "number of records"));

    v.addAttribute(new Attribute("standard_name", "npts"));

    v.setSPobject(new Vinfo(pos));

    pos += 4;

    return station;

  }

  private Structure makeReportIndexStructure() throws InvalidRangeException, IOException {

    Structure reportIndex = new Structure(ncfile, null, null, "reportIndex");

    reportIndex.setDimensions("report");

    reportIndex.addAttribute(new Attribute("long_name", "index on report - in memory"));

    int pos = 0;

    Variable v = reportIndex.addMemberVariable(new Variable(ncfile, null, reportIndex, "stationName", DataType.CHAR, ""));

    v.setDimensionsAnonymous(new int[]{6});

    v.addAttribute(new Attribute("long_name", "name of station"));

    v.addAttribute(new Attribute("standard_name", "station_name"));

    v.setSPobject(new Vinfo(pos));

    pos += 6;

    v = reportIndex.addMemberVariable(new Variable(ncfile, null, reportIndex, "time", DataType.INT, ""));

    v.addAttribute(new Attribute("units", "secs since 1970-01-01 00:00"));

    v.addAttribute(new Attribute("long_name", "observation time"));

    v.setSPobject(new Vinfo(pos));                

    pos += 4;

    return reportIndex;

  }

  private Structure makeReportStructure() throws InvalidRangeException, IOException {

    Structure report = new Structure(ncfile, null, null, "report");

    report.setDimensions("report");

    report.addAttribute(new Attribute("long_name", "ON29 observation report"));

    int pos = 0;

    Variable v = report.addMemberVariable(new Variable(ncfile, null, report, "time", DataType.INT, ""));

    v.addAttribute(new Attribute("units", "secs since 1970-01-01 00:00"));

    v.addAttribute(new Attribute("long_name", "observation time"));

    v.addAttribute(new Attribute(_Coordinate.AxisType, AxisType.Time.toString()));

    v.setSPobject(new Vinfo(pos));

    pos += 4;

    v = report.addMemberVariable(new Variable(ncfile, null, report, "timeISO", DataType.CHAR, ""));

    v.setDimensionsAnonymous(new int[]{20});

    v.addAttribute(new Attribute("long_name", "ISO formatted date/time"));

    v.setSPobject(new Vinfo(pos));

    pos += 20;

    v = report.addMemberVariable(new Variable(ncfile, null, report, "reportType", DataType.SHORT, ""));

    v.addAttribute(new Attribute("long_name", "report type from Table R.1"));

    v.setSPobject(new Vinfo(pos));

    pos += 2;

    // only for ON29

    v = report.addMemberVariable(new Variable(ncfile, null, report, "instType", DataType.SHORT, ""));

    v.addAttribute(new Attribute("long_name", "instrument type from Table R.2"));

    v.setSPobject(new Vinfo(pos));

    pos += 2;

    v = report.addMemberVariable(new Variable(ncfile, null, report, "reserved", DataType.CHAR, ""));

    v.setDimensionsAnonymous(new int[]{7});

    v.addAttribute(new Attribute("long_name", "reserved characters"));

    v.setSPobject(new Vinfo(pos));

    pos += 7;

    List<Record> records = firstReport.readData(); // for the moment, we will use the first report as the exemplar

    pos = makeInnerSequence(report, records, 1, pos);

    pos = makeInnerSequence(report, records, 2, pos);

    pos = makeInnerSequence(report, records, 3, pos);

    pos = makeInnerSequence(report, records, 4, pos);

    pos = makeInnerSequence(report, records, 5, pos);

    pos = makeInnerSequence(report, records, 7, pos);

    pos = makeInnerSequence(report, records, 8, pos);

    pos = makeInnerSequence(report, records, 51, pos);

    pos = makeInnerSequence(report, records, 52, pos);

    report.calcElementSize(); // recalc since we added new members

    return report;

  }

  private int makeInnerSequence( Structure reportVar, List<Record> records, int code, int obs_pos) throws InvalidRangeException {

    for (Record record : records) {

      if (record.code == code) {

        Entry first = record.entries[0];

        Structure s = first.makeStructure(reportVar);

        s.setSPobject(new Vinfo(obs_pos));

        obs_pos += 4;

        reportVar.addMemberVariable(s);

        catStructures.add(new StructureCode(s, code));

        break;

      }

    }

    return obs_pos;

  }

  private class Vinfo {

    int offset;

    Vinfo(int offset) {

      this.offset = offset;

    }

  }

  private class StructureCode {

    Structure s;

    int code;

    StructureCode(Structure s, int code) {

      this.s = s;

      this.code = code;

    }

  }

  /////////////////////////////////////////////////////////////

  private Array readStation(Variable v, Section section) throws IOException, InvalidRangeException {

    Structure s = (Structure) v;

    StructureMembers members = s.makeStructureMembers();

    for (Variable v2 : s.getVariables()) {

      Vinfo vinfo = (Vinfo) v2.getSPobject();

      StructureMembers.Member m = members.findMember(v2.getShortName());

      if (vinfo != null) {

        m.setDataParam(vinfo.offset);

        //m.setVariableInfo( vinfo.size);

      }

    }

    int size = (int) section.computeSize();

    ArrayStructureBB abb = new ArrayStructureBB(members, new int[]{size});

    ByteBuffer bb = abb.getByteBuffer();

    Range r = section.getRange(0);

    for (int i = r.first(); i <= r.last(); i += r.stride()) {

      Station station = stations.get(i);

      bb.put(station.r.stationId.getBytes());

      bb.putFloat(station.r.lat);

      bb.putFloat(station.r.lon);

      bb.putFloat(station.r.elevMeters);

      bb.putInt(station.nreports);

    }

    return abb;

  }

   public Array readReportIndex(Variable v, Section section) throws IOException, InvalidRangeException {

    Structure s = (Structure) v;

    StructureMembers members = s.makeStructureMembers();

    for (Variable v2 : s.getVariables()) {

      Vinfo vinfo = (Vinfo) v2.getSPobject();

      StructureMembers.Member m = members.findMember(v2.getShortName());

      m.setDataParam(vinfo.offset);

    }

    int size = (int) section.computeSize();

    ArrayStructureBB abb = new ArrayStructureBB(members, new int[]{size});

    ByteBuffer bb = abb.getByteBuffer();

    Range r = section.getRange(0);

    for (int i = r.first(); i <= r.last(); i += r.stride()) {

      Report report = reports.get(i);

      report.loadIndexData(bb);

    }

    return abb;

  }

  public Array readReport(Variable v, Section section) throws IOException, InvalidRangeException {

    Structure s = (Structure) v;

    StructureMembers members = s.makeStructureMembers();

    for (Variable v2 : s.getVariables()) {

      Vinfo vinfo = (Vinfo) v2.getSPobject();

      StructureMembers.Member m = members.findMember(v2.getShortName());

      m.setDataParam(vinfo.offset);

    }

    int size = (int) section.computeSize();

    ArrayStructureBB abb = new ArrayStructureBB(members, new int[]{size});

    ByteBuffer bb = abb.getByteBuffer();

    Range r = section.getRange(0);

    for (int i = r.first(); i <= r.last(); i += r.stride()) {

      Report report = reports.get(i);

      report.loadStructureData(abb, bb);

    }

    return abb;

  }

  /* private class ReportIterator implements StructureDataIterator {

    List<Report> reports;

    Iterator<Report> iter;

    StructureMembers members;

    ReportIterator(List<Report> reports) {

      this.reports = reports;

      iter = reports.iterator();

      members = reportVar.makeStructureMembers();

      for (Variable v2 : reportVar.getVariables()) {

        Vinfo vinfo = (Vinfo) v2.getSPobject();

        StructureMembers.Member m = members.findMember(v2.getShortName());

        m.setDataParam(vinfo.offset);

      }

    }

    public boolean hasNext() throws IOException {

      return iter.hasNext();

    }

    public StructureData next() throws IOException {

      Report r = iter.next();

      // LOOK should optimize - read 10 at a time or something ???

      ArrayStructureBB abb = new ArrayStructureBB(members, new int[]{1});

      ByteBuffer bb = abb.getByteBuffer();

      bb.position(0);

      r.loadStructureData(abb, bb);

      return abb.getStructureData(0);

    }

    public void setBufferSize(int bytes) {

    }

    public StructureDataIterator reset() {

      iter = reports.iterator();

      return this;

    }

  } */

  private Report firstReport = null;

  private void init() throws IOException {

    int badPos = 0;

    int badType = 0;

    short firstType = -1;

    raf.seek(0);

    readHeader(raf);

    // read through all the reports, construct unique stations

    Map<String,Station> map = new HashMap<String,Station>();

    while (true) {

      Report report = new Report();

      if (!report.readId(raf)) break;

      if (firstReport == null) {

        firstReport = report;

        firstType = firstReport.reportType;

      }

      if (checkType && (report.reportType != firstType)) {

        System.out.println(report.stationId + " type: " + report.reportType + " not " + firstType);

        badType++;

      }

      Station stn = map.get(report.stationId);

      if (stn == null) {

        stn = new Station(report);

        map.put(report.stationId, stn);

        stations.add( stn);

      } else {

        stn.nreports++;

        if (checkPositions) {

          Report first = reports.get(0);

          if (first.lat != report.lat) {

            System.out.println(report.stationId + " lat: " + first.lat + " !=" + report.lat);

            badPos++;

          }

          if (first.lon != report.lon)

            System.out.println(report.stationId + " lon: " + first.lon + " !=" + report.lon);

          if (first.elevMeters != report.elevMeters)

            System.out.println(report.stationId + " elev: " + first.elevMeters + " !=" + report.elevMeters);

        }

      }

      reports.add(report);

    }

    Collections.sort(stations);

    if (checkPositions)

      System.out.println("\nnon matching lats= " + badPos);

    if (checkType)

      System.out.println("\nnon matching reportTypes= " + badType);

    //System.out.println(firstReport);

    //firstReport.show();

    //firstReport.readData();

    /* Set<String> keys = map.keySet();

    if (showTimes || readData || checkSort) {

      int unsorted = 0;

      for (String key : keys) {

        List<Report> reports = map.get(key);

        if (showTimes) System.out.print("Station " + key + ": ");

        if (summarizeData) System.out.println("Station " + key + " :");

        Report last = null;

        for (Report r : reports) {

          if ((last != null) && last.date.after(r.date)) {

            System.out.println("***NOT ORDERED " + key +

                " last=" + dateFormatter.toDateTimeStringISO(last.date) + "(" + last.filePos + ")" +

                " next =" + dateFormatter.toDateTimeStringISO(r.date) + "(" + r.filePos + ")");

            unsorted++;

          }

          last = r;

          if (showTimes) System.out.print(dateFormatter.toDateTimeStringISO(r.date) + " ");

          if (readData || summarizeData) {

            List<Record> cats = r.readData();

            if (summarizeData) {

              System.out.print("  " + r.obsTime + ": (");

              for (Record cat : cats)

                System.out.print(cat.code + "/" + cat.nlevels + " ");

              System.out.println(")");

            }

          }

        }

        if (showTimes) System.out.println();

      }

      if (checkSort)

        System.out.println("\nunsorted= " + unsorted);

    }

    nstations = keys.size(); */

    // System.out.println("\nnreports= " + reports.size() + " nstations= " + stations.size());

  }

  private class Station implements Comparable<Station> {

    String name;

    Report r;

    int nreports;

    Station(Report r) {

      this.name = r.stationId;

      this.r = r;

      this.nreports=1;

    }

    public int compareTo(Station o) {

      return name.compareTo(o.name);

    }

  }

  private class Report {

    float lat, lon, elevMeters;

    String stationId;

    byte[] reserved = new byte[7];

    short reportType, instType, obsTime;

    int reportLen;

    long filePos;

    Date date;

    String rString; // refString, for debugging

    boolean readId(RandomAccessFile raf) throws IOException {

      filePos = raf.getFilePointer();

      byte[] reportId = raf.readBytes(40);

      String latS = new String(reportId, 0, 5);

      if (latS.equals("END R")) {

        raf.skipBytes(-40);

        endRecord(raf);

        filePos = raf.getFilePointer();

        reportId = raf.readBytes(40);

        latS = new String(reportId, 0, 5);

      }

      if (latS.equals("ENDOF")) {

        raf.skipBytes(-40);

        if (!endFile(raf)) return false;

        filePos = raf.getFilePointer();

        reportId = raf.readBytes(40);

        latS = new String(reportId, 0, 5);

      }

      //System.out.println("ReportId start at " + start);

      try {

        lat = (float) (.01 * Float.parseFloat(latS));

        lon = (float) (360.0 - .01 * Float.parseFloat(new String(reportId, 5, 5)));

        stationId = new String(reportId, 10, 6);

        obsTime = Short.parseShort(new String(reportId, 16, 4));

        System.arraycopy(reportId, 20, reserved, 0, 7);

        reportType = Short.parseShort(new String(reportId, 27, 3));

        elevMeters = Float.parseFloat(new String(reportId, 30, 5));

        instType = Short.parseShort(new String(reportId, 35, 2));

        reportLen = 10 * Integer.parseInt(new String(reportId, 37, 3));

        cal.setTime(refDate);

        int hour = cal.get(Calendar.HOUR_OF_DAY);

        if (obsTime / 100 > hour + 4) // if greater than 4 hours from reference time

          cal.add(Calendar.DAY_OF_MONTH, -1); // subtract a day LOOK

        cal.set(Calendar.HOUR_OF_DAY, obsTime / 100);

        cal.set(Calendar.MINUTE, 6 * (obsTime % 100));

        date = cal.getTime();

        rString = refString; // temp debugg

        if (showObs) System.out.println(this);

        else if (showTime) System.out.print("  time=" + obsTime + " date= " + dateFormatter.toDateTimeString(date));

        //nobs++;

        raf.skipBytes(reportLen - 40);

        return reportLen < 30000;

      } catch (Exception e) {

        System.out.println("BAD reportId=" + new String(reportId));

        System.out.println("ReportId start at " + filePos);

        e.printStackTrace();

        System.exit(1);

        return false;

      }

    }

    public String toString() {

      return "Report " + " stationId=" + stationId + " lat=" + lat + " lon=" + lon +

          " obsTime=" + obsTime + " date= " + dateFormatter.toDateTimeStringISO(date) +

          " reportType=" + reportType + " elevMeters=" + elevMeters + " instType=" + instType + " reserved=" + new String(reserved) +

          " start=" + filePos + " reportLen=" + reportLen;

    }

    // heres where the data for this Report is read into memory

    List<Record> readData() throws IOException {

      List<Record> records = new ArrayList<Record>();

      raf.seek(filePos + 40);

      byte[] b = raf.readBytes(reportLen - 40);

      if (showData) System.out.println("\n" + new String(b));

      if (showData) System.out.println(this);

      int offset = 0;

      while (true) {

        Record record = new Record();

        offset = record.read(b, offset);

        records.add(record);

        if (record.next >= reportLen / 10) break;

      }

      return records;

    }

    void show(RandomAccessFile raf) throws IOException {

      raf.seek(filePos);

      byte[] b = raf.readBytes(40);

      System.out.println(new String(b));

    }

    void loadIndexData(ByteBuffer bb) throws IOException {

      bb.put(stationId.getBytes());

      bb.putInt((int) (date.getTime() / 1000));

    }

    void loadStructureData(ArrayStructureBB abb, ByteBuffer bb) throws IOException {

      bb.putInt((int) (date.getTime() / 1000));

      bb.put(dateFormatter.toDateTimeStringISO(date).getBytes());

      bb.putShort(reportType);

      bb.putShort(instType);

      bb.put(reserved);

      List<Record> records = readData();

      for (StructureCode sc : catStructures)

        loadInnerSequence(abb, bb, records, sc.s, sc.code);

    }

    private void loadInnerSequence(ArrayStructureBB abb, ByteBuffer bb, List<Record> records, Structure useStructure, int code) {

      for (Record record : records) {

        if (record.code == code) {

          CatIterator iter = new CatIterator(record.entries, useStructure);

          ArraySequence seq = new ArraySequence(iter.members, iter, record.entries.length);

          int index = abb.addObjectToHeap(seq);

          bb.putInt(index);

          return;

        }

      }

      // need an empty one

      CatIterator iter = new CatIterator(new Entry[0], useStructure);

      ArraySequence seq = new ArraySequence(iter.members, iter, -1); // ??

      int index = abb.addObjectToHeap(seq);

      bb.putInt(index);

    }

    private class CatIterator implements StructureDataIterator {

      Entry[] entries;

      int count = 0;

      StructureMembers members;

      CatIterator(Entry[] entries, Structure useStructure) {

        this.entries = entries;

        members = useStructure.makeStructureMembers();

        for (Variable v2 : useStructure.getVariables()) {

          Vinfo vinfo = (Vinfo) v2.getSPobject();

          StructureMembers.Member m = members.findMember(v2.getShortName());

          m.setDataParam(vinfo.offset);

        }

      }

      @Override

      public boolean hasNext() throws IOException {

        return count < entries.length;

      }

      @Override

      public StructureData next() throws IOException {

        Entry entry = entries[count++];

        // LOOK should read 10 at a time or something ???

        ArrayStructureBB abb = new ArrayStructureBB(members, new int[]{1});

        ByteBuffer bb = abb.getByteBuffer();

        bb.position(0);

        entry.loadStructureData(bb);

        return abb.getStructureData(0);

      }

      @Override

      public void setBufferSize(int bytes) {

      }

      @Override

      public StructureDataIterator reset() {

        count = 0;

        return this;

      }

      @Override

      public int getCurrentRecno() {

        return count - 1;

      }

    }

  }

  // a record has a variable number of entries, which are all of one "category" type

  private class Record {

    int code, next, nlevels, nbytes;

    Entry[] entries;

    int read(byte[] b, int offset) throws IOException {

      code = Integer.parseInt(new String(b, offset, 2));

      next = Integer.parseInt(new String(b, offset + 2, 3));

      nlevels = Integer.parseInt(new String(b, offset + 5, 2));

      nbytes = readIntWithOverflow(b, offset + 7, 3);

      if (showData) System.out.println("\n" + this);

      offset += 10;

      if (code == 1) {

        if (showData) System.out.println(catNames[1] + ":");

        entries = new Cat01[nlevels];

        for (int i = 0; i < nlevels; i++) {

          entries[i] = new Cat01(b, offset, i);

          if (showData) System.out.println(" " + i + ": " + entries[i]);

          offset += 22;

        }

      } else if (code == 2) {

        if (showData) System.out.println(catNames[2] + ":");

        entries = new Cat02[nlevels];

        for (int i = 0; i < nlevels; i++) {

          entries[i] = new Cat02(b, offset);

          if (showData) System.out.println(" " + i + ": " + entries[i]);

          offset += 15;

        }

      } else if (code == 3) {

        if (showData) System.out.println(catNames[3] + ":");

        entries = new Cat03[nlevels];

        for (int i = 0; i < nlevels; i++) {

          entries[i] = new Cat03(b, offset);

          if (showData) System.out.println(" " + i + ": " + entries[i]);

          offset += 13;

        }

      } else if (code == 4) {

        if (showData) System.out.println(catNames[4] + ":");

        entries = new Cat04[nlevels];

        for (int i = 0; i < nlevels; i++) {

          entries[i] = new Cat04(b, offset);

          if (showData) System.out.println(" " + i + ": " + entries[i]);

          offset += 13;

        }

      } else if (code == 5) {

        if (showData) System.out.println(catNames[5] + ":");

        entries = new Cat05[nlevels];

        for (int i = 0; i < nlevels; i++) {

          entries[i] = new Cat05(b, offset);

          if (showData) System.out.println(" " + i + ": " + entries[i]);

          offset += 22;

        }

      } else if (code == 7) {

        if (showData) System.out.println(catNames[7] + ":");

        entries = new Cat07[nlevels];

        for (int i = 0; i < nlevels; i++) {

          entries[i] = new Cat07(b, offset);

          if (showData) System.out.println(" " + i + ": " + entries[i]);

          offset += 10;

        }

      } else if (code == 8) {

        if (showData) System.out.println(catNames[8] + ":");

        entries = new Cat08[nlevels];

        for (int i = 0; i < nlevels; i++) {

          entries[i] = new Cat08(b, offset);

          if (showData) System.out.println(" " + i + ": " + entries[i]);

          offset += 10;

        }

      } else if (code == 51) {

        if (showData) System.out.println(catNames[10] + ":");

        entries = new Cat51[nlevels];

        for (int i = 0; i < nlevels; i++) {

          entries[i] = new Cat51(b, offset);

          if (showData) System.out.println(" " + i + ": " + entries[i]);

          offset += 60;

        }

      } else if (code == 52) {

        if (showData) System.out.println(catNames[10] + ":");

        entries = new Cat52[nlevels];

        for (int i = 0; i < nlevels; i++) {

          entries[i] = new Cat52(b, offset);

          if (showData) System.out.println(" " + i + ": " + entries[i]);

          offset += 40;

        }

      } else {

        throw new UnsupportedOperationException("code= " + code);

      }

      // must be multiple of 10

      int skip = offset % 10;

      if (skip > 0)

        offset += (10 - skip);

      return offset;

    }

    public String toString() {

      return "Category/Group " + " code=" + code + " next= " + next + " nlevels=" + nlevels + " nbytes=" + nbytes;

    }

  }

  private int readIntWithOverflow(byte[] b, int offset, int len) {

    String s = new String(b, offset, len);

    try {

      return Integer.parseInt(s);

    } catch (Exception e) {

      if (showOverflow) System.out.println("OVERFLOW=" + s);

      return 0;

    }

  }

  private String[] catNames = new String[]{"",

      "Category 01: mandatory constant-pressure data",

      "Category 02: temperature/dewpoint at variable pressure-levels ",

      "Category 03: wind at variable pressure-levels ",

      "Category 04: wind at variable height-levels ",

      "Category 05: tropopause data", "",

      "Category 07: cloud cover",

      "Category 08: additional data", "", "",

      "Category 51: surface Data",

      "Category 52: ship surface Data"};

  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  private static float[] mandPressureLevel = new float[]{1000, 850, 700, 500, 400, 300, 250, 200, 150, 100,

      70, 50, 30, 20, 10, 7, 5, 3, 2, 1};

  private abstract class Entry {

    abstract Structure makeStructure(Structure parent) throws InvalidRangeException;

    abstract void loadStructureData(ByteBuffer bb);

  }

  private class Cat01 extends Entry {

    short windDir, windSpeed;

    float geopot, press, temp, dewp;

    byte[] quality = new byte[4];

    Cat01(byte[] b, int offset, int level) throws IOException {