require_relative 'objects/rcm_file'
require_relative 'objects/rcm_package'
require_relative 'objects/rcm_service'
require_relative 'managers/rcm_package_manager'
require 'yaml'

module RCM
  PACKAGES = 'packages'
  FILES = 'files'
  SERVICES = 'services'

  @@wanted = {
    PACKAGES => {},
    FILES => {},
    SERVICES => {}
  }

  @@got = {
    PACKAGES => {},
    FILES => {},
    SERVICES => {}
  }

  @@crackalackin = {
      PACKAGES => [],
      FILES => [],
      SERVICES => []
  }

  @@pkg_mgr = ::RCM::Apt.new()

  def self.parse_packages(markup)
    markup.each do |d|
      # ensure package version exists, if mentioned.
      version = d.fetch('version', '')
      desired_state = d.fetch('desired_state', ::RCM::Package::INSTALLED)

      valid_package_states = [::RCM::Package::INSTALLED, ::RCM::Package::REMOVED]

      if (valid_package_states & [desired_state]).empty?
        raise "Unknown desired_state: #{desired_state}. Valid states: #{valid_package_states.join(', ')}"
      end

      unless version.empty?
        available_versions = @@pkg_mgr.get_versions(d['name'])
        if (available_versions & [version]).empty?
          raise "\n\n#{d['name']} = #{version} is not available.\nAvailable versions: #{available_versions.join(', ')}"
        end
      end
      p = RCM::Package.new(d['name'], version, desired_state)
      @@wanted[PACKAGES][d['name']] = p
    end
  end


  def whachuwant() # or parse_config
    env = ENV.fetch('ENVIRONMENT', '')
    # Consume config from YAML, and convert it to usable objects in @@wanted.
    config_file = env.empty? ? 'config.yaml' : "config_#{env}.yaml"

    raise "#{config_file} not found." unless ::File.readable?(config_file)

    config = YAML.load_file(config_file)
    config.each do |yaml_objects|
      yaml_objects.each do |coll, defs|
        case coll
        when PACKAGES
          parse_packages(defs)

        when FILES
          defs.each do |d|
            f = RCM::File.new(d['path'], d['owner'], d['group'], d['mode'], 'idk')
            @@wanted[FILES][d['path']] = f
          end

        when SERVICES
          defs.each do |d|
            puts d
          end
        end
      end
    end

  end

  def whachugot() # or get_current_state
    @@wanted[PACKAGES].each do |name, p|
      state = ::RCM::Package::REMOVED
      version = 'idk'
      begin
        status = @@pkg_mgr.status(p.name)

        if status[:exit_code] == 0
          state = ::RCM::Package::INSTALLED if status[:output] =~ 'ok installed'
          version = /Version: (?<version>\d+.+)/.match(status[:output])[:version]
        end

        current_pkg = ::RCM::Package.new(name, version, state)

        @@got[PACKAGES][name] = current_pkg
      rescue Exception => e
        puts e.message
      end
    end
  end

  def crackalackin_packages()
    @@wanted[PACKAGES].each do |pkg_name, pkg_obj|
      current_pkg = @@got[PACKAGES][pkg_name]

      next if current_pkg.state == ::RCM::Package::INSTALLED &&
          current_pkg.version == pkg_obj.version

      # Set the version correctly
      current_pkg.version = pkg_obj.version
      @@crackalackin[PACKAGES].push(current_pkg)
    end

    puts @@crackalackin[PACKAGES]
  end

  def cracka_stop_lackin()
    puts 'not implemented'
  end
  module_function :whachuwant, :whachugot, :crackalackin_packages, :cracka_stop_lackin

end

RCM.whachuwant
RCM.whachugot
RCM.crackalackin_packages