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)

      @name = name unless name == NO_VALUE

      @name

    end

    def group(*properties, &builder)

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

      g._build(properties, &builder)

      g

    end

    def _build(properties, &builder)

      if properties and properties.size > 0

        properties.last.each {|name, value| self._set_property(name, caller(4).first, value)}

      end

      unless builder.nil?

        case builder.arity

          when -1

            self.instance_exec &builder

          when 0

            self.instance_exec &builder

          when 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)

      PROJECTS.include?(name) ? PROJECTS[name] : nil

    end

    def self.named(name)

      if PROJECTS.include?(name)

        p = PROJECTS[name]

      else

        p = self.new(name)

        PROJECTS[name] = p

      end

      p

    end

    def self.current

      defined? @@Current ? @@Current : (@@Current = nil)

      @@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

      p

    end

    def packages_and_application

      app = self.application

      app ? self.packages + [app] : self.packages

    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|

            @importee.package?(pkg.name)? @importee.package(pkg.name).merge(pkg) : @importee.packages.push(pkg.clone)

            pkg = @importee.package(pkg.name)

            pkg.set_property(:repository, @last_repository_name) if !pkg.repository and @last_repository_name

          end

          app = p.application

          if app

            if @importee.application

              (@importee.application.parent == @importee) ? @importee.application.merge(app) : (@importee.application = app.merge(@importee.application))

            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 {|import| import.apply}

    end

    def repository(name)

      raise Exception.new('Defining repository within package is no longer supported') if block_given?

      @last_repository_name = name

    end

    def package?(name)

      i = @packages.index {|r| r.name == name}

      i ? @packages[i] : nil

    end

    def package(name, *properties, &builder)

      unless (p = package?(name))

        p = Package.new(name, self)

        @packages.push(p)

      end

      p._build(properties, &builder)

      p.repository = @last_repository_name if !p.repository and @last_repository_name

      p

    end

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

      return @application if name == NO_VALUE

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

      unless (p = package?(name))

        p = Application.new(name, self)

        @application = p

      end

      p._build(properties, &builder)

      p.repository = @last_repository_name if !p.repository and @last_repository_name

      p

    end

    def tasks(*properties, &builder)

      if properties.empty? and !builder

        @tasks

      else

        t = Tasks.new

        t._build(properties, &builder)

        @tasks.push(t)

        t

      end

    end

    def accept_visitor(visitor)

      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!

      unless @builder.nil?

        case @builder.arity

          when -1

            @builder.call

          when 0

            @builder.call

          when 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)

      visitor.visit_tasks(self)

    end

  end # class Tasks

  class Package < ConfigurationObject

    property :repository, :class => Symbol

    property :branch, :class => String

    property :revision, :class => String

    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,

               :branch => pkg.branch, :revision => pkg.revision, :package => pkg, :separator => pkg._separator

    end), :class => Proc

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

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

      update pkg.repository, pkg.directory,

             :branch => pkg.branch, :revision => pkg.revision, :package => pkg, :separator => pkg._separator

    end), :class => Proc

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

    def _separator

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

    end

    def name_components

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

      @name_components

    end

    def top

      # Answers relative path to top directory

      File.join(self.name_components.collect {'..'})

    end

    def directory

      File.join(*self.name_components)

    end

    def project_definition_file_name

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

    end

    def dll_name_without_suffix

      # Sigh, a special hack for stx:librun which is NOT

      # libstx_librun.so/fll but just librun.so / librun.dll      

      # and for STC which  produces no .so / .dll

      case self.name

        when 'stx:stc'

          nil

        when 'stx:librun'

          'librun'

        else

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

      end

    end

    def dll_name

      case

        when self.name == 'stx:stc'

          nil

        when win32?

          "#{dll_name_without_suffix}.dll"

        when unix?

          "#{dll_name_without_suffix}.so"

        else

          error_unsupported_platform

      end

    end

    def nested_package?

      project.packages.each do |each|

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

      end

      false

    end

    def test_package?

      ((self.name.end_with? 'tests') or (self.name.end_with? 'test'))

    end

    def parent_package

      return nil unless 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

      nil

    end

    def application?

      false

    end

    def accept_visitor(visitor)

      visitor.visit_package(self)

    end

    def prereqs(mandatory: false, referenced: false, root: nil)

      raise Exception.new(%q{Nor mandatory nor referenced prereqs asked. Must specify either `mandatory: true` or `referenced: true` or both}) unless (mandatory or referenced)

      # Special hack for stx:stc and stx:librun which are actually 

      # not a smalltalk packages. 

      return [] if @name == 'stx:stc'

      # stx:librun depends on STC

      return ['stx:stc'] if @name == 'stx:librun'

      root = BUILD_DIR if (not root && defined? BUILD_DIR)

      raise Exception.new('BUILD_DIR not defined and no package root passed to Package::prereqs()') unless root

      source_file = root / directory / project_definition_file_name

      unless File.exist? source_file

        warn "Cannot fine project definition file for #{@name}. Container for nested packages?"

        return ['stx:libbasic']

      end

      source = ''

      File.open(source_file, 'r').each {|line| source << line}

      source.encode!('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')

      # All packaged depends on STC - one cannot compile them without it!

      prereqs = ['stx:stc']

      prereqs += source.scan(/^mandatoryPreRequisites(.*?)!$/m).flatten.to_s.scan(/#'([^']+)'/).flatten if mandatory

      prereqs += source.scan(/^referencedPreRequisites(.*?)!$/m).flatten.to_s.scan(/#'([^']+)'/).flatten if referenced

      prereqs.uniq

    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!!!

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

      end

      nm == 'application' ? c[c.size - 2] : nm

    end

    def application?

      true

    end

    def accept_visitor(visitor)

      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 {|name, value| each.set_property(name, value, caller(2).first)}

      end

    end

    def method_missing(selector, *args, &block)

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

      @nested_entities.push(e)

      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