# File lib/taskjuggler/TaskJuggler.rb, line 33
def initialize
  @project = nil
  @parser = nil
  @maxCpuCores = 1
  @warnTsDeltas = false
  @generateTraces = false
  TjTime.setTimeZone('UTC')
end

# File lib/taskjuggler/TaskJuggler.rb, line 338
def checkStatusSheet(fileName)
  begin
    Log.enter('checkStatusSheet', 'Parsing #{fileName} ...')

    # To use this feature, the user must have specified which scenario is
    # the tracking scenario.
    unless @project['trackingScenarioIdx']
      raise TjException.new, 'No trackingscenario defined'
    end

    return false unless (ss = parseFile(fileName, :statusSheetFile))
    queryAttrs = { 'project' => @project,
                   'property' => ss[0],
                   'scopeProperty' => nil,
                   'scenarioIdx' => @project['trackingScenarioIdx'],
                   'start' => ss[1],
                   'end' => ss[2],
                   'timeFormat' => '%Y-%m-%d',
                   'selfContained' => true }
    query = Query.new(queryAttrs)
    puts ss[0].query_dashboard(query).richText.inputText
  rescue TjException => msg
    if msg.message && !msg.message.empty?
      critical('check_status_sheet', msg.message)
    end
    Log.exit('checkStatusSheet')
    return false
  end
  Log.exit('checkStatusSheet')
  true
end

# File lib/taskjuggler/TaskJuggler.rb, line 294
def checkTimeSheet(fileName)
  begin
    Log.enter('checkTimeSheet', 'Parsing #{fileName} ...')

    # To use this feature, the user must have specified which scenario is
    # the tracking scenario.
    unless @project['trackingScenarioIdx']
      raise TjException.new, 'No trackingscenario defined'
    end

    # Make sure we don't use data from old time sheets or Journal entries.
    @project.timeSheets.clear
    @project['journal'] = Journal.new
    return false unless (ts = parseFile(fileName, :timeSheetFile))
    return false unless @project.checkTimeSheets
    queryAttrs = { 'project' => @project,
                   'property' => ts.resource,
                   'scopeProperty' => nil,
                   'scenarioIdx' => @project['trackingScenarioIdx'],
                   'start' => ts.interval.start,
                   'end' => ts.interval.end,
                   'journalMode' => :journal,
                   'journalAttributes' => %w( alert property propertyid
                                              headline flags timesheet
                                              summary details ),
                   'sortJournalEntries' => [ [ :seqno, 1 ] ],
                   'timeFormat' => '%Y-%m-%d',
                   'selfContained' => true }
    query = Query.new(queryAttrs)
    puts ts.resource.query_journal(query).richText.inputText
  rescue TjException => msg
    if msg.message && !msg.message.empty?
      critical('check_time_sheet', msg.message)
    end
    Log.exit('checkTimeSheet')
    return false
  end
  Log.exit('checkTimeSheet')
  true
end

# File lib/taskjuggler/TaskJuggler.rb, line 383
def errors
  MessageHandlerInstance.instance.errors
end

# File lib/taskjuggler/TaskJuggler.rb, line 219
def freeze(freezeDate, taskBookings)
  begin
    # Check the master file is really a file and not stdin.
    unless (masterFile = @project.inputFiles.masterFile)
      error('cannot_freeze_stdin',
            "The project freeze feature can only be used when the " +
            "master file is a real file, not standard input.")
    end

    # Derive the file names for the header and bookings file from the base
    # name of the master file.
    masterFileBase = Dir.pwd + '/' + File.basename(masterFile, '.tjp')
    headerFile = masterFileBase + '-header.tji'
    bookingsFileBase = masterFileBase + '-bookings'
    bookingsFile = bookingsFileBase + '.tji'

    if !File.exist?(bookingsFile) || !File.exist?(headerFile)
      info('incl_freeze_files',
           "Please make sure you include #{headerFile} at " +
           "the end of the project header and " +
           "#{bookingsFile} at the end of #{masterFile}.")
    end

    # Generate the project header include file with the new 'now' date.
    begin
      File.open(headerFile, 'w') do |f|
        f.puts("now #{freezeDate}")
      end
    rescue
      error('write_header_incl',
            "Cannote write header include file " +
            "#{headerFile}")
    end

    # Generate an export report for the bookings.
    report = Report.new(@project, '_bookings_', bookingsFileBase, nil)
    report.typeSpec = :export
    report.set('formats', [ :tjp ])
    report.inheritAttributes

    # We export only the tracking scenario.
    unless (trackingScenarioIdx = @project['trackingScenarioIdx'])
      error('no_tracking_scen', 'No trackingscenario defined')
    end
    report.set('scenarios', [ trackingScenarioIdx ])

    # Only generate bookings up to the freeze date.
    report.set('end', freezeDate)
    # Show all tasks, sorted by seqno-up.
    report.set('hideTask', LogicalExpression.new(LogicalOperation.new(0)))
    report.set('sortTasks', [ [ 'seqno', true, -1 ] ])
    # Show all resources, sorted by seqno-up.
    report.set('hideResource',
                LogicalExpression.new(LogicalOperation.new(0)))
    report.set('sortResources', [ [ 'seqno', true, -1 ] ])
    # Only generate bookings, no other attributes or definitions.
    report.set('definitions', [])
    # We group the bookings by task or by resource depending on the user
    # request.
    if taskBookings
      report.set('taskAttributes', [ 'booking' ])
      report.set('resourceAttributes', [])
    else
      report.set('taskAttributes', [])
      report.set('resourceAttributes', [ 'booking' ])
    end
  rescue TjException
    return false
  end
  true
end

# File lib/taskjuggler/TaskJuggler.rb, line 185
def generateReport(reportId, regExpMode, formats = nil,
                   dynamicAttributes = nil)
  begin
    Log.enter('generateReport', 'Generating report #{reportId} ...')
    @project.generateReport(reportId, regExpMode, formats, dynamicAttributes)
  rescue TjException => msg
    if msg.message && !msg.message.empty?
      critical('generate_report', msg.message)
    end
    Log.exit('generateReport')
    return false
  end
  Log.exit('generateReport')
  true
end

# File lib/taskjuggler/TaskJuggler.rb, line 147
def generateReports(outputDir = nil)
  @project.checkReports
  if outputDir
    # Make sure the output directory path always ends with a '/' unless empty.
    outputDir += '/' unless outputDir.empty? || outputDir[-1] == '/'
    @project.outputDir = outputDir
  end
  Log.enter('reports', 'Generating reports ...')

  begin
    #RubyProf.start
    @project.generateReports(@maxCpuCores)
    #profile = RubyProf.stop
    #printer = RubyProf::GraphHtmlPrinter.new(profile)
    #File.open("profile.html", "w") do |file|
    #  printer.print(file)
    #end
    #printer = RubyProf::CallTreePrinter.new(profile)
    #File.open("profile.clt", "w") do |file|
    #  printer.print(file)
    #end
  rescue TjException => msg
    if msg.message && !msg.message.empty?
      critical('generate_reports', msg.message)
    end
    return false
  end

  Log.exit('reports')
  true
end

# File lib/taskjuggler/TaskJuggler.rb, line 203
def listReports(reportId, regExpMode)
  begin
    Log.enter('listReports', 'Generating report list for #{reportId} ...')
    @project.listReports(reportId, regExpMode)
  rescue TjException => msg
    if msg.message && !msg.message.empty?
      critical('list_reports', msg.message)
    end
    Log.exit('listReports')
    return false
  end
  Log.exit('listReports')
  true
end

# File lib/taskjuggler/TaskJuggler.rb, line 45
def parse(files, keepParser = false)
  # Reset the MessageHandler to clear all errors.
  MessageHandlerInstance.instance.clear

  Log.enter('parser', 'Parsing files ...')
  master = true
  @project = nil

  #RubyProf.start
  @parser = ProjectFileParser.new
  files.each do |file|
    begin
      @parser.open(file, master)
    rescue TjException => msg
      if msg.message && !msg.message.empty?
        critical('parse', msg.message)
      end
      Log.exit('parser')
      return false
    end
    if master
      # The first file is considered the master file.
      if (@project = @parser.parse(:project)) == false
        Log.exit('parser')
        return false
      end
      master = false
    else
      # All other files.
      @parser.setGlobalMacros
      if @parser.parse(:propertiesFile) == false
        Log.exit('parser')
        return false
      end
    end
    @project.inputFiles << file
    @parser.close
  end

  #profile = RubyProf.stop
  #printer = RubyProf::GraphHtmlPrinter.new(profile)
  #File.open("profile.html", "w") do |file|
  #  printer.print(file)
  #end
  #printer = RubyProf::CallTreePrinter.new(profile)
  #File.open("profile.clt", "w") do |file|
  #  printer.print(file)
  #end

  # For the report server mode we may need to keep the parser. Otherwise,
  # destroy it.
  @parser = nil unless keepParser

  Log.exit('parser')
  MessageHandlerInstance.instance.errors == 0
end

# File lib/taskjuggler/TaskJuggler.rb, line 104
def parseFile(fileName, rule)
  begin
    @parser.open(fileName, false)
    @project.inputFiles << fileName
  rescue TjException => msg
    if msg.message && !msg.message.empty?
      critical('parse_file', msg.message)
    end
    return nil
  end

  @parser.setGlobalMacros
  return nil if (res = @parser.parse(rule)) == false

  @parser.close
  res
end

# File lib/taskjuggler/TaskJuggler.rb, line 371
def projectId
  return nil if @project.nil?
  @project['projectid']
end

# File lib/taskjuggler/TaskJuggler.rb, line 377
def projectName
  return nil if @project.nil?
  @project['name']
end

# File lib/taskjuggler/TaskJuggler.rb, line 124
def schedule
  Log.enter('scheduler', 'Scheduling project ...')
  #puts @project.to_s
  @project.warnTsDeltas = @warnTsDeltas

  begin
    res = @project.schedule
  rescue TjException => msg
    if msg.message && !msg.message.empty?
      critical('scheduling_error', msg.message)
    end
    return false
  end

  @project.enableTraceReports(@generateTraces)

  Log.exit('scheduler')
  res
end