class OmsInfoParser
{
  DateUtil dateUtil = new DateUtil()


  def getMetadataTags(def node)
  {
    def tagList = []

    node.each {tag ->

      if ( tag.tag?.size() > 0 )
      {
        def subTagList = getMetadataTags(tag.tag)

        if ( subTagList )
          tagList.addAll(subTagList)
      }
      else
      {
        def metadataTag = new MetadataTag(name: "${tag.@name}", value: "${tag}")

        tagList << metadataTag
      }
    }

    return tagList
  }

  def getRasterFiles(def node)
  {
    node?.RasterFile?.collect {fileObject ->
      RasterFile rf1 = new RasterFile()

      rf1.name = fileObject?.name
      rf1.type = fileObject?.@type
      rf1.format = fileObject?.@format

      return rf1
    }
  }

  def getRasterEntryFiles(def node)
  {
    node?.RasterEntryFile?.collect {fileObject ->
      RasterEntryFile ref1 = new RasterEntryFile()

      ref1.name = fileObject?.name
      ref1.type = fileObject?.@type

      return ref1
    }
  }

  def getRasterEntries(def node)
  {
    node?.RasterEntry?.collect {rasterEntry ->

      RasterEntry re1 = new RasterEntry()

      re1.entryId = rasterEntry?.entryId
      re1.width = rasterEntry?.width?.toLong()
      re1.height = rasterEntry?.height?.toLong()
      re1.numberOfBands = rasterEntry?.numberOfBands?.toInteger()
      re1.bitDepth = rasterEntry?.bitDepth?.toInteger()
      re1.dataType = rasterEntry?.dataType

      /*
      re1.groundGeom = rasterEntry.groundGeom
      re1.srs = rasterEntry.groundGeom.@srs
      */

      def wkt = rasterEntry?.groundGeom?.toString().trim()
      def srs = rasterEntry?.groundGeom?.@srs?.toString().trim()

      if ( wkt && srs )
      {
        try
        {
          srs -= "epsg:"

          def geomString = "SRID=${srs};${wkt}"

          re1.groundGeom = Geometry.fromString(geomString)
        }
        catch (Exception e)
        {
          System.err.println("Cannt create geom for: srs=${srs} wkt=${wkt}")
        }
      }

      def when = rasterEntry?.TimeStamp?.when

      re1.acquisitionDate = dateUtil.parseDate(when?.toString())

      def fileObjects2 = getRasterEntryFiles(rasterEntry?.fileObjects)

      fileObjects2.each {x -> re1.addToFileObjects(x)}

      def metadataTags = getMetadataTags(rasterEntry?.metadata)

      metadataTags.each {y -> re1.addToMetadataTags(y) }

      //println re1

      return re1
    }

  }

  def getRasterDataSets(def node)
  {
    def rasterDataSets = node?.RasterDataSet?.collect {rasterDataSet ->

      def rds = new RasterDataSet()

      def fileObjects = getRasterFiles(rasterDataSet?.fileObjects)

      fileObjects.each {x -> rds.addToFileObjects(x)}

      def rasterEntries = getRasterEntries(rasterDataSet?.rasterEntries)

      rasterEntries.each {z -> rds.addToRasterEntries(z) }

      //println rds

      return rds
    }

    return rasterDataSets
  }

  def parseRasterDataSets(String data)
  {
    def oms = new XmlSlurper().parseText(data)
    def rasterDataSets = getRasterDataSets(oms?.dataSets)


    return rasterDataSets
  }

  def parseVideoDataSets(String data)
  {
    def oms = new XmlSlurper().parseText(data)

    def videoDataSets = oms?.dataSets?.VideoDataSet?.collect {videoDataSet ->
      def vds = new VideoDataSet()

      vds.width = videoDataSet?.width?.toLong()
      vds.height = videoDataSet?.height?.toLong()


      def start = videoDataSet?.TimeSpan?.begin?.toString()
      def end = videoDataSet?.TimeSpan?.end?.toString()

      vds.startDate = dateUtil.parseDate(start)
      vds.endDate = dateUtil.parseDate(end)

      def srs = videoDataSet?.groundGeom?.@srs?.toString() - "epsg:"
      def wkt = videoDataSet?.groundGeom

      if ( srs && wkt )
      {
        vds.groundGeom = Geometry.fromString("SRID=${srs};${wkt}")
      }

      videoDataSet?.fileObjects?.VideoFile?.each {videoFile ->

        def vf = new VideoFile()

        vf.type = videoFile?.@type
        vf.format = videoFile?.@format
        vf.name = videoFile?.name
        vds.addToFileObjects(vf)
      }

      return vds
    }

    return videoDataSets
  }

  public static void main(String[] args)
  {
    if ( !args )
      args = ["sample.xml"] as String[]

    def parser = new OmsInfoParser()

    for ( arg in args )
    {
      def data = new File(arg).text

      println data

      def rasterDataSet = parser.parseOmsInfo(data)

      println rasterDataSet[0].rasterEntries[0].srs
      println rasterDataSet[0].rasterEntries[0].groundGeom
    }
  }
}