import joms.oms.DataInfo
import joms.oms.ImageStager

import joms.oms.Init
import org.codehaus.groovy.grails.plugins.DomainClassGrailsPlugin

class Stager
{
  def count = 0
  def dataInfo = new DataInfo()
  def imageStager = new ImageStager()
  def omsInfoParser = new OmsInfoParser()
  def stagerHandler
  def repository
  def sessionFactory
  def dataSource


  public Stager()
  {
  }

  public Stager(def repository)
  {
    this.repository = repository
    stagerHandler = new StagerHandler("logs", "repository-${repository.id}")
  }

  def getImageInfo(File file)
  {
    def status = dataInfo.open(file.absolutePath)

    if ( status )
    {
      def xml = dataInfo.getInfo()?.trim()
      dataInfo.close()

      if ( xml )
      {
        def oms = new XmlSlurper().parseText(xml)
        def rasterDataSets = omsInfoParser.processRasterDataSets(oms)
        def videoDataSets = omsInfoParser.processVideoDataSets(oms)

        //Repository.withTransaction {tx ->
        //def parent = Repository.findByBaseDir(repository.baseDir)

        rasterDataSets.each {rasterDataSet ->
          //parent.addToRasterDataSets(rasterDataSet)
          rasterDataSet.repository = repository

          // Scottie:  HACK!!!
          createHistogramsAndOverviews(rasterDataSet)

          if ( rasterDataSet.save() )
          {
            stagerHandler.processSuccessful(file, xml)
          }
          else
          {
            stagerHandler.processRejected(file)
          }

          //new StagerQueueItem(file: file.absolutePath, baseDir: parent.baseDir, dataInfo: xml).save()


        }

        videoDataSets.each {videoDataSet ->
          //parent.addToVideoDataSets(videoDataSet)
          videoDataSet.repository = repository

          if ( videoDataSet.save() )
          {
            stagerHandler.processSuccessful(file, xml)
          }
          else
          {
            stagerHandler.processRejected(file)
          }

          //new StagerQueueItem(file: file.absolutePath, baseDir: parent.baseDir, dataInfo: xml).save()          
        }
        //}

        if ( ++count % 1000 == 0 )
        {
          try
          {
            cleanupGorm()
          }
          catch (Exception e)
          {

          }
        }
      }
    }
    else
      status = false


    return status
  }

  private def cleanupGorm()
  {
    def session = sessionFactory.currentSession

    session.flush()
    session.clear()
    DomainClassGrailsPlugin.PROPERTY_INSTANCE_MAP.get().clear()
  }

  def scanFile(File imageFile)
  {
    stagerHandler.processAll(imageFile)

    if ( checkFile(imageFile) )
    {
      def results = getImageInfo(imageFile)

      if ( !results )
      {
        stagerHandler.processFailure(imageFile)
      }
    }
    else
    {
      stagerHandler.processSkipped(imageFile)
    }
  }

  def scanDirectory(File dir)
  {
    def noscan = new File(dir, "__OSSIM_NO_SCAN__")

    if ( !noscan.exists() )
    {
      def atoc1 = new File(dir, "a.toc")
      def atoc2 = new File(dir, "A.TOC")
      def dht = new File(dir, "dht")
      def imgs = []

      dir.eachFileMatch(~/.*img/) {imgs << it }

      if ( atoc1.exists() )
      scanFile(atoc1)
      else if ( atoc2.exists() )
      scanFile(atoc2)
      else if ( dht.exists() )
        scanFile(dht)
        else if ( imgs )
          imgs.each { scanFile(it) }
          else
            dir.listFiles()?.sort()?.each {file -> scan(file) }
    }
  }

  def checkFile(File file)
  {
    def ext = file.name.toLowerCase().tokenize('.')[-1]
    def cppFiles = ~/(cpp|h|o|obj|exe|dll|so|lib)/
    def javaFiles = ~/(java|class|jar|war)/
    def programming = ~/(py|pl|sh|cgi)/
    def imageSupport = ~/(ovr|spec|kwl|his|omd|statistics|geom|prj|aux|hdr|dim|key)/
    def elevationSupport = ~/(bin|avg|min|max)/
    def worldFiles = ~/(gfw|jpw|pgw|tfw|nfw|sdw|jgw)/
    def vectorSupport = ~/(shx|dbf)/
    def documentation = ~/(txt|xml|xsl|xls|[x]html|htm[l]?|pdf|doc|rtf)/
    def archive = ~/zip|tar|gz|tgz|bz2/
    def macStuff = ~/ds_store/
    def otherFiles = ~/(tmp|log|out|orig[inal]|back|bck|save|ini|new|readme|db|htaccess)/
    def backup = ~/.*\~/
    def landSatSupport = ~/fst/
    def jp2Files = ~/jp2/
    def remoteViewSupport = ~/rv.*/

    def status = true

    switch ( ext )
    {
      case jp2Files:
      case cppFiles:
      case javaFiles:
      case programming:
      case imageSupport:
      case elevationSupport:
      case worldFiles:
      case vectorSupport:
      case documentation:
      case backup:
      case archive:
      case macStuff:
      case otherFiles:
      case remoteViewSupport:
        status = false
        break
      case landSatSupport:
        def openLandSat = ~/.*b[1-8][0-2].fst/
        status = !(openLandSat.matcher(file.name.toLowerCase()).matches())
        break
    }

    return status
  }

  def scan(File file)
  {
    if ( file.isDirectory() )
    {
      scanDirectory(file)
    }
    else if ( file.isFile() )
    {
      scanFile(file)
    }
  }

  def createHistogramsAndOverviews(def rasterDataSet)
  {
    imageStager.filename = rasterDataSet.fileObjects.find { it.type == "main" }.name

    //println "${imageStager.filename}"

    rasterDataSet?.rasterEntries?.each {rasterEntry ->
      //println "${rasterEntry.entryId}"
      imageStager.setDefaults()
      imageStager.entry = rasterEntry.entryId as Integer
      imageStager.stage()
    }
  }

  def stage()
  {
    this.scan(repository.baseDir as File)
    cleanupGorm()
  }

  public static void main(String[] args)
  {
    Init.instance().initialize(args.length, args)
    //Init.instance().initialize()

    Stager stager = new Stager()

    println "start: ${new Date()}"

    if ( args )
    {
      for ( arg in args )
      {
        stager.scan(arg as File)
      }
    }
    else
    {
      stager.scan(new File("Z:\\Baghdad"))
      //stager.scan( new File("c:/data") )
    }

    println " stop: ${new Date()}"
  }

}