# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with this
# work for additional information regarding copyright ownership.  The ASF
# licenses this file to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
# License for the specific language governing permissions and limitations under
# the License.

module Buildr #:nodoc:
  module Eclipse #:nodoc:
    include Extension

    class Eclipse

      attr_reader :options
      attr_writer :name

      def initialize(project)
        @project = project
        @options = Options.new(project)
      end

      def name
        return @name if @name
        return @project.id.split('-').last if @options.short_names
        @project.id
      end

      # :call-seq:
      #   classpath_variables :VAR => '/path/to/location'
      # Sets classpath variables to be used for library path substitution
      # on the project.
      #
      def classpath_variables(*values)
        fail "eclipse.classpath_variables expects a single hash argument" if values.size > 1
        if values.size == 1
          fail "eclipse.classpath_variables expects a Hash argument" unless values[0].is_a? Hash
          # convert keys to strings
          values = values[0].inject({}) { |h, (k,v)| h[k.to_s] = @project.path_to(v); h }
          @variables = values.merge(@variables || {})
        end
        @variables || (@project.parent ? @project.parent.eclipse.classpath_variables : default_classpath_variables)
      end

      def default_classpath_variables
        vars = {}
        vars[:SCALA_HOME] = ENV['SCALA_HOME'] if ENV['SCALA_HOME']
        vars[:JAVA_HOME]  = ENV['JAVA_HOME']  if ENV['JAVA_HOME']
        vars
      end

      # :call-seq:
      #   natures=(natures)
      # Sets the Eclipse project natures on the project.
      #
      def natures=(var)
        @natures = arrayfy(var)
      end

      # :call-seq:
      #   natures() => [n1, n2]
      # Returns the Eclipse project natures on the project.
      # They may be derived from the parent project if no specific natures have been set
      # on the project.
      #
      # An Eclipse project nature is used internally by Eclipse to determine the aspects of a project.
      def natures(*values)
        if values.size > 0
          @natures ||= []
          @natures += values.flatten
        else
          @natures || (@project.parent ? @project.parent.eclipse.natures : [])
        end
      end

      # :call-seq:
      #   classpath_containers=(cc)
      # Sets the Eclipse project classpath containers on the project.
      #
      def classpath_containers=(var)
        @classpath_containers = arrayfy(var)
      end

      # :call-seq:
      #   classpath_containers() => [con1, con2]
      # Returns the Eclipse project classpath containers on the project.
      # They may be derived from the parent project if no specific classpath containers have been set
      # on the project.
      #
      # A classpath container is an Eclipse pre-determined ensemble of dependencies made available to
      # the project classpath.
      def classpath_containers(*values)
        if values.size > 0
          @classpath_containers ||= []
          @classpath_containers += values.flatten
        else
          @classpath_containers || (@project.parent ? @project.parent.eclipse.classpath_containers : [])
        end
      end

      # :call-seq:
      #   exclude_libs() => [lib1, lib2]
      # Returns the an array of libraries to be excluded from the generated Eclipse classpath
      def exclude_libs(*values)
        if values.size > 0
          @exclude_libs ||= []
          @exclude_libs += values.flatten
        else
          @exclude_libs || (@project.parent ? @project.parent.eclipse.exclude_libs : [])
        end
      end

      # :call-seq:
      #   exclude_libs=(lib1, lib2)
      # Sets libraries to be excluded from the generated Eclipse classpath
      #
      def exclude_libs=(libs)
        @exclude_libs = arrayfy(libs)
      end

      # :call-seq:
      #   builders=(builders)
      # Sets the Eclipse project builders on the project.
      #
      def builders=(var)
        @builders = arrayfy(var)
      end

      # :call-seq:
      #   builders() => [b1, b2]
      # Returns the Eclipse project builders on the project.
      # They may be derived from the parent project if no specific builders have been set
      # on the project.
      #
      # A builder is an Eclipse background job that parses the source code to produce built artifacts.
      def builders(*values)
        if values.size > 0
          @builders ||= []
          @builders += values.flatten
        else
          @builders || (@project.parent ? @project.parent.eclipse.builders : [])
        end
      end

      private

      def arrayfy(obj)
        obj.is_a?(Array) ? obj : [obj]
      end
    end

    class Options

      attr_writer :m2_repo_var, :short_names

      def initialize(project)
        @project = project
      end

      # The classpath variable used to point at the local maven2 repository.
      # Example:
      #   eclipse.options.m2_repo_var = 'M2_REPO'
      def m2_repo_var(*values)
        fail "m2_repo_var can only accept one value: #{values}" if values.size > 1
        if values.size > 0
          @m2_repo_var = values[0]
        else
          @m2_repo_var || (@project.parent ? @project.parent.eclipse.options.m2_repo_var : 'M2_REPO')
        end
      end

      def short_names
        @short_names || (@project.parent ? @project.parent.eclipse.options.short_names : false)
      end
    end

    def eclipse
      @eclipse ||= Eclipse.new(self)
      @eclipse
    end

    first_time do
      # Global task "eclipse" generates artifacts for all projects.
      desc 'Generate Eclipse artifacts for all projects'
      Project.local_task('eclipse'=>'artifacts') { |name|  "Generating Eclipse project for #{name}" }
    end

    before_define do |project|
      project.recursive_task('eclipse')
    end

    after_define(:eclipse => :package) do |project|
      # Need to enhance because using project.projects during load phase of the
      # buildfile has harmful side-effects on project definition order
      project.enhance do
        eclipse = project.task('eclipse')
        # We don't create the .project and .classpath files if the project contains projects.
        if project.projects.empty?

          eclipse.enhance [ file(project.path_to('.classpath')), file(project.path_to('.project')) ]

          # The only thing we need to look for is a change in the Buildfile.
          file(project.path_to('.classpath')=>Buildr.application.buildfile) do |task|
            if (project.eclipse.natures.reject { |x| x.is_a?(Symbol) }.size > 0)
              info "Writing #{task.name}"

              m2repo = Buildr::Repositories.instance.local

              File.open(task.name, 'w') do |file|
                classpathentry = ClasspathEntryWriter.new project, file
                classpathentry.write do
                  # Note: Use the test classpath since Eclipse compiles both "main" and "test" classes using the same classpath
                  cp = project.test.compile.dependencies.map(&:to_s) - [ project.compile.target.to_s, project.resources.target.to_s ]
                  cp = cp.uniq

                  # Convert classpath elements into applicable Project objects
                  cp.collect! { |path| Buildr.projects.detect { |prj| prj.packages.detect { |pkg| pkg.to_s == path } } || path }

                  # Remove excluded libs
                  cp -= project.eclipse.exclude_libs.map(&:to_s)

                  # project_libs: artifacts created by other projects
                  project_libs, others = cp.partition { |path| path.is_a?(Project) }

                  # Separate artifacts under known classpath variable paths
                  # including artifacts located in local Maven2 repository
                  vars = []
                  project.eclipse.classpath_variables.merge(project.eclipse.options.m2_repo_var => m2repo).each do |name, path|
                    matching, others = others.partition { |f| File.expand_path(f.to_s).index(path) == 0 }
                    matching.each do |m|
                      vars << [m, name, path]
                    end
                  end

                  # Generated: Any non-file classpath elements in the project are assumed to be generated
                  libs, generated = others.partition { |path| File.file?(path.to_s) }

                  classpathentry.src project.compile.sources + generated
                  classpathentry.src project.resources

                  if project.test.compile.target
                    classpathentry.src project.test.compile
                    classpathentry.src project.test.resources
                  end

                  project.eclipse.classpath_containers.each { |container|
                    classpathentry.con container
                  }

                  # Classpath elements from other projects
                  classpathentry.src_projects project_libs

                  classpathentry.output project.compile.target if project.compile.target
                  classpathentry.lib libs
                  classpathentry.var vars
                end
              end
            end
          end

          # The only thing we need to look for is a change in the Buildfile.
          file(project.path_to('.project')=>Buildr.application.buildfile) do |task|
            info "Writing #{task.name}"
            File.open(task.name, 'w') do |file|
              xml = Builder::XmlMarkup.new(:target=>file, :indent=>2)
              xml.projectDescription do
                xml.name project.eclipse.name
                xml.projects
                unless project.eclipse.builders.empty?
                  xml.buildSpec do
                    project.eclipse.builders.each { |builder|
                      xml.buildCommand do
                        xml.name builder
                      end
                    }
                  end
                end
                unless project.eclipse.natures.empty?
                  xml.natures do
                    project.eclipse.natures.each { |nature|
                      xml.nature nature unless nature.is_a? Symbol
                    }
                  end
                end
              end
            end
          end
        end
      end
    end


    # Writes 'classpathentry' tags in an xml file.
    # It converts tasks to paths.
    # It converts absolute paths to relative paths.
    # It ignores duplicate directories.
    class ClasspathEntryWriter #:nodoc:
      def initialize project, target
        @project = project
        @xml = Builder::XmlMarkup.new(:target=>target, :indent=>2)
        @excludes = [ '**/.svn/', '**/CVS/' ].join('|')
        @paths_written = []
      end

      def write &block
        @xml.classpath &block
      end

      def con path
        @xml.classpathentry :kind=>'con', :path=>path
      end

      def lib libs
        libs.map(&:to_s).sort.uniq.each do |path|
          @xml.classpathentry :kind=>'lib', :path=>relative(path)
        end
      end

      # Write a classpathentry of kind 'src'.
      # Accept an array of absolute paths or a task.
      def src arg
        if [:sources, :target].all? { |message| arg.respond_to?(message) }
          src_from_task arg
        else
          src_from_absolute_paths arg
        end
      end

      # Write a classpathentry of kind 'src' for dependent projects.
      # Accept an array of projects.
      def src_projects project_libs
        project_libs.map { |project| project.eclipse.name }.sort.uniq.each do |eclipse_name|
          @xml.classpathentry :kind=>'src', :combineaccessrules=>'false', :path=>"/#{eclipse_name}"
        end
      end

      def output target
        @xml.classpathentry :kind=>'output', :path=>relative(target)
      end

      # Write a classpathentry of kind 'var' (variable) for a library in a local repo.
      # * +libs+ is an array of library paths.
      # * +var_name+ is a variable name as defined in Eclipse (e.g., 'M2_REPO').
      # * +var_value+ is the value of this variable (e.g., '/home/me/.m2').
      # E.g., <tt>var([lib1, lib2], 'M2_REPO', '/home/me/.m2/repo')</tt>
      def var(libs)
        libs.each do |lib_path, var_name, var_value|
          lib_artifact = file(lib_path)

          attribs = { :kind => 'var', :path => lib_path }

          if lib_artifact.respond_to? :sources_artifact
            attribs[:sourcepath] = lib_artifact.sources_artifact
          end

          if lib_artifact.respond_to? :javadoc_artifact
            attribs[:javadocpath] = lib_artifact.javadoc_artifact
          end

          # make all paths relative
          attribs.each_key do |k|
            attribs[k] = attribs[k].to_s.sub(var_value, var_name.to_s) if k.to_s =~ /path/
          end

          @xml.classpathentry attribs
        end
      end

    private

      # Find a path relative to the project's root directory if possible. If the
      # two paths do not share the same root the absolute path is returned. This
      # can happen on Windows, for instance, when the two paths are not on the
      # same drive.
      def relative path
        path or raise "Invalid path '#{path.inspect}'"
        msg = [:to_path, :to_str, :to_s].find { |msg| path.respond_to? msg }
        path = path.__send__(msg)
        begin
          relative = Util.relative_path(File.expand_path(path), @project.path_to)
          if relative['..']
            # paths don't share same root
            Util.normalize_path(path)
          else
            relative
          end
        rescue ArgumentError
          Util.normalize_path(path)
        end
      end

      def src_from_task task
        src_from_absolute_paths task.sources, task.target
      end

      def src_from_absolute_paths absolute_paths, output=nil
        relative_paths = absolute_paths.map { |src| relative(src) }
        relative_paths.sort.uniq.each do |path|
          unless @paths_written.include?(path)
            attributes = { :kind=>'src', :path=>path, :excluding=>@excludes }
            attributes[:output] = relative(output) if output
            @xml.classpathentry attributes
            @paths_written << path
          end
        end
      end
    end

    module Plugin
      include Extension

      NATURE    = 'org.eclipse.pde.PluginNature'
      CONTAINER = 'org.eclipse.pde.core.requiredPlugins'
      BUILDERS   = ['org.eclipse.pde.ManifestBuilder', 'org.eclipse.pde.SchemaBuilder']

      after_define do |project|
        eclipse = project.eclipse

        # smart defaults
        if eclipse.natures.empty? && (
            (File.exists? project.path_to("plugin.xml")) ||
            (File.exists? project.path_to("OSGI-INF")) ||
            (File.exists?(project.path_to("META-INF/MANIFEST.MF")) && File.read(project.path_to("META-INF/MANIFEST.MF")).match(/^Bundle-SymbolicName:/)))
          eclipse.natures = [NATURE, Buildr::Eclipse::Java::NATURE]
          eclipse.classpath_containers = [CONTAINER, Buildr::Eclipse::Java::CONTAINER] if eclipse.classpath_containers.empty?
          eclipse.builders = BUILDERS + [Buildr::Eclipse::Java::BUILDER] if eclipse.builders.empty?
        end

        # :plugin nature explicitly set
        if eclipse.natures.include? :plugin
          unless eclipse.natures.include? NATURE
            # plugin nature must be before java nature
            eclipse.natures += [Buildr::Eclipse::Java::NATURE] unless eclipse.natures.include? Buildr::Eclipse::Java::NATURE
            index = eclipse.natures.index(Buildr::Eclipse::Java::NATURE) || -1
            eclipse.natures = eclipse.natures.insert(index, NATURE)
          end
          unless eclipse.classpath_containers.include? CONTAINER
            # plugin container must be before java container
            index = eclipse.classpath_containers.index(Buildr::Eclipse::Java::CONTAINER) || -1
            eclipse.classpath_containers = eclipse.classpath_containers.insert(index, CONTAINER)
          end
          unless (eclipse.builders.include?(BUILDERS[0]) && eclipse.builders.include?(BUILDERS[1]))
            # plugin builder must be before java builder
            index = eclipse.classpath_containers.index(Buildr::Eclipse::Java::BUILDER) || -1
            eclipse.builders = eclipse.builders.insert(index, BUILDERS[1]) unless eclipse.builders.include? BUILDERS[1]
            index = eclipse.classpath_containers.index(BUILDERS[1]) || -1
            eclipse.builders = eclipse.builders.insert(index, BUILDERS[0]) unless eclipse.builders.include? BUILDERS[0]
          end
        end
      end
    end

    module Scala
      include Extension

      NATURE    = 'org.scala-ide.sdt.core.scalanature'
      CONTAINER = 'org.scala-ide.sdt.launching.SCALA_CONTAINER'
      BUILDER   = 'org.scala-ide.sdt.core.scalabuilder'

      after_define :eclipse => :eclipse_scala
      after_define :eclipse_scala do |project|
        eclipse = project.eclipse
        # smart defaults
        if eclipse.natures.empty? && (project.compile.language == :scala || project.test.compile.language == :scala)
          eclipse.natures = [NATURE, Buildr::Eclipse::Java::NATURE]
          eclipse.classpath_containers = [CONTAINER, Buildr::Eclipse::Java::CONTAINER] if eclipse.classpath_containers.empty?
          eclipse.builders = BUILDER if eclipse.builders.empty?
          eclipse.exclude_libs += Buildr::Scala::Scalac.dependencies
        end

        # :scala nature explicitly set
        if eclipse.natures.include? :scala
          unless eclipse.natures.include? NATURE
            # scala nature must be before java nature
            eclipse.natures += [Buildr::Eclipse::Java::NATURE] unless eclipse.natures.include? Buildr::Eclipse::Java::NATURE
            index = eclipse.natures.index(Buildr::Eclipse::Java::NATURE) || -1
            eclipse.natures = eclipse.natures.insert(index, NATURE)
          end
          unless eclipse.classpath_containers.include? CONTAINER
            # scala container must be before java container
            index = eclipse.classpath_containers.index(Buildr::Eclipse::Java::CONTAINER) || -1
            eclipse.classpath_containers = eclipse.classpath_containers.insert(index, CONTAINER)
          end
          unless eclipse.builders.include? BUILDER
            # scala builder overrides java builder
            eclipse.builders -= [Buildr::Eclipse::Java::BUILDER]
            eclipse.builders += [BUILDER]
          end
          eclipse.exclude_libs += Buildr::Scala::Scalac.dependencies
        end
      end
    end

    module Java
      include Extension

      NATURE    = 'org.eclipse.jdt.core.javanature'
      CONTAINER = 'org.eclipse.jdt.launching.JRE_CONTAINER'
      BUILDER    = 'org.eclipse.jdt.core.javabuilder'

      after_define do |project|
        eclipse = project.eclipse

        # smart defaults
        if project.compile.language == :java || project.test.compile.language == :java
          eclipse.natures = NATURE if eclipse.natures.empty?
          eclipse.classpath_containers = CONTAINER if eclipse.classpath_containers.empty?
          eclipse.builders = BUILDER if eclipse.builders.empty?
        end

        # :java nature explicitly set
        if eclipse.natures.include? :java
          eclipse.natures += [NATURE] unless eclipse.natures.include? NATURE
          eclipse.classpath_containers += [CONTAINER] unless eclipse.classpath_containers.include? CONTAINER
          eclipse.builders += [BUILDER] unless eclipse.builders.include? BUILDER
        end
      end
    end

  end

end # module Buildr

class Buildr::Project
  include Buildr::Eclipse
  include Buildr::Eclipse::Plugin
  include Buildr::Eclipse::Scala
  include Buildr::Eclipse::Java
end