require 'rake'

require 'tsort'

require "#{File.dirname(__FILE__)}/dsl"

module Rake

end

module Rake::DSL

end

module Rake::Stx  

end

module Rake::Stx::Configuration

  def self.read_specs_from_dir(dir)

    if File.exist? dir

      info "Reading project specs from #{dir}..."

      d = Dir.new(dir)

      d.each do | file | 

        if file[0] != ?. and file =~ /.*\.rbspec$/ 

          begin

            info "  #{file}"

            $:.push(dir)

            load dir / file            

          ensure

            $:.pop()

          end          

        end    

      end

      d.each do | file | 

        if File.directory? File.join(dir, file)

          read_specs_from_dir(File.join(dir, file)) if file[0] != ?.

        end

      end        

    end

  end

  def self.read_specs(project_dirs_spec)

    project_dirs = ['specs' , 

                    ENV['HOME'] / '.smalltalk' / 'builder'

                   ]

    if win32?

      project_dirs += project_dirs_spec.split(";")

    else

      project_dirs += project_dirs_spec.split(":")

    end

    project_dirs.each do | dir |

      read_specs_from_dir(dir)

    end

  end

  class ConfigurationException < Exception 

  end

  class ConfigurationObject < Rake::StX::DSL::Object

    NO_VALUE = Object.new()

    attr_accessor  :parent

    attr_reader :last_repository_name

    def initialize(name = nil, parent = nil)

      @name = name

      @parent = parent

      @properties = {}

    end

    def name(name = NO_VALUE) 

      if (name != NO_VALUE)

        @name = name

      end

      return @name

    end

    def group(*properties, &builder)

      g = Group.new("<group>", self)

      g._build(properties, &builder)

      return g

    end

    def _build(properties, &builder)

      if (properties and properties.size() > 0) 

        properties.last.each do | name, value |        

          self._set_property(name, caller(4).first, value )

        end

      end

      if (builder != nil)

        if (builder.arity == -1)

          self.instance_exec &builder

        elsif (builder.arity == 0)

          self.instance_exec &builder          

        elsif (builder.arity == 1) 

          self.instance_exec(self,&builder)

        else

          raise ConfigurationException.new("invalid arity of builder block (0 or 1 arguments expected, #{builder.arity} given")

        end

      end

    end          

    def accept_visitor(visitor)

      raise Exception.new("Subclass responsibility (#{self.class.name}#accept_visitor")

    end

  end # class ConfigurationObject

  class Project < ConfigurationObject

    include Rake::DSL

    PROJECTS = {}

    attr_accessor :repositories, :packages, :tasks, :application

    attr_accessor :last_repository_name

    def self.named?(name)

      if (PROJECTS.include?(name)) 

        p = PROJECTS[name]     

      else

        p = nil

      end

      return p

    end

    def self.named(name)

      if (PROJECTS.include?(name)) 

        p = PROJECTS[name]     

      else

        p = self.new(name)

        PROJECTS[name] = p

      end

      return p

    end

    def self.current()

      if (not defined? @@Current) 

        @@Current = nil

      end

      return @@Current

    end

    def self.current=(project)

      @@Current = project

    end

    property :app_name

    property :app_version

    def initialize(name)

      super(name)

      @imports = []      

      @packages = []

      @application = nil

      @tasks = []

      @last_repository_name = nil

    end

    def clone()

      p = super()

      p.repositories = @repositories.clone()

      p.packages = @packages.clone()

      return p

    end

    def packages_and_application()

      app = self.application()

      if app 

        return self.packages() + [ app ]

      else

        return self.packages()

      end

    end

    class Import

      def initialize(importee, imported)

        @importee = importee

        @imported = imported#as symbol!        

        @last_repository_name = importee.last_repository_name

      end

      def apply()

        p = @importee.class.named(@imported)

        p.apply_imports()

        @importee.merge(p)

        #merge packages

        begin

          importee_last_repository_name = @importee.last_repository_name

          @importee.last_repository_name = @last_repository_name

          p.packages.each do | pkg |

            if @importee.package? pkg.name

              @importee.package(pkg.name).merge(pkg)

            else

              @importee.packages.push(pkg.clone())

            end

            pkg = @importee.package(pkg.name)

            if (not pkg.repository and @last_repository_name)

              pkg.set_property(:repository, @last_repository_name_name)

            end

          end

          app = p.application 

          if app

            if @importee.application

              if @importee.application.parent == @importee

                @importee.application.merge(app)

              else

                @importee.application = app.merge(@importee.application)

              end

            else

              @importee.application = app

            end

          end

        ensure

          @importee.last_repository_name = importee_last_repository_name 

        end

        p_tasks = p.tasks.collect { | t | t.clone }

        @importee.tasks = p_tasks + @importee.tasks

        info "Importing #{@imported}"

        info "     into #{@importee.name}"        

      end

    end # class Import

    def import(name)

      @imports.push(Import.new(self, name))

    end

    def apply_imports() 

      @imports.each do | import |

        import.apply()

      end      

    end

    def repository(name)            

      if block_given? then

        raise Exception.new("Defining repository within package is no longer supported")

      end

      @last_repository_name = name      

    end

    def package?(name)

      if ((i = @packages.index { | r | r.name == name }) != nil) 

        return @packages[i]        

      else

        return nil

      end

    end

    def package(name, *properties, &builder)

      if (not (p = package?(name)))

        p = Package.new(name, self)

        @packages.push(p)

      end      

      p._build(properties, &builder)

      if (not p.repository and @last_repository_name)

        p.repository = @last_repository_name

      end

      return p

    end

    def application(name = NO_VALUE, *properties, &builder)

      return @application if name == NO_VALUE         

      warn "Refefining application for project #{self.name}!" if @application

      if (not (p = package?(name)))

        p = Application.new(name, self)

        @application = p

      end      

      p._build(properties, &builder)

      if (not p.repository and @last_repository_name)

        p.repository = @last_repository_name

      end

      return p

    end

    def tasks(*properties, &builder)

      if (properties.empty? and not builder) 

        return @tasks

      else

        t = Tasks.new()

        t._build(properties, &builder)

        @tasks.push(t)

        return t

      end

    end

    def accept_visitor(visitor)

      return visitor.visit_project(self)

    end

  end # class Configuration

  class Tasks < ConfigurationObject

    include Rake::TaskManager    

    def _build(*properties, &builder)

      super(properties) {} 

      @builder = builder

    end

    def define!()

      if (@builder != nil)

        if (@builder.arity == -1)

          @builder.call()

        elsif (@builder.arity == 0)

          @builder.call()

        elsif (@builder.arity == 1) 

          @builder.call(self)

        else

          raise ConfigurationException.new("invalid arity of builder block (0 or 1 arguments expected, #{builder.arity} given")

        end

      end

    end

    def accept_visitor(visitor)

      return visitor.visit_tasks(self)

    end

  end # class Tasks

  class Package < ConfigurationObject 

    property :repository, :class => Symbol

    property :link, :values => [ true, false ], :default => true

    property :test, :values => [ true, false ], :default => false

    property :coverage, :values => [ true, false ], :default => false

    property :lint, :values => [ true, false ], :default => false

    property :checkout, :default => (Proc.new do | pkg |

                                     info "Checking out #{pkg.name}..."

                                     checkout pkg.repository, pkg.directory, 

                                   end), :class => Proc

    property :update, :default => (Proc.new do | pkg |

                                   info "Updating #{pkg.name}..."

                                   update pkg.repository, pkg.directory, 

                                 end), :class => Proc

    property :stc_flags, :default => '+optinline +optinline2 -optContext', :class => String    

    def _separator()

      return (Repository::find(self.repository)).separator

    end

    def name_components()

      if not @name_components then

        @name_components = self.name.sub(":", '/').split('/')

      end

      return @name_components

    end

    def top()

      # Answers relative path to top directory

      return File.join(self.name_components().collect { | e | '..' })

    end

    def directory()

      return File.join(*self.name_components)

    end

    def project_definition_file_name() 

      return "#{self.directory.gsub(File::SEPARATOR, "_")}.st"

    end

    def dll_name_without_suffix()

      return "lib#{self.directory.gsub(File::SEPARATOR, "_")}"

    end

    def dll_name()

      case 

      when win32?

        return  "#{dll_name_without_suffix()}.dll"

      when unix?

        return"#{dll_name_without_suffix()}.so"

      else

        error_unsupported_platform

      end       

    end

    def nested_package?

      project.packages.each do | each |

        if self.name != each.name and self.name.start_with? each.name + '/'

          return true

        end

      end

      return false

    end

    def parent_package

      return nil if not nested_package?

      last_slash = self.name.rindex(?/)

      return nil if last_slash == nil

      parent_package_name = self.name.slice(0, last_slash)

      project.packages.each do | each |

        return each if each.name == parent_package_name

      end

      return nil

    end

    def application? 

      return false

    end

    def accept_visitor(visitor)

      return visitor.visit_package(self)

    end

    def mandatory_prereqs() 

      return _prereqs("mandatoryPreRequisites")

    end

    def _prereqs(kind) 

    end

  end # class Package

  class Application < Package

    def executable

      c = self.name_components

      nm = c.last

      if win32?

        #JV@2011-07-22: HACK for Windows, since smalltalk.bat messes the argument list!!!

        if self.name == 'stx:projects/smalltalk'

          return 'stx'

        end        

      end

      if nm == 'application' 

        nm = c[c.size - 2]

      end

      return nm

    end

    def application? 

      return true

    end

    def accept_visitor(visitor)

      return visitor.visit_application(self)

    end

  end # class Application

  class Group < ConfigurationObject 

    def initialize(name, parent)

      super(name, parent)

      @properties_to_apply = Properties.new('<properties>', self);

      @nested_entities = []

    end

    def properties(*properties, &builder)      

      @properties_to_apply._build(properties, &builder)

    end

    def _build(*properties, &builder)

      @properties_to_apply._build(properties)

      super([], &builder)

      @nested_entities.each do | each |

        @properties_to_apply.properties.each do | name, value |

          each.set_property(name, value, caller(2).first)

        end

      end

    end

    def method_missing(selector, *args, &block)

      e = parent.send(selector,*args, &block)

      @nested_entities.push(e)

      return e

    end

    class Properties < ConfigurationObject

    end # class Group::Properties

  end # class Group

  class Repository < ConfigurationObject

    property :type, :class => Symbol

    # defines a canonical repossitory - this means, the one and only

    # repository that contains "official" code. 

    property :canonical, :class => String

    # defines a so called upstream repository - this means the repository

    # where the code from staging repository goes once verified. If no

    # upstream repository is defined, canonical repository is taken

    # instead

    property :upstream, :class => String

    # defines staging repository

    property :staging, :class => String

    property :separator, :default => '.'

    # Keeps reference to all defined repositories

    @@DEFINED = {}

    def self.find(name) 

      return @@DEFINED[name] || nil

    end

    def initialize(name, parent)