require File.join(File.dirname(__FILE__), "..", "tools", 'model.rb')

module Maven
  module Model

    class DependencyArray < Array
      def <<(dep)
        d = detect { |item| item == dep }
        if d
          d.version = arg.version
          self
        else
          super
        end
      end
      alias :push :<<
    end

    class ExclusionArray < Array
      def <<(dep)
        excl = dep.is_a?(Exclusion) ? dep: Exclusion.new(dep)
        d = detect { |item| item == excl }
        if d
          delete d
        end
        super excl
      end
      alias :push :<<
    end

    class Coordinate < Maven::Tools::Tag
      tags :group_id, :artifact_id, :version
      def initialize(*args)
        @group_id, @artifact_id, @version = *coordinate(*args.flatten)
      end

      def coordinate(*args)
        if args[0] =~ /:/
          [args[0].sub(/:[^:]+$/, ''), args[0].sub(/.*:/, ''), version(*args[1, 2])]
        else
          [args[0], args[1], version(*args[2,3])]
        end
      end

      def version(*args)
        if args.size == 0
          nil
        else
          low, high = convert(args[0])
          low, high = convert(args[1], low, high) if args[1]
          if low == high
            low
          else
            "#{low || '[0.0.0'},#{high || ')'}"
          end
        end
      end

      def convert(arg, low = nil, high = nil)
        if arg =~ /~>/
          val = arg.sub(/~>\s*/, '')
          last = val.sub(/\.[^.]+$/, '.99999')
          ["[#{val}", "#{last}]"]
        elsif arg =~ />=/
          val = arg.sub(/>=\s*/, '')
          ["[#{val}", (nil || high)]
        elsif arg =~ /<=/
          val = arg.sub(/<=\s*/, '')
          [(nil || low), "#{val}]"]
        elsif arg =~ />/
          val = arg.sub(/>\s*/, '')
          ["(#{val}", (nil || high)]
        elsif arg =~ /</
          val = arg.sub(/<\s*/, '')
          [(nil || low), "#{val})"]
        else
          [arg, arg]
        end
      end

      def hash
        "#{group_id}:#{artifact_id}".hash
      end

      def ==(other)
        group_id == other.group_id && artifact_id == other.artifact_id
      end
      alias :eql? :==
    end

    class Exclusion < Maven::Tools::Tag
      tags :group_id, :artifact_id
      def initialize(*args)
        @group_id, @artifact_id = *coordinate(*args)
      end
      
      def coordinate(*args)
        case args.size
        when 1
          name = args[0].sub(/^mvn:/, '')
          if name =~ /:/
            [name.sub(/:[^:]+$/, ''), name.sub(/.*:/, '')]
          else
            ["rubygems", name]
          end
        else
          [args[0], args[1]]
        end
      end

      def hash
        "#{group_id}:#{artifact_id}".hash
      end

      def ==(other)
        group_id == other.group_id && artifact_id == other.artifact_id
      end
      alias :eql? :==
    end

    class Dependency < Coordinate
      tags :type, :scope, :classifier, :exclusions
      def initialize(type, *args)
        super(*args)
        @type = type
      end

      def hash
        "#{group_id}:#{artifact_id}:#{@type}".hash
      end

      def ==(other)
        super && @type == other.instance_variable_get(:@type)
      end
      alias :eql? :==

      def self.new_gem(gemname, *args)
        if gemname =~ /^mvn:/
          new(:maven_gem, gemname.sub(/^mvn:/, ''), *args)
        else
          new(:gem, "rubygems", gemname, *args)
        end
      end

      def self.new_jar(*args)
        new(:jar, *args)
      end

      def self.new_test_jar(*args)
        new(:test_jar, *args)
      end

      def exclusions(&block)
        @exclusions ||= ExclusionArray.new
        if block
          block.call(@exclusions)
        end
        @exclusions
      end

    end

    module Dependencies
    
      def jar?(*args)
        dependencies.member?(Dependency.new(:jar, *args))
      end

      def test_jar?(*args)
        dependencies.member?(Dependency.new(:test_jar, *args))
      end

      def gem?(*args)
        dependencies.member?(Dependency.new(:gem, *args))
      end

      def maven_gem?(*args)
        dependencies.member?(Dependency.new(:maven_gem, *args))
      end

      def dependencies(&block)
        @dependencies ||= DependencyArray.new
        if block
          block.call(@dependencies)
        end
        @dependencies
      end

      def lock_file
        nil
      end

      def add_dependency(dep, &block)
        dependencies << dep
        block.call(dep) if block
        dep
      end
      private :add_dependency

      def add_gem(*args, &block)
        if lock_file.nil? #|| !lock_file.hull.member?(args[0])
          args[1] = ">= 0.0.0" unless args[1]
          add_dependency(:gem, args, block)
        else
          result = add_dependency(:gem, args[0], block)
         
          # add its dependencies as well to have the version
          # determine by the dependencyManagement
          lock_file.dependency_hull(args[0]).map.each do |d|
            add_dependency(:gem, d[0], block)
          end

          result
        end
      end
      private :add_gem

      def jar(*args, &block)
        if args.last.is_a?(Hash)
          raise "hash not allowed for jar"
        end
        add_dependency(:jar, args, block)
      end

      def test_jar(*args, &block)
        if args.last.is_a?(Hash)
          raise "hash not allowed for test_jar"
        end
        add_dependency(:test_jar, args, block)
      end
      
      def gem(*args, &block)
        if args.last.is_a?(Hash)
          raise "hash not allowed in that context"
        end
        add_gem(args, block)
      end

      def maven_gem(*args, &block)
        if args.last.is_a?(Hash)
          raise "hash not allowed in that context"
        end
        add_dependency(:maven_gem, args, block)
      end
    end
  end
end