Exit
    StopAfterCurrent
    ReloadSongConfigs
    ToggleInterpolation
    ToggleChorus
    SeekForward
    SeekBackward
    ReloadTheme
  end

  enum ProgramState
    Run
    Quit
  end

    Config.confField(vuBarChar,            String,     DEF_VU_BAR_CHAR.to_s,     key: "vu-bar-character")
    Config.confField(vuTipChar,            String,     DEF_VU_TIP_CHAR.to_s,     key: "vu-tip-character")
    Config.confField(vuColors,      Array(ThemeColor), DEF_VU_COLORS,            key: "vu-colors")
    Config.confField(vuClipColor,          ThemeColor, DEF_VU_CLIP_COLOR,        key: "vu-clip-color")
    Config.confField(vuClippedChannelTime, UInt8,      DEF_CLIPPED_CHANNEL_TIME, key: "vu-clipped-channel-time")

    @[YAML::Field(ignore: true)]
    getter name : String = ""

    protected def name=(@name : String)
    end

    def initialize(@name = "")
    end

    def after_initialize
      {% begin %}
        raise ThemeError.new("Unsupported theme: version is too high") if @version > THEME_FORMAT_VERSION

        case @version

        else
          raise ThemeError.new("Unsupported theme version")
        end
      {% end %}
    end

    def dup
      ret : Theme = Theme.new(@name)
      ret.bgColor = self.bgColor
      ret.headerColor = self.headerColor
      ret.errColor = self.errColor
      ret.curSongColor = self.curSongColor
      ret.prevSongColor = self.prevSongColor
      ret.nextSongColor1 = self.nextSongColor1
      ret.nextSongColor2 = self.nextSongColor2

    # Attempts to load a theme file from disk.
    def self.load(resolver, aName : String|Array(String)) : Theme
      name : String = case aName
                      in String then aName
                      in Array(String) then aName.sample
                      end

      return Theme.new(DEF_THEME_NAME) if name == DEF_THEME_NAME

      # All theme files use the same format: theme-<name of theme>.yaml
      path = resolver.configDir.join(THEMES_DIR_NAME).join("theme-#{name}.yaml")
      if File.exists?(path)
        File.open(path, "r") do |file|
          RemiLib.log.log("Loading user theme: #{name}")
          ret = Theme.from_yaml(file)
          ret.name = name
          return ret
        end
      end

      # Check system-wide
      path = BENBEN_SYSTEM_DATA_DIR.join(SHORT_NAME, THEMES_DIR_NAME, "theme-#{name}.yaml")
      if File.exists?(path)
        File.open(path, "r") do |file|
          RemiLib.log.log("Loading system-wide theme: #{name}")
          ret = Theme.from_yaml(file)
          ret.name = name
          return ret
        end
      end

      raise ThemeError.new("Cannot find theme: #{name}")
    end

    # Generates a list of all available themes.

            ret[match[1]] = true
          end
        end
      end

      ret.keys
    end

    def self.reloadTheme : Theme?
      Benben.dlog!("Attempting to reload theme config for '#{Benben.theme.name}'")
      newTheme = Theme.load(Benben.resolver, Benben.theme.name)
      Benben.dlog!("Loaded theme config for '#{Benben.theme.name}': #{newTheme}")
      Benben.theme = newTheme
      Benben.dlog!("Theme configuration reloaded and set, global theme is now #{Benben.theme}")
      newTheme
    rescue err : Exception
      RemiLib.log.error("Could not reload theme: #{err}")
      Benben.ui.queueError("Could not reload theme: #{err}")
      nil
    end
  end
end

  RemiLib.classSetonce! logFile : File?

  # The loaded configuration file.
  @@config : EphemeralConfig = EphemeralConfig.new
  class_property config

  # The loaded UI theme.
  @@theme : Atomic(Theme?) = Atomic(Theme?).new(nil)
  #@@themeMut : Mutex = Mutex.new

  def self.theme : Theme
    #@@themeMut.synchronize { @@theme.not_nil! }
    @@theme.get.not_nil!
  end

  def self.theme=(newTheme : Theme) : Theme
    #@@themeMut.synchronize { @@theme = newTheme }
    @@theme.set(newTheme)
    newTheme
  end

  #class_property! theme

  # Used to find the configuration file and data files.
  @@resolver = RemiConf::Resolver.xdg(SHORT_NAME)
  class_getter resolver

  # Holds the original screen attributes.
  @@originalAttrs : LibC::Termios?

      # Initializes offsets for the banner lines.  This must be called before
      # any animation is performed.
      abstract def initOffsets : Nil

      # Refreshes the border lines.
      def refreshBorderLines(force : Bool = false) : Nil
        if force
          color = OrigUI.theme.maxBannerLineColor - 1

          SLScreen.drawHline(0, 0, color: color)
          SLScreen.drawHline(0, @bottomBorderY, color: color)
        else
          # See if it's time to animate the border lines.
          if @borderLinesTimeout < Time.local
            # The animation hasn't finished.  First update the lines that go
            # above/below the banner.  We go through all banner line colors
            # twice, hence the *2 and %2 below.
            if @doBorderColorChange == 0 && @borderColorOff < OrigUI.theme.numBannerLineColors * 2
              color = (Theme::BANNER_LINES_START + (@borderColorOff % OrigUI.theme.numBannerLineColors))
              SLScreen.drawHline(0, 0, color: color)
              SLScreen.drawHline(0, @bottomBorderY, color: color)
              @borderColorOff += 1
            end
            @doBorderColorChange = (@doBorderColorChange + 1) % 2 # Every third frame

            # Did we finish the entire loop?
            if @borderColorOff >= OrigUI.theme.numBannerLineColors * 2
              # Reset, wait for next redraw
              @borderLinesTimeout = Time.local + BANNER_LINES_TIMEOUT
              @doBorderColorChange = 0
              @borderColorOff = 0
            end
          end
        end

module Benben
  alias Slang = RemiSlang
  alias SLScreen = RemiSlang::Screen
  alias SLInput = RemiSlang::Input

  class OrigUI < UI
    enum Mode
      Playing
      Paused
      PlayingStopAfterCurrent
      PausedStopAfterCurrent
      Undefined
    end

    ##
    ## Constants
    ##

    # How often the CPU usage is refreshed, in milliseconds.
    CPU_USAGE_UPDATE_FREQ = 1000

    # How long a message is displayed.
    MESSAGE_TIME = 5.seconds

    HELP_MESSAGE_MIDI = %|
n - Next  p - Prev  x - Toggle Chorus     a - Vol up
q - Quit  e - EQ    c - Toggle soft clip  z - Vol down
s - Toggle stereo enhancer                Space - Pause/Unpause
R - Redraw screen   S - Stop after song   C - Reload song configs
    |.strip.lines

    INFO_LINE_HEADER = "Info: "







    ##
    ## Theme
    ##

    @@theme : Atomic(Theme?) = Atomic(Theme?).new(nil)
    #@@themeMut : Mutex = Mutex.new

    def self.theme : Theme
      @@theme.get.not_nil!
      #@@themeMut.synchronize { @@theme.not_nil! }
    end

    def self.theme=(newTheme : Theme) : Theme
      @@theme.set(newTheme)
      #@@themeMut.synchronize { @@theme = newTheme }
      newTheme
    end

    ##
    ## Fields
    ##

    # Current terminal attributes.
    property currentAttrs : LibC::Termios?

    # Mutex for thread-sensitive UI code.
    getter uiLock : Mutex = Mutex.new

    # Screen info
    getter lastWidth : Int32 = 0
    getter lastHeight : Int32 = 0

    # Message handling
    @messageTimeout : Time?
    @errorQueue : Deque(String) = Deque(String).new(1)
    @messageQueue : Deque(String) = Deque(String).new(1)

    def initialize
      OrigUI.theme = Theme.new(Benben.theme)
      @animations = Benben.config.uiConfig.animationsEnabled?

      @banner = Banner.getBanner(@animations)
      @mainAreaStartRow = @banner.size

      @tagDisplay = TagDisplay.new(@mainAreaStartRow)
      @playQueue = PlayQueue.new(@mainAreaStartRow + 8)

        when 'S' then Benben.manager.sendToAllKeyChans(KeyCommand::StopAfterCurrent)
        when 'C' then Benben.manager.sendToAllKeyChans(KeyCommand::ReloadSongConfigs)
        when 'i' then Benben.manager.sendToAllKeyChans(KeyCommand::ToggleInterpolation)
        when 'x' then Benben.manager.sendToAllKeyChans(KeyCommand::ToggleChorus)
        when 'R' then Benben.manager.sendToAllKeyChans(KeyCommand::ForceRedraw)
        when 'q' then Benben.manager.sendToAllKeyChans(KeyCommand::Exit)
        when 'h' then Benben.manager.sendToAllKeyChans(KeyCommand::Help)
        when 'T' then Benben.manager.sendToAllKeyChans(KeyCommand::ReloadTheme)

        {% if flag?(:benben_manual_gc) %}
        when 'G' then GC.collect
        {% end %}
        end
      {% end %}
    end

            @mainVolume = newVol
            vu.resetClips
            updateVolume

          when .reload_song_configs?
            queueMessage("Reloading song configs")
            Benben.config.loadSongConfigs

          when .reload_theme?
            Benben.dlog!("UI is attempting to reload the theme")
            if newTheme = Benben::Theme.reloadTheme
              Benben.dlog!("Same?  #{newTheme} == #{Benben.theme}")
              OrigUI.theme = Theme.new(newTheme)
              initColors
              initVu
              queueRedrawWholeScreen
              queueMessage("Theme reloaded")
            end

          when .force_redraw?
            Benben.dlog!("Redrawing entire screen due to request")
            redrawWholeScreen

          when .stop_after_current?
            @stopAfterCurrent = !@stopAfterCurrent

        @bgColor = getColorStr(@config.bgColor)
        @fgColor = getColorStr(@config.fgColor)
        @bannerColor = getColorStr(@config.bannerColor)
        @pbarChar = @config.progressBarChar
        @pbarSpaceChar = @config.progressBarSpaceChar
        @maxBannerLineColor = BANNER_LINES_START + @config.bannerLines.size
      end

      private def printDebugThemeInfo : Nil
        Benben.dlog!("UI Theme is from:      #{@config}")
        Benben.dlog!("UI Theme bg color:     #{@bgColor} (#{@config.bgColor})")
        Benben.dlog!("UI Theme fg color:     #{@fgColor} (#{@config.fgColor})")
        Benben.dlog!("UI Theme banner color: #{@bannerColor} (#{@config.bannerColor})")
        Benben.dlog!("UI Theme header color: #{getColorStr(@config.headerColor)} (#{@config.headerColor})")
        Benben.dlog!("UI Theme error color:  #{getColorStr(@config.errColor)} (#{@config.errColor})")
        Benben.dlog!("UI Theme song color:   #{getColorStr(@config.curSongColor)} (#{@config.curSongColor})")
      end

      # Converts *color* into a color string recognized by S-Lang.
      private def getColorStr(color : Benben::ThemeColor) : String
        case color
        in UInt8 then "color#{color}"
        in Tuple(UInt8, UInt8, UInt8)
          sprintf("#%02X%02X%02X", color[0], color[1], color[2])

        @pbarColors = [] of Int32
        @config.progressBarColors.each do |col|
          @pbarColors << (PBAR_COLOR_START + @pbarColors.size)
          SLScreen.defineColor(@pbarColors[-1], getColorStr(col), @bgColor)
        end
        @maxPbarColorIdx = (@pbarColors.size - 1).to_f32!

        printDebugThemeInfo
      end

      # Resets the progress bar color to the lowest color.
      def resetBarColor : Nil
        @curBarColor = 0.0f32
      end