import groovy.util.slurpersupport.GPathResult

/**
 * Created by IntelliJ IDEA.
 * User: sbortman
 * Date: May 16, 2009
 * Time: 7:36:25 PM
 * To change this template use File | Settings | File Templates.
 */

public class OmsInfoParser
{
  def dateUtil = new DateUtil()
  def additionalTags

  public def processRasterDataSets(GPathResult oms, Repository repository = null)
  {
    def rasterDataSets = []

    oms?.dataSets?.RasterDataSet.each {rasterDataSetNode ->

      def rasterDataSet = new RasterDataSet()

      rasterDataSetNode.fileObjects.RasterFile.each {rasterFileNode ->
        RasterFile rasterFile = initRasterFile(rasterFileNode)

        rasterDataSet.addToFileObjects(rasterFile)
      }

      rasterDataSetNode.rasterEntries.RasterEntry.each {rasterEntryNode ->
        RasterEntry rasterEntry = initRasterEntry(rasterEntryNode)

        if ( rasterEntry.groundGeom )
        {
          rasterDataSet.addToRasterEntries(rasterEntry)
        }
      }

      if ( rasterDataSet.rasterEntries )
      {
        rasterDataSets << rasterDataSet
        repository?.addToRasterDataSets(rasterDataSet)
      }
    }

    return rasterDataSets
  }

  public def processVideoDataSets(GPathResult oms, Repository repository = null)
  {
    def videoDataSets = []

    oms?.dataSets?.VideoDataSet.each {videoDataSetNode ->

      def videoDataSet = new VideoDataSet()

      videoDataSetNode.fileObjects.VideoFile.each {videoFileNode ->
        VideoFile videoFile = initVideoFile(videoFileNode)

        videoDataSet.addToFileObjects(videoFile)
      }

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


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

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

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

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

      repository?.addToVideoDataSets(videoDataSet)
      videoDataSets << videoDataSet
    }

    return videoDataSets
  }

  private VideoFile initVideoFile(videoFileNode)
  {
    def videoFile = new VideoFile()

    videoFile.name = videoFileNode.name
    videoFile.format = videoFileNode.@format
    videoFile.type = videoFileNode.@type
    return videoFile
  }


  private RasterEntry initRasterEntry(rasterEntryNode)
  {
    def rasterEntry = new RasterEntry()

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

    rasterEntry.groundGeom = initGroundGeom(rasterEntryNode)
    rasterEntry.acquisitionDate = initAcquisitionDate(rasterEntryNode)

    rasterEntryNode.fileObjects?.RasterEntryFile.each {rasterEntryFileNode ->
      RasterEntryFile rasterEntryFile = initRasterEntryFile(rasterEntryFileNode)

      rasterEntry.addToFileObjects(rasterEntryFile)
    }

    def metadataNode = rasterEntryNode.metadata

    initMetadataTags(metadataNode, rasterEntry)

    additionalTags?.each {k, v -> re1.addToMetadataTags(new MetadataTag(name: k, value: v)) }

    initMetadataXml(rasterEntry)

    return rasterEntry
  }

  private def initMetadataTags(metadataNode, rasterEntry)
  {
    metadataNode.tag.each {tagNode ->

      if ( tagNode.tag?.size() > 0 )
      {
        initMetadataTags(tagNode, rasterEntry)
      }
      else
      {
        MetadataTag metadataTag = initMetadataTag(tagNode)

        rasterEntry.addToMetadataTags(metadataTag)
      }
    }
  }

  private def initMetadataXml(rasterEntry)
  {
    def writer = new StringWriter()
    def metadataBuilder = new groovy.xml.MarkupBuilder(writer)

    metadataBuilder.metadata {
      rasterEntry?.metadataTags?.each {metadataTag ->
        def name = metadataTag.name.toLowerCase()
        def value = metadataTag.value

        "${name}"(value)

      }
    }

    def metadataXml = new MetadataXml()

    metadataXml.namevalue = writer.buffer
    rasterEntry?.addToMetadataXml(metadataXml)

    //println rasterEntry.metadataXml.data
  }

  private MetadataTag initMetadataTag(tagNode)
  {
    def metadataTag = new MetadataTag()

    metadataTag.name = tagNode.@name
    metadataTag.value = tagNode.toString()
    return metadataTag
  }

  private def initGroundGeom(rasterEntryNode)
  {
    def wkt = rasterEntryNode?.groundGeom?.toString().trim()
    def srs = rasterEntryNode?.groundGeom?.@srs?.toString().trim()
    def groundGeom = null

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

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

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

    }

    return groundGeom
  }

  private def initAcquisitionDate(rasterEntryNode)
  {
    def when = rasterEntryNode?.TimeStamp?.when

    return dateUtil.parseDate(when?.toString())
  }

  private RasterEntryFile initRasterEntryFile(rasterEntryFileNode)
  {
    def rasterEntryFile = new RasterEntryFile()

    rasterEntryFile.name = rasterEntryFileNode?.name
    rasterEntryFile.type = rasterEntryFileNode?.@type
    return rasterEntryFile
  }

  private RasterFile initRasterFile(rasterFileNode)
  {
    def rasterFile = new RasterFile()

    rasterFile.name = rasterFileNode.name
    rasterFile.format = rasterFileNode.@format
    rasterFile.type = rasterFileNode.@type
    return rasterFile
  }

}