module SleepRoom

# File lib/sleeproom/utils.rb, line 31
def self.config_dir
  File.join(user_path, ".config", "sleeproom")
end

# File lib/sleeproom/utils.rb, line 37
def self.config_path(config)
  name = {
    status: "status.yml",
    base: "base.yml",
    record: "record.yml",
    pid: "tmp/pid.yml"
  }
  file = name[config].to_s
  raise Error if file.empty?
  return File.join(config_dir, file) if config == :base

  if load_config(:base)[:config_path] == "USER_CONFIG"
    File.join(config_dir, file)
  else
    File.join(load_config(:base)[:config_path], file)
  end
end

# File lib/sleeproom/utils.rb, line 64
def self.create_config_file(config, settings)
  path = config_path(config)
  return false if File.exist?(path)
  mkdir(File.dirname(path)) unless Dir.exist?(File.dirname(path))
  write_config_file(config, settings)
end

# File lib/sleeproom/utils.rb, line 190
def self.create_pid(pid)
  SleepRoom.create_config_file(:pid, pid)
  SleepRoom.write_config_file(:pid, pid)
end

# File lib/sleeproom/utils.rb, line 186
def self.create_record(record = {default: []})
  SleepRoom.create_config_file(:record, record)
end

# File lib/sleeproom/utils.rb, line 182
def self.create_status(status = [])
  SleepRoom.create_config_file(:status, status)
end

# File lib/sleeproom/utils.rb, line 209
def self.error(string)
  log(:error, string)
end

# File lib/sleeproom/utils.rb, line 227
def self.file_logger(type, log)
  path = configatron.logger.file.path
  mkdir(File.dirname(path)) unless Dir.exist?(File.dirname(path))
  logger = Logger.new(path)
  case type
  when :info
    logger.info(log)
  when :warning
    logger.warning(log)
  when :error
    logger.error(log)
  end
end

# File lib/sleeproom/utils.rb, line 197
def self.info(string)
  log(:info, string)
end

# File lib/sleeproom/utils.rb, line 84
def self.init_base
  base = {
    web: {
      use: true,
      server: "localhost",
      port: 3000
    },
    proxy: {
      use: false,
      server: "localhost",
      port: 8080,
      type: "socks5"
    },
    record: {
      all: true,
      wanted: [],
      unwanted: []
    },
    config_path: "USER_CONFIG",
    save_path: "#{sleeproom_dir}/archive",
    working_path: "#{sleeproom_dir}/working",
    default_save_name: "%ROOMNAME%-%TIME%.ts",
    minyami: {
      threads: 8,
      retries: 999,
    },
    logger: {
      console: true,
      file: {
        use: false,
        path: "#{sleeproom_dir}/log"
      }
    }
  }
  create_config_file(:base, base)
end

# File lib/sleeproom/utils.rb, line 121
def self.init_config
  mkdir(config_dir) unless Dir.exist?(config_dir)

  mkdir("#{config_dir}/tmp") unless Dir.exist?("#{config_dir}/tmp")
  
  init_base
  
  record = {
    "default" => []
  }

  create_config_file(:record, record)
  create_config_file(:status, [])
  write_config_file(:pid, nil)
end

# File lib/sleeproom/utils.rb, line 71
def self.load_config(config)
  raise Error if config.empty? || !File.exist?(config_path(config))

  YAML.load_file(config_path(config))
rescue Error => e
  init_config
  retry
end

# File lib/sleeproom/utils.rb, line 160
def self.load_pid
  SleepRoom.load_config(:pid)
rescue Error
  create_pid(nil)
  retry
end

# File lib/sleeproom/utils.rb, line 175
def self.load_record
  SleepRoom.load_config(:record)
rescue Error
  create_record
  retry
end

# File lib/sleeproom/utils.rb, line 153
def self.load_status
  SleepRoom.load_config(:status)
rescue Error
  create_status
  retry
end

# File lib/sleeproom/utils.rb, line 213
def self.log(type, log)
  if configatron.logger.console == true
    case type
    when :info
      puts("[INFO] #{log}".colorize(:white))
    when :warning
      warn("[WARN] #{log}".colorize(:yellow))
    when :error
      puts("[ERROR] #{log}".colorize(:red))
    end
  end
  file_logger(type, log) if configatron.logger.file.use == true
end

# File lib/sleeproom/utils.rb, line 80
def self.mkdir(path)
  FileUtils.mkdir_p(path) unless Dir.exist?(path)
end

# File lib/sleeproom/utils.rb, line 138
def self.reload_config
  configs = %i[base]
  configs.each do |config|
    configatron.configure_from_hash(YAML.load_file(config_path(config)))
  end
  true
rescue Errno::ENOENT => e
  info("Creating configuration...")
  init_base
  false
end

# File lib/sleeproom/utils.rb, line 12
def self.root_path
  Dir.pwd
end

# File lib/sleeproom/utils.rb, line 167
def self.running?(pid=nil)
  pid = SleepRoom.load_config(:pid) if pid.nil?
  Process.kill(0, pid)
  true
rescue
  false
end

# File lib/sleeproom/utils.rb, line 150
def self.settings
  configatron
end

# File lib/sleeproom/utils.rb, line 22
def self.sleeproom_dir
  File.join(user_path, "sleeproom")
end

# File lib/sleeproom/utils.rb, line 17
def self.user_path
  Dir.home
end

# File lib/sleeproom/utils.rb, line 203
def self.warning(string)
  log(:warning, string)
end

# File lib/sleeproom/utils.rb, line 26
def self.working_dir
  Dir.pwd
end

# File lib/sleeproom/utils.rb, line 58
def self.write_config_file(config, settings)
  file = File.new(config_path(config), "w")
  file.puts(YAML.dump(settings))
  file.close
end