#!/usr/bin/ruby

require_relative 'objects/rcm_file'
require_relative 'objects/rcm_package'
require_relative 'objects/rcm_service'
require_relative 'managers/rcm_config_manager'
require_relative 'managers/rcm_package_manager'
require_relative 'managers/rcm_file_manager'
require_relative 'managers/rcm_service_manager'
require_relative 'rcm_utils'
require 'yaml'
require 'logger'

module RCM
  
  @config_mgr = ::RCM::ConfigManager.new()
  @got = {
    ::RCM::ConfigManager::PACKAGES => {},
    ::RCM::ConfigManager::FILES => {},
    ::RCM::ConfigManager::SERVICES => {}
  }
 
  @logger = @config_mgr.logger
  @pkg_mgr = ::RCM::Apt.new(@logger)
  @file_mgr = ::RCM::FileManager.new(@logger)
  @svc_mgr = ::RCM::ServiceManager.new(@logger)

  def self.converge_packages(current_state_of_packages)
    # We'll install them in one go (minor optimization)
    missing_packages = []

    @pkg_mgr.update unless @env == 'dev'

    @config_mgr.packages.each do |pkg_name, pkg_obj|
      current_pkg = current_state_of_packages[pkg_name]

      if current_pkg == pkg_obj
        @logger.info("#{pkg_name} is in expected state.")
        next
      end

      if current_pkg.version != pkg_obj.version && current_pkg.state == ::RCM::Package::INSTALLED
        # Wrong version is installed. Remove current version and install the correct one.
        # Not the best way to go about it... but we are not implementing a legit solution.
        @logger.debug("#{current_pkg.name}=#{current_pkg.version} is installed. Uninstalling first.")
        @pkg_mgr.remove(pkg_obj)
        missing_packages.push(pkg_obj)
      elsif current_pkg.state == ::RCM::Package::REMOVED
        missing_packages.push(pkg_obj)
      end
    end

    @pkg_mgr.install(missing_packages) unless missing_packages.empty?
  end

  def self.converge_files(current_state_of_files)
    @config_mgr.files.each do |path, file_obj|
      file_on_fs = current_state_of_files[path]

      if file_on_fs.state == ::RCM::File::PRESENT && file_obj.state == ::RCM::File::ABSENT
        @logger.info("#{path} is present on disk when it should not be. Removing...")
        @file_mgr.remove(file_obj)
        next
      end

      if file_on_fs == file_obj
        @logger.info("#{path} is in expected state (#{file_on_fs.state}).")
        next
      end

      @logger.info("#{path} is not in expected state on disk.")
      status = @file_mgr.copy(file_obj)
      @file_mgr.apply_attributes(file_obj) if status == 0
    end
  end

  def self.restart_services_if_needed
    @config_mgr.services.values.each do |svc_obj|
      @svc_mgr.restart(svc_obj) if @svc_mgr.dependencies_changed?(svc_obj)
    end
  end

  def main
    # Installing packages creates file that we want to delete.
    # So finish managing packages and then deal with files.
    current_state_of_packages = @pkg_mgr.get_current_state(@config_mgr.packages)
    converge_packages(current_state_of_packages)
    current_state_of_files = @file_mgr.get_current_state(@config_mgr.files)
    converge_files(current_state_of_files)
    restart_services_if_needed
  end

  module_function :main
end

RCM.main