# This file is not a standalone script. It is a kind

# of lightweight Mercurial library used by other scripts.

require 'uri'

require 'open3'

require 'shellwords'

# Following hack is to make hglib.rb working wit both jv:scripts and

# Smalltalk/X rakefiles. 

begin

  require 'rakelib/inifile'

rescue

  begin

    require 'inifile'

  rescue LoadError => ex

    $LOGGER.error("Cannot load package 'inifile'")

    $LOGGER.error("Run 'gem install inifile' to install it")

    exit 1

  end

end

if not $LOGGER then

  if STDOUT.tty? or win32? then

    require 'logger'

    $LOGGER = Logger.new(STDOUT)

    if (VERBOSE != nil) then

        $LOGGER.level = Logger::DEBUG

    else 

       $LOGGER.level = Logger::INFO 

    end

  else 

    require 'syslog/logger'

    $LOGGER = Syslog::Logger.new($0)    

  end

end

module HG

  @@config = nil

  # Cross-platform way of finding an executable in the $PATH.

  #

  #   which('ruby') #=> /usr/bin/ruby

  module_function

  def which(cmd)

    exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']

    ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|

      exts.each { |ext|

        exe = File.join(path, "#{cmd}#{ext}")

        return exe if File.executable?(exe) && !File.directory?(exe)

      }

    end

    return nil

  end

  GLOBAL_OPTIONS= [:'cwd', :'repository', :'noninteractive', :'config', :'debug', :'debugger',

       :'encoding',:'encodingmode',:'traceback',:'time', :'profile',:'version', :'help',

       :'hidden' ]

  # Execute `hg` command with given positional arguments and

  # keyword arguments turned into command options. For example, 

  #

  #     HG::hg("heads", "default", cwd: '/tmp/testrepo')

  #

  # will result in executing

  # 

  #     hg --cwd '/tmp/testrepo' heads default

  #

  # In addition if block is passed, then the block is evaluate with

  # `hg` command exit status (as Process::Status) and (optionally)

  # with contents of `hg` command stdout and stderr. 

  # If no block is given, an exception is raised when `hg` command 

  # exit status IS NOT zero.

  def self.hg(command, *args, **options, &block)

    g_opts = []

    c_opts = []

    options.each do | k , v |       

      if v != false and v != nil

        o = k.size == 1 ? "-#{k}" : "--#{k}"                

        if GLOBAL_OPTIONS.include? k then                  

          if v.kind_of?(Array)

            v.each do | e |

              g_opts << o << (e == true ? '' : e)  

            end

          else

            g_opts << o << (v == true ? '' : v)

          end

        else

          if v.kind_of?(Array)

            v.each do | e |

              c_opts << o << (e == true ? '' : e)  

            end

          else

            c_opts << o << (v == true ? '' : v)

          end

        end

      end

    end

    c_opts.reject! { | e | e.size == 0 }

    cmd = ['hg'] + g_opts + [command] + c_opts + args      

    cmd_info = cmd.shelljoin.

                gsub(/username\\=\S+/, "username\\=***").

                gsub(/password\\=\S+/, "password\\=***")

    $LOGGER.debug("executing: #{cmd_info}")

    if defined? RakeFileUtils then

      puts cmd_info

    end

    if block_given? then

      stdout, stderr, status = Open3.capture3(*cmd)

      case block.arity

      when 1

        STDOUT.print stdout

        STDERR.print stderr        

        yield status

      when 2                

        STDERR.print stderr 

        yield status, stdout

      when 3        

        yield status, stdout, stderr

      else

        raise Exception.new("invalid arity of given block")

      end

    else

      if not system(*cmd) then

        raise Exception.new("command failed: #{cmd.join(' ')}")

      end

    end    

  end

  def self.config()

    if @@config == nil

      files = Dir.glob('/etc/mercurial/hgrc.d/*.rc') + 

          [ '/etc/mercurial/hgrc' ,

          hgrc() ]

      if Gem.win_platform? then

         hg_exe = HG::which("hg")

         hgrc_d = File.join(File.dirname(hg_exe), "hgrc.d")

         if File.directory? (hgrc_d) then

            files += Dir.glob("#{hgrc_d}\\*.rc".gsub('\\', '/'))

         end

      end

      @@config = IniFile.new()

      files.each do | file |

        if File.exist?(file)

          $LOGGER.debug("Loading global config from \"#{file}\"")

          @@config.merge!(IniFile.new(:filename => file))

        end

      end  

    end

    return @@config

  end

  def self.hgrc()

    return File.expand_path('~/.hgrc')

  end

  class Repository

    @@HOSTS_ON_LAN = {}

    attr_accessor :path, :config

    private

    # Return --ssh config string for use with passed remote url or nil

    # if no special --ssh config is needed. 

    # 

    # Rationale: 

    #

    # On Windows, most of users tend to use TortoiseHG and hg.exe comming with

    # it. THG makes hg.exe to use (shipped) plink.exe which is bad for performance 

    # since it uses 16k channel input buffer (!) leading to a pretty slow transfers 

    # (a lot of iowaits...)

    # OpenSSH OTOH has 2MB input buffer which is good though on Windows bit 

    # oversized as Windows TCP window size is fixed to 65k for all connections with 

    # RTT less than 1ms. Still, 65k better then 16k. 

    # As a workaround, look if MSYS2's OpenSSH client is installed and if so, use that 

    # one - but only if `ui.ssh` config option has the default value. 

    # Ugly, isn't it? 

    def self.sshconf(uri_string) 

      uri = URI(uri_string)

      ssh = nil      

      if (uri.scheme == 'ssh') 

        ssh_in_path = HG::which('ssh') ? true : false

        if Gem.win_platform? then      

          # Running on Windows 

          #

          # Mercurial uses `ssh` by default, so to use `plink.exe`, `ui.ssh` 

          # config option has to be explicitly set.

          #

          # It it's set to `plink.exe`, check whether MSYS's `ssh.exe` is available

          # and if so, change it to `ssh.exe`...

          ssh_configured = HG::config['ui']['ssh'] 

          if /^.*[pP]link.exe"?\s*(-ssh)?\s*(-2)?$/ =~ ssh_configured then            

            if ssh_in_path then

              ssh = 'ssh'

            else 

              if (File.exist? "c:\\msys64\\usr\\bin\\ssh.exe") then              

                ssh = "\"c:\\msys64\\usr\\bin\\ssh.exe\""

              end

            end

            # Sigh, we should not tamper with SSH configuration wildly. User may have

            # her ssh and mercurial properly configured to use `plink.exe` and `pageant`.

            # If we just start using `ssh.exe` clone/pull might not work beause

            # `ssh.exe` cannot talk to `pageant`. So, if we don't find OpenSSH's 

            # style of agent, don't use `ssh.exe` event if available.

            if ssh then

              if ENV['SSH_AUTH_SOCK'] then

                # Good, OpenSSH agent running but still, be nice and  tell the 

                # user SSH configuration has been tampered wirh. 

                $LOGGER.info("Passing --ssh \"#{ssh}\" option to 'hg' command for faster transfers")

              else 

                # No agent, no fun. Be nice and give user a hit

                $LOGGER.warn("Not using -ssh \"#{ssh}\" option because SSH agent is not running")

                $LOGGER.warn("For faster clone/pull consider using ssh-agent or ssh-pageant (if you want to use PuTTY's pageant)")

                ssh = nil

              end

            end

            # Turn off SSH compression - data transferred by Mercurial are either

            # already compressed or --uncompressed was given to reduce CPU load

            # in which case passing -C would reduce it further.

            if ssh and HG::Repository::host_on_lan?(uri.host) then

              ssh += " -C"

            end

          end       

        else           

          # Turn off SSH compression - data transferred by Mercurial are either

          # already compressed or --uncompressed was given to reduce CPU load

          # in which case passing -C would reduce it further.

          if ssh_in_path and HG::Repository::host_on_lan?(uri.host) then

            ssh = "ssh -C"

          end

        end

      end

      return ssh

    end

    # Same as class method, but allows for remote aliases

    def sshconf(remote) 

      return HG::Repository::sshconf(self.paths[remote] || remote)

    end

    # Given a hostname, return true if the host is on local LAN, false

    # otherwise. 

    #

    # Results are cached to reduce resolver queries (maybe not worth it,

    # system may cache answers anyways)

    #

    # The detection is rather simplistic - it only checks if host's address

    # is from private IP range - and only for IPv4. 

    # This may cause problems when using over VPN that assigns private address

    # (the usuall case). In that case this code will treat is a local

    # which may result in transfer of uncompressed data over WAN. Not nice,

    # This should be fixed, somehow. 

    def self.host_on_lan?(hostname)

      if not @@HOSTS_ON_LAN.has_key? hostname then

        require 'resolv'

        addr = Resolv.getaddress(hostname)

        # Really poor detection of LAN, but since this is an 

        # optimization, getting this wrong does not hurt.         

        local = (addr.start_with? '192.168.') or (addr.start_with? '10.10.')

        @@HOSTS_ON_LAN[hostname] = local

      end

      return @@HOSTS_ON_LAN[hostname]

    end

    public

    # Clone a repository from given `uri` to given `directory`. 

    # Returns an `HG::Repository` instance representing the repository

    # clone. 

    # If `noupdate` is true, working copy is not updated, i.e., will be

    # empty. Use this when you're going to issue `update(rev)` shortly after.

    #

    def self.clone(uri, directory, noupdate: false)

      uri_obj = URI(uri)

      host = uri_obj.host

      scheme = uri_obj.scheme

      # When cloning over LAN, use --uncompressed option

      # as it tends to be faster if bandwidth is good (1GB norm

      # these days) amd saves some CPU cycles.

      local = HG::Repository::host_on_lan?(URI(uri).host)

      ssh = HG::Repository::sshconf(uri)      

      if noupdate then

        HG::hg("clone", uri, directory, ssh: ssh, uncompressed: local, noupdate: true)

      else

        HG::hg("clone", uri, directory, ssh: ssh, uncompressed: local)

      end

      return HG::Repository.new(directory)

    end

    # Initializes an empty repository in given directory. Returns an 

    # `HG::Repository` instance representing the created (empty) repository.

    def self.init(directory)

      HG::hg("init", directory)

      return HG::Repository.new(directory)

    end

    # Like HG::hg, but passes --cwd @path

    def hg(command, *args, **options, &block)

      options[:cwd] = @path

      HG::hg(command, *args, **options, &block)

    end

    def hgrc() 

      return File.join(@path, '.hg', 'hgrc')

    end

    def initialize(directory)

      @path = directory

      config_file = hgrc()      

      if File.exist? ( config_file ) 

        $LOGGER.debug("Loading repository config from \"#{config_file}\"")

        @config = HG::config().merge(IniFile.new(:filename => config_file))

      else

        @config = HG::config()

      end

    end

    # Return a hashmap with defined paths (alias => uri)

    def paths() 

      return @config['paths'].clone

    end

    # Set paths for given repository

    def paths=(paths)

      config = IniFile.new(:filename => self.hgrc())

      config['paths'] = paths

      config.write()

    end

    def log(revset, template = "{node|short}\n")      

      log = []

      hg("log", rev: revset, template: template) do | status, out |     

        if status.success?

          puts out

          log = out.split("\n")

        end

      end

      return log

    end

    # Return changeset IDs of all head revisions. 

    # If `branch` is given, return only heads in given

    # branch.

    def heads(branch = nil) 

      if branch then

        return log("head() and branch('#{branch}')")

      else

        return log("head()")

      end

    end

    # Return name of an active bookmark or nil if no bookmark

    # is active

    def bookmark() 

      filename = File.join(@path, '.hg', 'bookmarks.current')

      if File.exist? filename then

        file = File.open(filename, "r")

        begin

          bookmark = file.read.chomp

        ensure

          file.close()

        end

        return bookmark

      else

        return nil

      end

    end

    # Return a hash "bookmark => revision" of all 

    # bookmarks. 

    def bookmarks(branch = nil)

      revset  = "bookmark()"

      revset += " and branch('#{branch}')" if branch

      bookmarks = {}

      self.log(revset, "{bookmarks}|{node|short}\n").each do | line |

      end

      return bookmarks

    end

    # a private helper to generate auth --config options for

    # HTTP-served repositories

    protected

    def authconf(remote, user, pass) 

      authconf = []

      if pass != nil then

        if user == nil then

          raise Exception.new("Password given but not username! Use user: named param to specify username.")

        end

        # If user/password is provided, make sure we don't have

        # username in remote URI. Otherwise Mercurial won't use 

        # password from config!        

        uri = URI.parse(self.paths[remote] || remote)

        uri.user = nil

        uri = uri.to_s

        uri_alias = if self.paths.has_key? remote then remote else 'xxx' end

        authconf << "auth.#{uri_alias}.prefix=#{uri}"

        authconf << "auth.#{uri_alias}.username=#{user}"        

        authconf << "auth.#{uri_alias}.password=#{pass}"        

      end

      return authconf

    end

    public 

    def incoming(remote = 'default', user: nil, pass: nil, rev: nil)

      hg("incoming", remote, ssh: sshconf(remote), config: authconf(remote, user, pass), rev: rev) do | status, stdout|        

        case status.exitstatus

        when 0

          STDOUT.print stdout

        when 1

          puts "No new changes comming from #{remote}"          

        else        

          raise Exception.new("Failed to do 'incoming' from #{remote} (exit code #{status.exitstatus})")

        end

      end

    end

    def pull(remote = 'default', user: nil, pass: nil, rev: nil, bookmarks: nil)

      hg("pull", remote, ssh: sshconf(remote), config: authconf(remote, user, pass), rev: rev, bookmark: bookmarks) do | status, stdout|                

        STDOUT.print stdout

        case status.exitstatus

        when 0                    

          #nothing

        when 1

          raise Exception.new("Failed to 'pull' from #{remote} (update had unresolved conflicts)")

        else        

          raise Exception.new("Failed to 'pull' from #{remote} (exit code #{status.exitstatus})")

        end

      end

    end

    def outgoing(remote = 'default', user: nil, pass: nil, rev: nil)

      hg("outgoing", remote, ssh: sshconf(remote), config: authconf(remote, user, pass), rev: rev) do | status, stdout|                

        case status.exitstatus

        when 0          

          STDOUT.print stdout

        when 1

          puts "No new changes going to #{remote}"          

        else        

          raise Exception.new("Failed to do 'outgoing' from #{remote} (exit code #{status.exitstatus})")

        end

      end

    end

    def push(remote = 'default', user: nil, pass: nil, rev: nil, bookmarks: [])

      hg("push", remote, ssh: sshconf(remote), config: authconf(remote, user, pass), rev: rev, bookmark: bookmarks) do | status, stdout|                

        case status.exitstatus

        when 0          

          STDOUT.print stdout

        when 1

          puts "No new changes to push to #{remote}"          

        else        

          raise Exception.new("Failed to 'push' from #{remote} (exit code #{status.exitstatus})")

        end

      end

    end

    # Create a shared clone in given directory, Return a new

    # HG::Repository object on the shared clone

    def share(dst, rev = nil)

      if File.exist? dst then

        raise Exception.new("Destination file exists: #{dst}")

      end

      if rev == nil then

        rev = log('.')[0]

      end

      if not has_revision?(rev) 

        raise Exception.new("Revision #{rev} does not exist")

      end

      mkdir_p File.dirname(dst);

      HG::hg("share", path, dst, config: 'extensions.share=', noupdate: true, bookmarks: false)

      share = Repository.new(dst)

      share.update(rev);

      return share

    end

    # Updates the repository's working copy to given 

    # revision if given. If not, update to most-recent

    # head, as plain

    #

    #   hg update

    #

    # would do. 

    def update(rev = nil)

      if rev 

        if not has_revision? rev then

          raise Exception.new("Revision #{rev} does not exist")

        end

        hg("update", rev: rev)

      else

        hg("update")

      end

    end

    # Merge given revision. Return true, if the merge was

    # successful, false otherwise

    def merge(rev)

      if not has_revision? rev then

        raise Exception.new("Revision #{rev} does not exist")

      end

      hg("merge", rev) do | status |