# coding: utf-8
#
# @package subtle
#
# @file Migrate config
# @copyright Copyright (c) 2011 Christoph Kappel <unexist@dorfelite.net>
# @version $Id$
#
# This program can be distributed under the terms of the GNU GPL.
# See the file COPYING.
#

require "pp"

def format_value(value)
  case value
    when String then "\"#{value}\""
    when Array  then value.join(", ")
    when Fixnum then value
    else value.to_s
  end
end

begin
  config  = nil
  styles  = {}
  skip    = []
  nline   = 0
  colline = nil
  ignore  = false
  lines   = nil

  # Init
  [ :title, :focus, :urgent, :occupied, :views,
    :sublets, :separator, :clients, :subtle
  ].each { |s| styles[s] = {} }

  # Check arguments
  if(0 == ARGV.size)
    # Get XDG path
    xdg_config_home = File.join((ENV["XDG_CONFIG_HOME"] ||
      File.join(ENV["HOME"], ".config")), "subtle")
    xdg_config_dir = File.join((ENV["XDG_CONFIG_DIRS"].split(":").first rescue
      File.join("/etc", "xdg")), "subtle")

    # Find config
    unless(File.exist?(config = File.join(xdg_config_home, "subtle.rb")))
      puts ">>> ERROR: Couldn't find config file"
      exit
    end
  elsif([ "--help", "-h", "help" ].include?(ARGV[0]))
    puts "Usage: %s [CONFIG]" % [ $0 ]
    puts "\nConvert color definitions to styles"
    puts "\nPlease report bugs at http://subforge.org/projects/subtle/issues"
    exit
  else
    config = ARGV[0]
  end

  puts ">>> Reading config `#{config}'"

  # Load config
  lines = IO.readlines(config)

  # Parse config
  lines.each do |line|
    case line
      # Block comments
      when /^=begin/ then ignore = true
      when /^=end/   then ignore = false

      # Options
      when /^\s*set\s*:border,\s*(\d+)/
        next if(ignore)
        value = $~[1].to_i
        styles[:clients][:active]   = value
        styles[:clients][:inactive] = value

        skip << nline
      when /^\s*set\s*:outline,\s*(\d+)/
        next if(ignore)
        value = $~[1].to_i
        styles[:title][:border]     = value
        styles[:focus][:border]     = value
        styles[:urgent][:border]    = value
        styles[:occupied][:border]  = value
        styles[:views][:border]     = value
        styles[:sublets][:border]   = value
        styles[:separator][:border] = value

        skip << nline
      when /^\s*set\s*:gap,\s*(\d+)/
        next if(ignore)
        styles[:clients][:margin] = $~[1].to_i

        skip << nline
      when /^\s*set\s*:padding,\s*\[((?:\s*(?:\d+)\s*,?)*)\]/
        next if(ignore)
        value = $~[1].split(",").map(&:to_i)

        styles[:title][:padding]     = value
        styles[:focus][:padding]     = value
        styles[:urgent][:padding]    = value
        styles[:occupied][:padding]  = value
        styles[:views][:padding]     = value
        styles[:sublets][:padding]   = value
        styles[:separator][:padding] = value

        skip << nline
      when /^\s*set\s*:strut,\s*\[((?:\s*(?:\d+)\s*,?)*)\]/
        next if(ignore)
        styles[:subtle][:padding] = $~[1].split(",").map(&:to_i)

        skip << nline

      # Colors
      when /^\s*color\s*:(\w+),\s*"(#[0-9a-fA-F]{6})/
        next if(ignore)
        name  = $~[1]
        sym   = name.split("_").first.to_sym
        color = $~[2]

        colline     ||= nline
        styles[sym] ||= {} if(styles.keys.include?(sym))

        case name
          when /^\w+_fg/     then styles[sym][:foreground]        = color
          when /^\w+_bg/     then styles[sym][:background]        = color
          when /^background/ then styles[:subtle][:background]    = color
          when /^stipple/    then styles[:subtle][:stipple]       = color
          when /^separator/  then styles[:separator][:foreground] = color
          when /^client_((?:in)?active)/
            sym = $~[1].to_sym

            # Set or append
            if(styles[:clients][sym].nil?)
              styles[:clients][sym] = color
            else
              styles[:clients][sym] = [
                format_value(color), styles[:clients][sym]
              ]
            end
          when /^panel/
            styles[:subtle][:panel]         = color
            styles[:separator][:background] = color
          when /^\w+_border/
            # Set or append
            if(styles[sym][:border].nil?)
              styles[sym][:border] = color
            else
              styles[sym][:border] = [
                format_value(color), styles[sym][:border]
              ]
            end
        end

        skip << nline
    end

    nline += 1
  end

  # Output
  filename = File.join(ENV["HOME"], "subtle.rb")
  File.open(filename, "w") do |f|
    nline = 0

    # Puts old config into new file
    lines.each do |line|
      # Replace colors by styles
      if(nline == colline)
        styles.each do |k, v|
          f.puts "style :#{k} do"

          # Arguments
          v.each do |k2, v2|
            value = format_value(v2)

            if(value.is_a?(String))
              f.puts "  %-10s  %s" % [ k2, value ]
            else
              f.puts "  %-10s  %d" % [ k2, value ]
            end
          end

          f.puts "end"
          f.puts
        end
      end

      # Puts line of not in skip list
      f.puts line unless(skip.include?(nline))

      nline += 1
    end
  end

  puts ">>> Created config `#{filename}'"

rescue => err
  puts ">>> ERROR: #{err}"
  puts err.backtrace
end