class Makit::Humanize

def self.get_command_details(command)
  summary = "#{get_command_summary(command)}\n"
  summary += "  Name: #{command.name}\n"
  summary += "  Arguments: #{command.arguments.join(" ")}\n"
  summary += "  Directory: #{command.directory}\n"
  summary += "  Exit Code: #{command.exit_code}\n"
  if command.output.length > 0
    summary += "  Output:\n"
    summary += indent_string(command.output, 4)
    summary += "\n"
  end
  if command.error.length > 0
    summary += "  Error:\n"
    summary += indent_string(command.error, 4)
    summary += "\n"
  end
  summary
end

def self.get_command_summary(command)
  symbol = Makit::Symbols.warning
  symbol = Makit::Symbols.checkmark if !command.exit_code.nil? && command.exit_code.zero?
  symbol = Makit::Symbols.error if command.exit_code != 0
  "#{symbol} #{command.name} #{command.arguments.join(" ")}"
end

def self.get_commands(commands)
  message = ""
  commands.each do |command|
    message += Makit::Humanize::get_command_details(command)
  end
  message
end

def self.get_humanized_duration(seconds_value)
  minutes = (seconds_value / 60).to_i
  seconds = (seconds_value % 60).to_i
  hours = (minutes / 60).to_i
  minutes = minutes % 60
  days = (hours / 24).to_i
  hours = hours % 24
  milliseconds = (seconds_value % 1 * 1000).to_i
  parts = []
  parts << "#{days} days" if days > 0
  parts << "#{hours} hours" if hours > 0
  if (minutes > 0)
    if (minutes == 1)
      parts << "1 minute"
    else
      parts << "#{minutes} minutes"
    end
  end
  if (seconds > 0)
    if (seconds == 1)
      parts << "1 second"
    else
      parts << "#{seconds} seconds"
    end
  end
  #parts << "#{seconds} seconds" if seconds > 0

  parts << "#{milliseconds} milliseconds" if milliseconds > 0 && seconds < 1
  if (parts.length == 0)
    parts << "0 seconds"
  end
  parts.join(", ")
end

def self.get_humanized_size(bytes, precision = 2)
  units = ["B", "KB", "MB", "GB", "TB", "PB"]
  return "0 B" if bytes == 0
  exp = (Math.log(bytes) / Math.log(1024)).to_i
  exp = units.size - 1 if exp >= units.size
  size = bytes.to_f / (1024 ** exp)
  format("%.#{precision}f %s", size, units[exp])
end

def self.get_humanized_timestamp(timestamp)
  return timestamp.strftime("%Y-%m-%d %I:%M:%S %p") if timestamp.respond_to?(:strftime)
  timestamp.strftime("%Y-%m-%d %H:%M:%S")
end

def self.get_make_result_summary(make_result)
  summary = "Make Result\n"
  summary += "  Repository: #{make_result.repository}\n"
  summary += "  Commit: #{make_result.commit}\n"
  summary += "  Branch: #{make_result.branch}\n"
  summary += "  Tag: #{make_result.tag}\n"
  summary += "  Device: #{make_result.device}\n"
  summary += "  Runtime Identifier: #{make_result.runtime_identifier}\n"
  summary += "  Initial Size: #{get_humanized_size(make_result.initial_size)}\n"
  summary += "  Final Size: #{get_humanized_size(make_result.final_size)}\n"
  summary += "  Delta Size: #{get_humanized_size(make_result.final_size - make_result.initial_size)}\n"
  summary += "  Commands: (#{make_result.commands.length})\n"
  make_result.commands.each do |command|
    details = get_command_details(command)
    summary += "\n"
    summary += indent_string(details, 4)
    summary += "\n"
  end
  summary
end

def self.get_protobuf_duration(duration)
  total_seconds = duration.seconds + (duration.nanos / 1_000_000_000.0)
  hours = (total_seconds / 3600).to_i
  minutes = ((total_seconds % 3600) / 60).to_i
  seconds = (total_seconds % 60).round(2)
  "#{hours}h #{minutes}m #{seconds}s"
end

def self.get_protobuf_timestamp(timestamp)
  Time.at(timestamp.seconds, timestamp.nanos / 1000.0).strftime("%Y-%m-%d %H:%M:%S")
end

def self.indent_string(string, spaces)
  string.split("\n").map { |line| " " * spaces + line }.join("\n")
end