require 'rubygems'

module YARD
  module Templates::Helpers
    # Helper methods for loading and managing markup types.
    module MarkupHelper
      MARKUP_PROVIDERS = {
        :markdown => [
          {:lib => :bluecloth, :const => 'BlueCloth'},
          {:lib => :maruku, :const => 'Maruku'},
          {:lib => :"rpeg-markdown", :const => "PEGMarkdown"},
          {:lib => :rdiscount, :const => "RDiscount"}
        ],
        :textile => [
          {:lib => :redcloth, :const => 'RedCloth'}
        ],
        :rdoc => [],
        :text => [],
        :html => []
      }
      
      # Returns a list of extensions for various markup types. To register
      # extensions for a type, add them to the array of extensions for the
      # type.
      # @since 0.6.0
      MARKUP_EXTENSIONS = {
        :html => ['htm', 'html', 'shtml'],
        :text => ['txt'],
        :textile => ['textile', 'txtile'],
        :markdown => ['markdown', 'md', 'mdown', 'mkd'],
        :rdoc => ['rdoc']
      }
      
      # Contains the Regexp object that matches the shebang line of extra
      # files to detect the markup type.
      MARKUP_FILE_SHEBANG = /\A#!(\S+)\s*$/

      begin
        require 'rdoc/markup'
        require 'rdoc/markup/to_html'
        SimpleMarkup = RDoc::Markup.new
      rescue Gem::LoadError
        raise
      rescue LoadError
        require 'rubygems'
        require 'rdoc/markup/simple_markup'
        require 'rdoc/markup/simple_markup/to_html'
        SimpleMarkup = SM::SimpleMarkup.new
      end

      private
      
      # Attempts to load the first valid markup provider in {MARKUP_PROVIDERS}.
      # If a provider is specified, immediately try to load it.
      # 
      # On success this sets `@markup_provider` and `@markup_class` to
      # the provider name and library constant class/module respectively for
      # the loaded proider.
      # 
      # On failure this method will inform the user that no provider could be
      # found and exit the program.
      def load_markup_provider(type = options[:markup])
        return if type == :rdoc || (@markup_cache && @markup_cache[type])
        @markup_cache ||= {}
        @markup_cache[type] ||= {}
        
        providers = MARKUP_PROVIDERS[type]
        return if providers && providers.empty?
        if options[:markup_provider]
          providers = providers.select {|p| p[:lib] == options[:markup_provider] }
        end
        
        if providers == nil || providers.empty?
          STDERR.puts "Invalid markup type '#{type}'"
          exit
        end
        
        # Search for provider, return the library class name as const if found
        providers.each do |provider|
          begin require provider[:lib].to_s; rescue LoadError; next end
          @markup_cache[type][:provider] = provider[:lib] # Cache the provider
          @markup_cache[type][:class] = Kernel.const_get(provider[:const])
          return
        end
        
        # Show error message telling user to install first potential provider
        name, lib = providers.first[:const], providers.first[:lib]
        STDERR.puts "Missing #{name} gem for #{options[:markup].to_s.capitalize} formatting. Install it with `gem install #{lib}`"
        exit
      end
      
      # Checks for a shebang or looks at the file extension to determine
      # the markup type for the file contents. File extensions are registered
      # for a markup type in {MARKUP_EXTENSIONS}.
      # 
      # A shebang should be on the first line of a file and be in the form:
      # 
      #   #!markup_type
      # 
      # Standard markup types are text, html, rdoc, markdown, textile
      # 
      # @return [Symbol] the markup type recognized for the file
      # @see MARKUP_EXTENSIONS
      # @since 0.6.0
      def markup_for_file(contents, filename)
        if contents =~ MARKUP_FILE_SHEBANG # Shebang support
          return $1.to_sym
        end

        ext = (File.extname(filename)[1..-1] || '').downcase
        MARKUP_EXTENSIONS.each do |type, exts|
          return type if exts.include?(ext)
        end
        options[:markup]
      end
      
      # Strips any shebang lines on the file contents that pertain to 
      # markup or preprocessing data.
      # 
      # @return [String] the file contents minus any preprocessing tags
      # @since 0.6.0
      def markup_file_contents(contents)
        contents =~ MARKUP_FILE_SHEBANG ? $' : contents
      end
      
      # Gets the markup provider class/module constant for a markup type
      # Call {#load_markup_provider} before using this method.
      # 
      # @param [Symbol] the markup type (:rdoc, :markdown, etc.)
      # @return [Class] the markup class
      def markup_class(type = options[:markup])
        type == :rdoc ? SimpleMarkup : @markup_cache[type][:class]
      end
      
      # Gets the markup provider name for a markup type
      # Call {#load_markup_provider} before using this method.
      # 
      # @param [Symbol] the markup type (:rdoc, :markdown, etc.)
      # @return [Symbol] the markup provider name (usually the gem name of the library)
      def markup_provider(type = options[:markup])
        type == :rdoc ? nil : @markup_cache[type][:provider]
      end
    end
  end
end