require "yaml"
require "optparse"
module Blueprint
  class Compressor
    TEST_FILES = ["index.html",
                  "parts/elements.html",
                  "parts/forms.html",
                  "parts/grid.html",
                  "parts/sample.html"]

    attr_accessor :namespace, :custom_css, :custom_layout, :semantic_classes, :project_name, :plugins, :custom_tests_path
    attr_reader   :custom_path, :loaded_from_settings, :destination_path, :script_name

    # overridden setter method for destination_path
    # also sets custom_path flag on Blueprint::Compressor instance
    def destination_path=(path)
      @destination_path = path
      @custom_path = @destination_path != Blueprint::BLUEPRINT_ROOT_PATH
    end

    # constructor
    def initialize
      # set up defaults
      @script_name = File.basename($0)
      @loaded_from_settings = false
      @settings_file = Blueprint::SETTINGS_FILE
      self.namespace = ""
      self.destination_path = Blueprint::BLUEPRINT_ROOT_PATH
      self.custom_layout = CustomLayout.new
      self.custom_css = {}
      self.semantic_classes = {}
      self.plugins = []

      self.options.parse!(ARGV)
      initialize_project_from_yaml(self.project_name)
    end

    # generates output CSS based on any args passed in
    # overwrites any existing CSS, as well as grid.png and tests
    def generate!
      output_header       # information to the user (in the console) describing custom settings
      generate_css_files  # loops through Blueprint::CSS_FILES to generate output CSS
      generate_tests      # updates HTML with custom namespaces in order to test the generated library.  TODO: have tests kick out to custom location
      output_footer       # informs the user that the CSS generation process is complete
    end

    def options #:nodoc:#
      OptionParser.new do |o|
        o.set_summary_indent("  ")
        o.banner =    "Usage: #{@script_name} [options]"
        o.define_head "Blueprint Compressor"
        o.separator ""
        o.separator "options"
        o.on( "-fSETTINGS_FILE", "--settings_file=SETTINGS_FILE", String,
              "Specify a non-default settings file path.") { |file| @settings_file = file }
        o.on( "-oOUTPUT_PATH", "--output_path=OUTPUT_PATH", String,
              "Define a different path to output generated CSS files to.") { |path| self.destination_path = path }
        o.on( "-nBP_NAMESPACE", "--namespace=BP_NAMESPACE", String,
              "Define a namespace prepended to all Blueprint classes (e.g. .your-ns-span-24)") { |ns| self.namespace = ns }
        o.on( "-pPROJECT_NAME", "--project=PROJECT_NAME", String,
              "If using the settings.yml file, PROJECT_NAME is the project name you want to export") {|project| @project_name = project }
        o.on( "--column_width=COLUMN_WIDTH", Integer,
              "Set a new column width (in pixels) for the output grid") {|cw| self.custom_layout.column_width = cw }
        o.on( "--gutter_width=GUTTER_WIDTH", Integer,
              "Set a new gutter width (in pixels) for the output grid") {|gw| self.custom_layout.gutter_width = gw }
        o.on( "--column_count=COLUMN_COUNT", Integer,
              "Set a new column count for the output grid") {|cc| self.custom_layout.column_count = cc }
        o.on( "--custom_tests_path=TESTS_OUTPUT_PATH", String,
              "Define a different path to output generated test files to") {|test_path| self.custom_tests_path = test_path }
        #o.on("-v", "--verbose", "Turn on verbose output.") { |$verbose| }
        o.on("-h", "--help", "Show this help message.") { puts o; exit }
      end
    end

    private

    # attempts to load output settings from settings.yml
    def initialize_project_from_yaml(project_name = nil)
      # ensures project_name is set and settings.yml is present
      return unless (project_name && File.exist?(@settings_file))

      # loads yaml into hash
      projects = YAML::load(File.path_to_string(@settings_file))

      if (project = projects[project_name]) # checks to see if project info is present
        self.destination_path = if self.destination_path == Blueprint::BLUEPRINT_ROOT_PATH
                                  project["path"]
                                else
                                  self.destination_path
                                end
        self.destination_path   ||= Blueprint::BLUEPRINT_ROOT_PATH
        self.namespace =        project["namespace"]        || ""
        self.custom_css =       project["custom_css"]       || {}
        self.semantic_classes = project["semantic_classes"] || {}
        self.plugins =          project["plugins"]          || []

        if (layout = project["custom_layout"])
          self.custom_layout = CustomLayout.new(:column_count =>  layout["column_count"],
                                                :column_width =>  layout["column_width"],
                                                :gutter_width =>  layout["gutter_width"],
                                                :input_padding => layout["input_padding"],
                                                :input_border =>  layout["input_border"])
        end
        @loaded_from_settings = true
      end
    end

    def generate_css_files
      Blueprint::CSS_FILES.each do |output_file_name, css_source_file_names|
        css_output_path = File.join(destination_path, output_file_name)
        puts "\n    Assembling to #{custom_path ? css_output_path : "default blueprint path"}"

        # CSS file generation
        css_output = css_file_header # header included on all three Blueprint-generated files
        css_output += "\n\n"

        # Iterate through src/ .css files and compile to individual core compressed file
        css_source_file_names.each do |css_source_file|
          puts "      + src/#{css_source_file}"
          css_output += "/* #{css_source_file} */\n" if css_source_file_names.any?

          source_options = if self.custom_layout && css_source_file == "grid.css"
            self.custom_layout.generate_grid_css
          else
            File.path_to_string File.join(Blueprint::SOURCE_PATH, css_source_file)
          end

          css_output += Blueprint::CSSParser.new(source_options,
                                                 :namespace => namespace).to_s
          css_output += "\n"
        end

        #append CSS from plugins
        css_output = append_plugin_css(css_output, output_file_name)

        # append CSS from custom files
        css_output = append_custom_css(css_output, output_file_name)

        #save CSS to correct path, stripping out any extra whitespace at the end of the file
        File.string_to_file(css_output.rstrip, css_output_path)
      end

      # append semantic class names if set
      append_semantic_classes

      generate_grid_png
    end

    def append_custom_css(css, current_file_name)
      # check to see if a custom (non-default) location was used for output files
      # if custom path is used, handle custom CSS, if any
      default_custom_css_exists = File.exist?(File.join(destination_path, "my-#{current_file_name}"))
      return css unless self.custom_path && (default_custom_css_exists || self.custom_css[current_file_name])

      custom_css_files = self.custom_css[current_file_name] || []
      custom_css_files << "my-#{current_file_name}"

      custom_css_files.each do |custom_css|
        overwrite_path = File.join(destination_path, custom_css)
        overwrite_css = if File.exists?(overwrite_path)
                          File.path_to_string(overwrite_path)
                        else
                          ""
                        end

        # if there's CSS present, add it to the CSS output
        unless overwrite_css.blank?
          puts "      + custom styles (#{custom_css})\n"
          css += "/* #{custom_css} */\n"
          css += CSSParser.new(overwrite_css).to_s + "\n"
        end
      end

      css
    end

    def append_plugin_css(css, current_file_name)
      return css unless self.plugins.any?

      plugin_css = ""

      self.plugins.each do |plugin|
        plugin_file_specific  = File.join(Blueprint::PLUGINS_PATH, plugin, current_file_name)
        plugin_file_generic   = File.join(Blueprint::PLUGINS_PATH, plugin, "#{plugin}.css")

        file = if File.exists?(plugin_file_specific)
          plugin_file_specific
        elsif File.exists?(plugin_file_generic) && current_file_name =~ /^screen|print/
          plugin_file_generic
        end

        if file
          puts "      + #{plugin} plugin\n"
          plugin_css += "/* #{plugin} */\n"
          plugin_css += CSSParser.new(File.path_to_string(file)).to_s + "\n"

          Dir.glob(File.join(File.dirname(file), "**", "**")).each do |cp|
            short_path = cp.gsub(/#{File.dirname(file)}./ , "")
            # make directory if it doesn't exist
            directory = File.dirname(short_path)
            if directory != "."
              FileUtils.mkdir_p(File.join(destination_path, directory))
            end

            unless File.directory?(File.join(File.dirname(file), short_path)) || cp == file
              FileUtils.cp(cp, File.join(destination_path, short_path))
            end
          end
        end
      end

      css += plugin_css
    end

    def append_semantic_classes
      screen_output_path = File.join(self.destination_path, "screen.css")
      semantic_classes = SemanticClassNames.new(:namespace => self.namespace,
                                                :source_file => screen_output_path)
      semantic_styles = semantic_classes.css_from_assignments(self.semantic_classes)
      return if semantic_styles.blank?

      css = File.path_to_string(screen_output_path)
      css += "\n\n/* semantic class names */\n"
      css += semantic_styles
      File.string_to_file(css.rstrip, screen_output_path)
    end

    def generate_tests
      puts "\n    Updating namespace to \"#{namespace}\" in test files:"
      test_files = Compressor::TEST_FILES.map do |file|
        File.join(self.custom_tests_path || Blueprint::TEST_PATH, *file.split(/\//))
      end

      test_files.each do |file|
        puts "      + #{file}"
        Namespace.new(file, namespace)
      end
    end

    def generate_grid_png
      GridBuilder.new(:column_width => self.custom_layout.column_width,
                      :gutter_width => self.custom_layout.gutter_width,
                      :output_path  => File.join(self.destination_path, "src")).generate!
    end

    def output_header
      puts "\n"
      puts "  #{"*" * 100}"
      puts "  **"
      puts "  **   Blueprint CSS Compressor"
      puts "  **"
      puts "  **   Builds compressed files from the source directory."
      puts "  **"
      puts "  **   Loaded from settings.yml" if loaded_from_settings
      puts "  **   Namespace: '#{namespace}'" unless namespace.blank?
      puts "  **   Output to: #{destination_path}"
      puts "  **   Grid Settings:"
      puts "  **     - Column Count: #{self.custom_layout.column_count}"
      puts "  **     - Column Width: #{self.custom_layout.column_width}px"
      puts "  **     - Gutter Width: #{self.custom_layout.gutter_width}px"
      puts "  **     - Total Width : #{self.custom_layout.page_width}px"
      puts "  **"
      puts "  #{"*" * 100}"
    end

    def output_footer
      puts "\n\n"
      puts "  #{"*" * 100}"
      puts "  **"
      puts "  **   Done!"
      puts "  **   Your compressed files and test files are now up-to-date."
      puts "  **"
      puts "  #{"*" * 100}\n\n"
    end

    def css_file_header
%(/* -----------------------------------------------------------------------


 Blueprint CSS Framework 1.0.1
 http://blueprintcss.org

   * Copyright (c) 2007-Present. See LICENSE for more info.
   * See README for instructions on how to use Blueprint.
   * For credits and origins, see AUTHORS.
   * This is a compressed file. See the sources in the 'src' directory.

----------------------------------------------------------------------- */)
    end

    def putsv(str)
      puts str if $verbose
    end
  end
end
