#!/usr/bin/env ruby -W1
# frozen_string_literal: true

require_relative "../lib/conductor"
require "optparse"

# Main Conductor class
module Conductor
  class << self
    ##
    ## Execute commands/scripts in the track
    ##
    ## @param      track  The track
    ##
    ## @return     Resulting STDOUT output
    ##
    def execute_track(track)
      if track[:sequence]
        track[:sequence].each do |cmd|
          if cmd[:script]
            script = Script.new(cmd[:script])

            res = script.run
          elsif cmd[:command]
            command = Command.new(cmd[:command])

            res = command.run
          end

          Conductor.stdin = res unless res.nil?
        end
      elsif track[:script]
        script = Script.new(track[:script])

        Conductor.stdin = script.run
      elsif track[:command]
        command = Command.new(track[:command])

        Conductor.stdin = command.run
      end

      Conductor.stdin
    end

    ##
    ## Main function to parse conditions and
    ##             execute actions. Executes recursively for
    ##             sub-tracks.
    ##
    ## @param      tracks     The tracks to process
    ## @param      res        The current result
    ## @param      condition  The current condition
    ##
    ## @return     [Array] result, matched condition(s)
    ##
    def conduct(tracks, res = nil, condition = nil)
      tracks.each do |track|
        cond = Condition.new(track[:condition])

        next unless cond.true?

        # Build "matched condition" message
        title = track[:title] || track[:condition]
        condition ||= [""]
        condition << title
        condition.push(track.key?(:continue) ? " -> " : ", ")

        res = execute_track(track)

        if track[:tracks]
          ts = track[:tracks]

          res, condition = conduct(ts, res, condition)

          next if res.nil?
        end

        break unless track[:continue]
      end

      if res == Conductor.original_input
        [nil, "No change in output"]
      else
        [res, condition]
      end
    end
  end
end

optparse = OptionParser.new do |opts|
  opts.banner = "Called from Marked 2 as a Custom Pre/Processor"

  opts.on("-v", "--version", "Show version number") do
    puts "conductor v#{Conductor::VERSION}"
    Process.exit 0
  end

  opts.on("-h", "--help", "Display this screen") do
    puts opts
    exit
  end
end

optparse.parse!

config = Conductor::Config.new

Conductor.stdin
Conductor.original_input = Conductor.stdin

tracks = config.tracks
res, condition = Conductor.conduct(tracks)

##
## Clean up conditions for output
##
## @param      condition  The condition
##
def clean_condition(condition)
  condition.join("").sub(/ *(->|,) *$/, "")
end

if res.nil?
  warn "No conditions satisfied"
  puts "NOCUSTOM"
else
  if res == Conductor.original_input
    warn "No change in output"
    puts "NOCUSTOM"
  else
    warn "Met condition: #{clean_condition(condition)}"
    puts res
  end
end