require 'colorize'

app_name = "my-app" # specify your app name
rails_master_key = File.read('config/master.key')
db_password = "dumbpass" # same as postgresql container's setting
db_host_or_ip = "app-pg" # the container name of pg db, to let Rails database.yml know where to connect
docker_subnet = "app-net" # The rails, db, frp, redis Docker internal network, can be "bridge" or "host" or "anything", need to create in docker with docker network create
server_user = "root" # the user of the remote server (pi, or an Hetzner vps, etc)
server_ip = "docker-app-ip" # the IP of the server
use_bzip = false # whether to compress docker image when transmitting it to server, if server can't decompress fast or net traffic is free, don't zip. If server traffic is slow, zip it.

deploy_start_at = Process.clock_gettime(Process::CLOCK_MONOTONIC) # To count how many seconds is used for the whole deploy process

# Run a shell command on remote machine
run_remote = Proc.new do |cmd|
  start_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
  puts "Start CMD: ssh #{server_user}@#{server_ip} #{cmd} 2>&1".colorize(:blue)  # 2>&1 will show the stderr in return value
  out = `ssh #{server_user}@#{server_ip} #{cmd} 2>&1`
  finish_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
  puts "Finished CMD: #{(finish_at - start_at).round(1)} seconds.\n\n".colorize(:green)
  out
end

# Run a shell command on local machine
run_local = Proc.new do |cmd| 
  start_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
  puts "Start CMD: #{cmd} 2>&1".colorize(:blue)
  out = `#{cmd} 2>&1`
  finish_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
  puts "Finished CMD: #{(finish_at - start_at).round(1)} seconds.\n\n".colorize(:green)
  out
end

# Healthcheck a Rails app is running successfully by inspect the container status and then GET /up.
test_app_running = Proc.new do |container_name|
  10.times do |i|
    puts "#{server_ip}: Healthcheck new container status - Round: #{i}"
    out = run_remote.call("docker inspect --format \"\" #{container_name}")
    if out.include? "true"
      out = run_remote.call("docker run --rm --network #{docker_subnet} curlimages/curl --silent -LI -o /dev/null #{container_name}:3000/up -w '%{http_code}\n'")
      if out.include? "200"
        puts "#{server_ip}: Container is ready."
        puts "#{server_ip}: Success!"
        break
      else
        puts "#{server_ip}: Container is up but Rails server is not ready, waiting 3 seconds..."
        sleep(3)
      end
    elsif i < 9
      puts "#{server_ip}: Container is not ready, waiting 1 second..."
      sleep(1)
    else
      raise "#{server_ip}: Container is not ready after waits. Aborting. Manual fix is required."
    end
  end
end

# Phase 1: Build Docker Image for Rails App
puts "local: Building Docker image for #{app_name}."
build_image_cmd = "docker build -t #{app_name}:new_build ."
out = run_local.call(build_image_cmd)
if out.include? "DONE"
  puts "local: Docker Build Successful."
elsif out.include? "ERROR"
  puts out
  raise "local: Docker Build Error."
else
  raise "local: Docker build process status unknown, check manually."
end

puts "local+remote: Compressing Image and Loading it in the Remote Server"
out = run_local.call("docker save #{app_name}:new_build #{use_bzip ? "| bzip2 |" : "|"} ssh #{server_user}@#{server_ip} docker load")

# Phase 2: Test the Docker image of Rails app on remote server. If successful, stop it and run it later.
# Because port mapping of docker and container name can't have conflict, but FRP uses a static web app container name in frps.ini, can't change it dynamically.
# So, have to stop and rerun the new app container.
puts "#{server_ip}: Starting Rails app with new built image"
out = run_remote.call("docker run --name #{app_name}-app-new-build -e RAILS_MASTER_KEY=#{rails_master_key} -e POSTGRES_PASSWORD=#{db_password} -e DB_HOST=#{db_host_or_ip} --network #{docker_subnet} -d #{app_name}:new_build")
puts "#{server_ip}: #{out}"

puts "Test if app can start"
test_app_running.call("#{app_name}-app-new-build")

puts "#{server_ip}: Stopping new container, will restart it later after stopping the old one."
out = run_remote.call("docker container stop #{app_name}-app-new-build")

puts "#{server_ip}: Removing new build container"
out = run_remote.call("docker container rm #{app_name}-app-new-build")

# Phase 3: Stop old container, start new container for the Rails app
puts "#{server_ip}: Stopping old Rails container"
out = run_remote.call("docker container stop #{app_name}-app")

puts "#{server_ip}: Removing old Rails container"
out = run_remote.call("docker container rm #{app_name}-app")

puts "#{server_ip}: Removing old Rails Image"
out = run_remote.call("docker image rm #{app_name}")

puts "#{server_ip}: Renaming new rails image tag from 'new_build' to 'latest'"
out = run_remote.call("docker image tag #{app_name}:new_build #{app_name}:latest")
out = run_remote.call("docker image rm #{app_name}:new_build")

puts "#{server_ip}: Starting Rails app..."
out = run_remote.call("docker run --name #{app_name}-app -e RAILS_MASTER_KEY=#{rails_master_key} -e POSTGRES_PASSWORD=#{db_password} -e DB_HOST=#{db_host_or_ip} --network #{docker_subnet} -d #{app_name}")

# Phase 4: Test new container is ready.
puts "Test if app is running"
test_app_running.call("#{app_name}-app")

puts "Deployment finished in #{(Process.clock_gettime(Process::CLOCK_MONOTONIC) - deploy_start_at).round(1)} seconds."

# Optional: Clean up local docker images
puts "local: Retag new build Docker image to latest. Remove old image file."
old_image_id = run_local.call("docker images -q #{app_name}:latest").strip
out = run_local.call("docker image tag #{app_name}:new_build #{app_name}:latest")
out = run_local.call("docker image rm #{old_image_id}")
out = run_local.call("docker image rm #{app_name}:new_build")