/*
VisAD system for interactive analysis and visualization of numerical
data.  Copyright (C) 1996 - 2017 Bill Hibbard, Curtis Rueden, Tom
Rink, Dave Glowacki, Steve Emmerson, Tom Whittaker, Don Murray, and
Tommy Jasmin.

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Library General Public License for more details.

You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
MA 02111-1307, USA
*/

package visad.data.fits;

import nom.tam.fits.BadHeaderException;
import nom.tam.fits.BasicHDU;
import nom.tam.fits.BinaryTableHDU;
import nom.tam.fits.Data;
import nom.tam.fits.ExtensionHDU;
import nom.tam.fits.Fits;
import nom.tam.fits.FitsException;
import nom.tam.fits.ImageHDU;
import nom.tam.fits.PrimaryHDU;
import nom.tam.fits.RandomGroupsHDU;
import nom.tam.fits.TruncatedFileException;

import java.io.IOException;
import java.io.PrintStream;

import java.util.Date;

public class DumpHeader
{
  private static void dumpBasic(PrintStream ps, String indentStr,
				BasicHDU hdu)
  {
    int bitpix;
    try {
      bitpix = hdu.getBitPix();

      String bpName;
      switch (bitpix) {
      case BasicHDU.BITPIX_BYTE:
	bpName = "byte";
	break;
      case BasicHDU.BITPIX_SHORT:
	bpName = "short";
	break;
      case BasicHDU.BITPIX_INT:
	bpName = "int";
	break;
      case BasicHDU.BITPIX_FLOAT:
	bpName = "float";
	break;
      case BasicHDU.BITPIX_DOUBLE:
	bpName = "double";
	break;
      default:
	bpName = "?" + bitpix + '?';
	break;
      }
      ps.println(indentStr + "bitpix " + bpName);
    } catch (FitsException e) {
      ps.println(indentStr + "bitpix *** " + e.getMessage());
    }

    int[] axes;
    try {
      axes = hdu.getAxes();
    } catch (FitsException e) {
      System.err.println("Bad axes: " + e.getMessage());
      axes = null;
    }
    if (axes != null) {
      ps.print(indentStr + "axes ");
      for (int i = 0; i < axes.length; i++) {
	ps.print((i == 0 ? "" : "x") + axes[i]);
      }
      ps.println("");
    }

    int paramCount = hdu.getParameterCount();
    if (paramCount != 0) {
      ps.println(indentStr + "paramCount " + paramCount);
    }

    int groupCount = hdu.getGroupCount();
    if (groupCount != 1) {
      ps.println(indentStr + "groupCount " + groupCount);
    }

    double bzero = hdu.getBZero();
    if (bzero != 0.0) {
      ps.println(indentStr + "bzero " + bzero);
    }

    double bscale = hdu.getBScale();
    if (bscale != 1.0) {
      ps.println(indentStr + "bscale " + bscale);
    }

    String bunit = hdu.getBUnit();
    if (bunit != null) {
      ps.println(indentStr + "bunit " + bunit);
    }

    try {
      int blankValue = hdu.getBlankValue();
      ps.println(indentStr + "blank " + blankValue);
    } catch (FitsException e) {
    }

    Date creation = hdu.getCreationDate();
    if (creation != null) {
      ps.println(indentStr + "creation date " + creation);
    }

    Date observation = hdu.getObservationDate();
    if (observation != null) {
      ps.println(indentStr + "observation date " + observation);
    }

    String origin = hdu.getOrigin();
    if (origin != null) {
      ps.println(indentStr + "origin " + origin);
    }

    String telescope = hdu.getTelescope();
    if (telescope != null) {
      ps.println(indentStr + "telescope " + telescope);
    }

    String instrument = hdu.getInstrument();
    if (instrument != null) {
      ps.println(indentStr + "instrument " + instrument);
    }

    String observer = hdu.getObserver();
    if (observer != null) {
      ps.println(indentStr + "observer " + observer);
    }

    String object = hdu.getObject();
    if (object != null) {
      ps.println(indentStr + "object " + object);
    }

    double equinox = hdu.getEquinox();
    if (equinox != -1.0) {
      ps.println(indentStr + "equinox " + equinox);
    }

    String author = hdu.getAuthor();
    if (author != null) {
      ps.println(indentStr + "author " + author);
    }

    String reference = hdu.getReference();
    if (reference != null) {
      ps.println(indentStr + "reference " + reference);
    }

    double maxValue = hdu.getMaximumValue();
    if (maxValue != 0.0) {
      ps.println(indentStr + "maximum value " + maxValue);
    }

    double minValue = hdu.getMinimumValue();
    if (minValue != 0.0) {
      ps.println(indentStr + "minimum value " + minValue);
    }
  }

  private static void dumpPrimary(PrintStream ps, String indentStr,
				  PrimaryHDU hdu)
	throws IOException
  {
    dumpBasic(ps, indentStr, (BasicHDU )hdu);

    Data foo = hdu.getData();
  }

  private static void dumpBinaryTable(PrintStream ps, String indentStr,
				      BinaryTableHDU hdu)
  {
    int num = hdu.getNumColumns();
    if (num == 0) {
      ps.println(indentStr + "No columns");
      return;
    }

    for (int i = 0; i < num; i++) {
      String name, type;
      try {
	name = hdu.getColumnName(i);
	type = hdu.getColumnFITSType(i);
      } catch (FitsException e) {
	break;
      }

      ps.println(indentStr + i + ": " + name + " = " + type);
    }
  }

  private static void dumpExtension(PrintStream ps, String indentStr,
				    ExtensionHDU hdu)
	throws IOException
  {
    dumpBasic(ps, indentStr, (BasicHDU )hdu);

    String name = hdu.getExtensionName();
    if (name != null) {
      ps.println(indentStr + "name " + name);
    }

    int vers = hdu.getExtensionVersion();
    if (vers != 1) {
      ps.println(indentStr + "version " + vers);
    }

    int level = hdu.getExtensionLevel();
    if (level != 1) {
      ps.println(indentStr + "level " + level);
    }

    if (hdu instanceof BinaryTableHDU) {
      ps.println(indentStr + "Binary Table:");
      dumpBinaryTable(ps, indentStr + indentStr, (BinaryTableHDU )hdu);
    } else {
      try {
	String type = hdu.getExtensionType();
	if (type == null) {
	  ps.println(indentStr + "Null extension type");
	} else {
	  ps.println(indentStr + "type " + type);
	}
      } catch (FitsException e) {
	ps.println(indentStr + indentStr + "Bad extension type: " +
		   e.getMessage());
      }
    }

    Data foo = hdu.getData();
  }

  private static void dumpImage(PrintStream ps, String indentStr, ImageHDU hdu)
	throws IOException
  {
    dumpBasic(ps, indentStr, (BasicHDU )hdu);

    ps.println(indentStr + "...");

    Data foo = hdu.getData();
  }

  private static void dumpRandomGroups(PrintStream ps, String indentStr,
				       RandomGroupsHDU hdu)
	throws IOException
  {
    dumpBasic(ps, indentStr, (BasicHDU )hdu);

    ps.println(indentStr + "...");

    Data foo = hdu.getData();
  }

  public static void dump(PrintStream ps, String name)
	throws FitsException, IOException
  {
    Fits fits;
    try {
      fits = new Fits(name);
    } catch (FitsException e) {
      System.err.println("Couldn't open \"" + name + "\": " + e.getMessage());
      return;
    }

    ps.println(name + ':');

    BasicHDU hdu;
    for (int hduNum = 0; true; hduNum++) {
      try {
	hdu = fits.readHDU();
      } catch (OutOfMemoryError e) {
	System.err.println("  *** Out of memory for HDU #" + hduNum);
	e.printStackTrace(System.err);
	break;
      } catch (TruncatedFileException e) {
	System.err.println("  *** File truncated at HDU #" + hduNum + " (" + e.getMessage() + ")");
	break;
      } catch (IOException e) {
	System.err.println("  *** I/O error at HDU #" + hduNum + " (" + e.getMessage() + ")");
	break;
      } catch (BadHeaderException e) {
	System.err.println("  *** HDU #" + hduNum + " threw " + e.getMessage());
	continue;
      } catch (FitsException e) {
	System.err.println("  *** HDU #" + hduNum + " threw " + e.getMessage());
	continue;
      }

      if (hdu == null)  {
	break;
      }

      String indentStr = "\t";

      if (hdu instanceof PrimaryHDU) {
	if (hduNum == 0) {
	  ps.println(indentStr + "Primary:");
	} else {
	  ps.println(indentStr + "Primary " + hduNum + ':');
	}
	ps.flush();
	dumpPrimary(ps, indentStr + indentStr, (PrimaryHDU )hdu);
      } else if (hdu instanceof ExtensionHDU) {
	ps.println(indentStr + "Extension " + hduNum + ':');
	ps.flush();
	dumpExtension(ps, indentStr + indentStr, (ExtensionHDU )hdu);
      } else if (hdu instanceof ImageHDU) {
	ps.println(indentStr + "Image " + hduNum + ':');
	ps.flush();
	dumpImage(ps, indentStr + indentStr, (ImageHDU )hdu);
      } else if (hdu instanceof RandomGroupsHDU) {
	ps.println(indentStr + "RandomGroups " + hduNum + ':');
	ps.flush();
	dumpRandomGroups(ps, indentStr + indentStr, (RandomGroupsHDU )hdu);
      } else {
	throw new FitsException("Unknown header found: " + hdu);
      }
    }
  }

  public static void main(String[] args)
  {
    for (int i = 0; i < args.length; i++) {
      try {
	dump(System.out, args[i]);
      } catch (OutOfMemoryError e) {
	e.printStackTrace(System.out);
      } catch (FitsException e) {
	e.printStackTrace(System.out);
      } catch (IOException e) {
	e.printStackTrace(System.out);
      }
    }
  }
}