require 'dencli'
require 'yaml'

require 'pve'
require_relative 'helper'
require_relative 'cli/base'
require_relative 'cli/ct'
require_relative 'cli/ha'
require_relative 'cli/task'
require_relative 'cli/qm'
require_relative 'cli/node'
require_relative 'cli/storage'

class DenCli::Sub
  def provide_help name: nil, aliases: nil, min: nil
    base = self
    name = :help  if name.nil?
    aliases = %w[-h --help]  if aliases.nil?
    min = 1  if min.nil?
    #p name: name, aliases: aliases, min: min
    cmd( name, '', aliases: aliases, min: min) {|*args| help *args }
  end
end

class PVE::Cli
  class RuntimeError <::RuntimeError
  end

  class UsageError <RuntimeError
  end
  def UsageError msg
    raise UsageError, msg
  end

  class OperationalError <RuntimeError
  end
  def OperationalError msg
    raise OperationalError, msg
  end

  class ConditionViolation <RuntimeError
  end
  def ConditionViolation msg
    raise ConditionViolation, msg
  end

  class Output
    LINERESET = "\r\e[J"
    RESET     = "\e[0m"
    SUCCESS_  = "\e[32;1m✓"
    SUCCESS   = "#{LINERESET}[%s] #{SUCCESS_}#{RESET} "
    FAILED_   = "\e[31;1m✗"
    FAILED    = "#{LINERESET}[%s] #{FAILED_}#{RESET} "
    PROGRESS_ = "\e[33;1m%s"
    PROGRESS  = "#{LINERESET}[%s] #{PROGRESS_}#{RESET} "
    INFO_     = "\e[33;1m•"
    INFO      = "#{LINERESET}[%s] #{INFO_}#{RESET} "

    attr_accessor :host

    def initialize host
      @host, @spinners, @spin = host, "▖▘▝▗", 0
    end

    def progress format, *args, **kwargs
      STDERR.printf PROGRESS, @host, @spinners[@spin = (@spin + 1) % 4]
      STDERR.printf( format, *args, **kwargs)
    end

    def info format, *args, **kwargs
      STDERR.printf INFO, @host
      STDERR.printf( format, *args, **kwargs)
      STDERR.puts
    end

    def failed format, *args, **kwargs
      STDERR.printf FAILED, @host
      STDERR.printf( format, *args, **kwargs)
      STDERR.puts
    end

    def success format, *args, **kwargs
      STDERR.printf SUCCESS, @host
      STDERR.printf( format, *args, **kwargs)
      STDERR.puts
    end

    def reset
      STDERR.printf LINERESET
    end
  end

  attr_reader :cfg, :cli

  def connect
    @conn ||=
      Proxmox.connect cfg[:auth][:username], cfg[:auth][:password],
        realm: cfg[:auth][:realm], **cfg[:connect]
    #RestClient.log = STDERR
    @conn
  end

  def initialize config_file = nil
    config_file ||= '/etc/pve/pvecli.yml'
    @cfg =
      YAML.safe_load File.read( config_file), permitted_classes: [],
        permitted_symbols: [], aliases: false, filename: config_file,
        symbolize_names: true
    @cli = DenCli.new File.basename($0), "PVE CLI"
    @interactive = false
    @out = Output.new "<>"
    prepare
  end

  def interactive?
    @interactive
  end

  def enter host, *args
    @out.host = host.name
    r = host.enter *args
    operational_error "Exitstatus: #{$?.exitstatus}"  unless r
  end

  def wait_state host, state, timeout: nil, lock: nil
    @out.host = host.name
    r =
      host.wait state, lock: lock, timeout: timeout, secs: 0.2 do |state, lock|
        @out.progress "Still %s%s...", state, lock ? " (locked: #{lock})" : ''
      end
    @out.reset
    exit 1  if interactive?  and  !r
  end

  def task_log task, logn, limit = 1024
    log = task.log start: logn, limit: limit
    log = []  if [{n: 1, t: 'no content'}] == log
    unless log.empty?
      @out.reset
      log.each {|l| puts l[:t] }
      logn = log.last[:n]
    end
    logn
  end

  def wait task, secs: nil, text: nil, timeout: nil
    secs ||= 0.1
    logn = 0
    STDOUT.puts task.upid
    @out.host = host = task.host&.name || '<>'
    loop do
      s = task.status
      logn = self.task_log task, logn
      if s.finished?
        loop do
          r = self.task_log task, logn
          break  if 0 == logn - r
          logn = r
        end
        if s.successfull?
          @out.success "%s %s", text && "#{text}:", s.stopped? ? :finished : s.status
        else
          @out.failed "%s %s", text && "#{text}:", s.stopped? ? :finished : s.status
        end
        return s
      end
      @out.progress text || "Working"
      sleep secs
    end
  end

  def migrate host, node, timeout: nil, fire: nil, secs: nil, online: nil
    timeout ||= 30
    task = host.migrate Proxmox::Node.find_by_name!( node), online: online || false
    wait task, text: "Migrating", timeout: timeout  if fire
  end

  def start host, node: nil, timeout: nil, fire: nil, secs: nil
    timeout ||= 60
    if host.running?
      ConditionViolation "Already running."
      return
    end
    task = host.start
    t = Time.now
    unless fire
      wait task, text: "Starting", timeout: timeout
      wait_state host, :running, timeout: timeout-(Time.now-t)  if host.ha.exist? and not host.running?
    end
  end

  def stop host, timeout: nil, fire: nil, secs: nil
    timeout ||= 30
    if host.stopped?
      preset_error "Already stopped."
      return
    end
    task = host.stop
    t = Time.now
    unless fire
      wait task, text: "Stopping", timeout: timeout
      wait_state host, :stopped, timeout: timeout-(Time.now-t)  if host.ha.exist? and not host.stopped?
    end
  end

  def create klass, template, timeout: nil, fire: nil, start: nil, **options
    options[:start] = fire && start
    task = klass.create template, **options
    return  if fire
    status = wait task, text: "Creating"
    if status.successfull?
      host = task.host.refresh!
      start host, timeout: timeout, secs: secs  if start
    elsif not interactive?
      exit 1
    end
  end

  def destroy ct, timeout: nil, fire: nil, secs: nil
    task = ct.destroy
    unless fire
      wait task, text: "Destroying"
    end
  end

  def rbd_device_map image_spec, &exe
    dev = IO.popen( [*%w[rbd device map], image_spec]) {|io| io.read }.chomp
    raise OperationalError, "Device mapping #{image_spec} localy failed."  unless $?.success?
    begin
      yield dev
    ensure
      system *%w[rbd device unmap], image_spec
      raise OperationalError, "Device unmapping #{image_spec} failed."  unless $?.success?
    end
  end

  def rbd_devices_maps spec, *specs, &exe
    rbd_device_map spec do |dev|
      if specs.empty?
        yield dev
      else
        rbd_devices_maps *specs do |*devs|
          yield dev, *devs
        end
      end
    end
  end

  def mount dev, mp, &exe
    system 'mount', dev.to_s, mp.to_s
    begin yield
    ensure
      # it could be possible, that a process is working in fs, yet.
      sleep 1
      system 'umount', mp.to_s
    end
  end

  def ct_volume_move ct, disk, destination
    @out.host = ct.name
    host = Proxmox::Node.find_by_name! Socket.gethostname
    unless host.node == ct.node.node
      ConditionViolation( "CT is hosted on #{ct.node.node}, not local (#{Socket.gethostname})")
    end
    # Lock, we do not want changes, while we check/prepare,
    # these checks could be obsolete while moving.
    configupdate = {}
    ct.lock :migrate do
      disk =
        case disk
        when 'rootfs', /\Amp\d+\z/ then disk.to_sym
        else UsageError( "Unknown disk #{disk}")
        end
      ctcnf = ct.config
      UsageError( "CT has no disk #{disk}")  if ctcnf[disk].nil?
      UsageError( "CT not stopped, yet.")    unless ct.stopped?
      dest = host.storage.find {|x| destination == x.storage }
      ConditionViolation( "Destination storage #{dest.storage} disabled")    unless dest.enabled?
      ConditionViolation( "Destination storage #{dest.storage} not active")  unless dest.active?

      unless /\A([^:]+):([^,]+)(,.+)?\z/ =~ ctcnf[disk]
        OperationalError( "disk-specification cannot be parsed: [#{disk}: #{ctcnf[disk]}]")
      end
      source, name, diskopts = $1, $2, $3.to_s
      src = host.storage.find {|x| source == x.storage }

      ConditionViolation( "Source storage #{dest.storage} disabled")    unless dest.enabled?
      ConditionViolation( "Source storage #{dest.storage} not active")  unless dest.active?
      case src.type
      when 'rbd'
      else ConditionViolation( "Storage type #{src.type} not supported as source. (supported: rbd only, yet)")
      end
      #unless c = src.content.find {|x| x.name == name }
      #  usage_error "Source storage #{src.storage} has no disk named #{name}"
      #end
      case dest.type
      when 'rbd'
      else ConditionViolation( "Storage type #{dest.type} not supported as destination. (supported: rbd only, yet)")
      end
      #if c = dest.content.find {|x| x.name == name }
      #  usage_error "Destination storage #{dest.storage} has already a disk named #{name}"
      #end

      src_image_spec, dest_image_spec = "#{source}/#{name}", "#{destination}/#{name}"
      mp_path = Pathname.new( "/var/lib/lxc/").join ct.vmid.to_s
      mp_path.mkdir  unless mp_path.exist?
      src_mp, dest_mp = mp_path + src_image_spec.gsub('/','-'), mp_path + dest_image_spec.gsub('/','-')

      src_mp.mkdir   unless src_mp.exist?
      dest_mp.mkdir  unless dest_mp.exist?
      # We check, if something is mounted already on our mountpoints.
      # We check it later, too, but later cleaning up would be impossible.
      # We do not trust only this checks, so we check later, too.
      ConditionViolation( "Something already mounted at #{src_mp}")   if src_mp.mountpoint?
      ConditionViolation( "Something already mounted at #{dest_mp}")  if dest_mp.mountpoint?

      rbd_image_info = JSON.parse IO.popen( [*%w[rbd info --format json], src_image_spec]) {|io| io.read }
      OperationalError( "Couldn't determine size of #{src_image_spec}.")  unless $?.success?

      # checks and preparation done.
      size = rbd_image_info['size']/1024/1024

      unless system *%w[rbd create -s], size.to_s, dest_image_spec
        OperationalError( "Creating disk #{dest_image_spec} failed.")
      end
      @out.progress "Map devices %s, %s \e[J", ct.name, dest_image_spec, src_image_spec
      rbd_devices_maps dest_image_spec, src_image_spec do |dest_dev, src_dev|
        @out.info "Maped source      device %s => %s => %s", src_image_spec, src_dev, src_mp
        @out.info "Maped destination device %s => %s => %s", dest_image_spec, dest_dev, dest_mp
        @out.info "Formatting destination disk"
        unless system *%w[mkfs.xfs -mreflink=1 -bsize=4096 -ssize=4096], dest_dev
          OperationalError( "Formatting #{dest_image_spec} failed.")
        end
        OperationalError( "Something already mounted at #{src_mp}")  if src_mp.mountpoint?
        @out.progress "Mounting source disk"
        mount src_dev, src_mp do
          OperationalError( "Something already mounted at #{src_mp}")  if dest_mp.mountpoint?
          @out.progress "Mounting destination disk"
          mount dest_dev, dest_mp do
            #@out.info "rsyncing..."
            #system *%w[rsync -aHAX --info=progress2], "#{src_mp}/", "#{dest_mp}/"
            IO.popen %w[rsync -ahHAX --info=progress2] + ["#{src_mp}/", "#{dest_mp}/"] do |io|
              io.each_line("\r") {|l| @out.progress 'rsync|%s', l.chomp }
            end
            OperationalError( "rsync had an error. [#{$?.exitcode}]")  unless $?.success?
          end
        end
      end

      unusedfield = (0..20).map{|i| "unused#{i}" }.find {|n| ctcnf[n].nil? }
      configupdate = {unusedfield => "#{source}:#{name}", disk => "#{destination}:#{name}#{diskopts}"}
    end
    ct.cnfset **configupdate
    @out.success "disk moved."
  end

  def node_opt node = nil
    node ? [Proxmox::Node.find_by_name!( node)] : Proxmox::Node.all
  end

  def target_opt target = nil, &exe
    if target
      target = /\A#{target}\z/
      lambda {|n| exe.call n  if n === target }
    else
      exe
    end
  end

  def hosting_table target:, status:, sort:, tags:
    connect
    to = TablizedOutput.new %w[Status HA ID Name Host Uptime CPU/% Mem/MiB Mem/% Disk/MiB Disk/% Tags], format: '<<<<<>>>>>><'
    target &&= /\A#{target}\z/i
    nottags = nil
    if tags
      tags = tags.split /,/
      nottags = tags.grep /\A-/
      tags -= nottags
      nottags.map! {|x| x[1..-1] }
    end
    status =
      case status
      when /\Asta(?:r(?:t(?:ed?)?)?)?\z/i, /\Aon(?:l(?:i(?:ne?)?)?)?\z/i, /\Ar(?:u(?:n(?:n(?:i(?:ng?)?)?)?)?)?\z/i, '1'
        %i[started online running]
      when /\Asto(?:p(?:p(?:ed?)?)?)?\z/i, /\Aof(?:f(?:l(?:i(?:ne?)?)?)?)?\z/i, '0'
        %i[stopped offline]
      when nil, '', /\Aa(ll?)?\z/i then nil
      else
        usage_error "Unknown state #{status}"
      end
    push =
      begin
        condition = []
        condition.push lambda {|n| n === target }  if target
        if status
          condition.push lambda {|n| !n.respond_to?( :status) or status.include?( n.status) }
        end
        if tags
          condition.push lambda {|n|
            if n.respond_to?( :tags) and n.tags
              nt = n.tags
              [] == tags - nt and nottags == nottags - nt
            else false
            end
          }
        end
        lambda {|n| to.push tablized_virt( n)  if condition.all? {|c| c.call n} }
      end
    yield push
    to.print order: sort.each_char.map {|c| (2*c.ord[5]-1) * (' sainhucmd'.index( c.downcase)) }
  end

  def help cl, *args
    STDERR.puts cl.help( *args)
    exit 1  unless interactive?
  end

  def opts_wait cl
    cl.
      opt( :timeout, "-t", "--timeout=TIMEOUT", "Wait for max TIMEOUT seconds (default: endless)", default: nil).
      opt( :secs, "-s", "--seconds=SECONDS", "Check every SECONDS for state (default: 0.2)", default: 0.2).
      opt( :fire, "-f", "--[no-]fire", "Do not wait till running", default: false)
  end

  def complete_lxc f
    Proxmox::LXC.all.
      flat_map {|x| [x.name, x.vmid.to_s] }.
      select {|x| f =~ x }
  end

  def complete_qemu f
    Proxmox::Qemu.all.
      flat_map {|x| [x.name, x.vmid.to_s] }.
      select {|x| f =~ x }
  end

  def complete_node f
    Proxmox::Qemu.all.
      map {|x| x.name }.
      select {|x| f =~ x }
  end

  def completion_helper *pre, arg, &exe
    if pre.empty?
      connect
      xs = yield /\A#{Regexp.quote arg}/
      STDOUT.print "\a"  if xs.empty?
      xs
    else
      STDOUT.print "\a"
      []
    end
  end

  def prepare
    cli_node
    cli_ct
    cli_qm
    cli_task
    cli_ha
    cli_base
    cli_storage
  end

  def call *argv
    cli.call *argv
  rescue RestClient::ExceptionWithResponse
    @out.failed "%s: %s - %s (%s)", $!.request, $!, $!.response, $!.class
    #STDERR.puts $!.backtrace.map {|b|"  #{b}"}
    exit 1
  rescue DenCli::UsageError, RuntimeError
    @out.failed "%s", $!
    exit 1
  end

  def per_argument arguments, print: nil, &exe
    arguments.each do |argument|
      @out.host = argument
      @out.info "\e[1;34m#{print}\e[0m", argument  if print
      begin
        yield argument
      rescue RestClient::ExceptionWithResponse
        @out.failed "%s: %s - %s", $!.request, $!, JSON.parse( $!.response.body)
      rescue DenCli::UsageError, RuntimeError
        @out.failed "%s", $!
      rescue RestClient::BadRequest
        @out.failed "%p", $!.message
      rescue Interrupt
        @out.failed "Interrupted by user"
      rescue SystemExit
        @out.failed "Exitcode: %d", $!.status  if 0 < $!.status
      end
    end
  end

  def appliances node, regexp, system, applications
    system = applications = true  if system.nil? and applications.nil?
    node = node ? Proxmox::Node.find_by_name!( node) : Proxmox::Node.all.first
    to = TablizedOutput.new %w<Section Package Version OS Template Description>, format: %w[> > > > > <]
    node.aplinfo.
      select {|a| 'system' == a.section ? system : applications}.
      each do |apl|
        to.push [
          apl.section,
          apl.package,
          apl.version,
          apl.os,
          apl.template,
          apl.description,
        ]
      end
    to.print order: [1,2]
  end

  COLORS = %w[black red green yellow blue magenta cyan white].each_with_index.to_h
  def fgcolor color
    color = color.to_s
    if /\Abright[-_]?(.*)\z/ =~ color
      c = COLORS[$1]
      c.nil? ? nil : "1;3#{c}"
    else
      c = COLORS[color]
      c.nil? ? nil : "3#{c}"
    end
  end

  def tablized_virt v
    ha = v.respond_to?( :ha) ? v.ha : nil
    unknown = TablizedOutput::V.new 0, '-'
    node = v.node.is_a?(String) ? v.node : v.node.node
    if color = @cfg[:hosts]&.[](node.to_sym)&.[](:color)
      node = ColoredString.new node, fgcolor( color)
    end
    [
      case v.status
      when :running, :online  then ColoredString.new v.status, "32"
      when :stopped, :offline then ColoredString.new v.status, "31"
      else v.status
      end,
      ha&.state || '·',
      case v.t
      when "nd" then ColoredString.new v.sid, "33"
      when "qm" then ColoredString.new v.sid, "35"
      when "ct" then ColoredString.new v.sid, "36"
      else v.sid
      end,
      v.name, node,
      v.respond_to?(:uptime) ? TablizedOutput::V.new( v.uptime, Measured.seconds( v.uptime)) : unknown,
      v.respond_to?(:cpu)    ? TablizedOutput::Percentage.new( v.cpu) : unknown,
      v.respond_to?(:mem)    ? TablizedOutput::V.new( v.mem, Measured.bytes( v.mem)) : unknown,
      v.respond_to?(:maxmem) ? TablizedOutput::Percentage.new( v.mem/v.maxmem.to_f) : unknown,
      v.respond_to?(:disk)   ? TablizedOutput::V.new( v.disk.to_i, Measured.bytes( v.disk.to_i)) : unknown,
      if v.respond_to?(:maxdisk) and 0 < v.maxdisk.to_i
        TablizedOutput::Percentage.new( v.disk.to_f/v.maxdisk.to_f)
      else unknown end,
      v.respond_to?(:tags)   ? v.tags.join(', ') : '',
    ]
  end
end