# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  # Forward host machine SSH agent to guest machine
  config.ssh.forward_agent = true

  if Vagrant.has_plugin?("vagrant-vbguest") then
    config.vbguest.auto_update = false
  end

  config.vm.provider :docker do |docker, override|
    override.vm.box = nil
    docker.image = "vagrant-nicu:latest"
    docker.remains_running = true
    docker.has_ssh = true
    docker.privileged = true
    docker.volumes = ["/sys/fs/cgroup:/sys/fs/cgroup:ro"]

    docker.create_args = [
        "--add-host", "dashboard.portfolio.local pw.internal.pixieset.local:192.168.56.106",
        "--add-host", "mwa.local mwa.internal.pixieset.local:192.168.56.107",
        "--add-host", "cs.internal.pixieset.local:192.168.56.109",
        "--add-host", "studio.local sm.internal.pixieset.local:192.168.56.111",
        # "--mac-address", "255.255.255.0",
        # "--ip", "192.168.56.101",
        # "--dns", "[8.8.8.8]"
      ]
    # Uncomment to force arm64 for testing images on Intel
    # docker.create_args = ["--platform=linux/arm64"]
  end

  # Redis Server
  config.vm.define "redis" do |redis|
    # redis.vm.box = "ubuntu/focal64"
    redis.vm.hostname = 'redis'
    # redis.vm.box_url = "ubuntu/focal64"
    redis.vm.network :private_network, ip: "192.168.56.103"

    redis.vm.synced_folder "~/dev/ansible-pixieset/", "/ansible",
      owner: "root", group: "root"

    # redis.vm.provider :virtualbox do |v|
    #   v.customize ["modifyvm", :id, "--natdnshostresolver1", "on"]
    #   v.customize ["modifyvm", :id, "--memory", 512]
    #   v.customize ["modifyvm", :id, "--name", "redis"]
    #   v.customize ["guestproperty", "set", :id, "/VirtualBox/GuestAdd/VBoxService/--timesync-set-threshold", 2000]
    # end
    redis.vm.provision "ansible_local" do |ansible|
      ansible.playbook = "/ansible/dev-redis.yml"
      ansible.become = true
      ansible.install = true
      ansible.compatibility_mode = "2.0"
    end
  end

  # MySQL 5.7 server
  config.vm.define "db57" do |db57|
    # db57.vm.box = "ubuntu/xenial64"
    db57.vm.hostname = 'db57'
    # db57.vm.box_url = "ubuntu/xenial64"
    db57.vm.network :private_network, ip: "192.168.56.110"

    db57.vm.synced_folder "~/dev/ansible-pixieset/", "/ansible",
      owner: "root", group: "root"

    # db57.vm.provider :virtualbox do |v|
    #   v.customize ["modifyvm", :id, "--natdnshostresolver1", "on"]
    #   v.customize ["modifyvm", :id, "--memory", 768]
    #   v.customize ["modifyvm", :id, "--name", "db57"]
    #   v.customize ["guestproperty", "set", :id, "/VirtualBox/GuestAdd/VBoxService/--timesync-set-threshold", 2000]
    # end
     db57.vm.provision "ansible_local" do |ansible|
       ansible.playbook = "/ansible/dev-db57.yml"
       ansible.become = true
       ansible.install = true
       ansible.compatibility_mode = "2.0"
       ansible.extra_vars = { ansible_python_interpreter:"/usr/bin/python3" }
     end
  end

  # Web Server for Client Gallery App
  config.vm.define "web" do |web|
    # web.vm.box = "ubuntu/focal64"
    web.vm.hostname = 'web'
    # web.vm.box_url = "ubuntu/focal64"
    # uncomment the line below if you want to make your server publicly accessible from LAN. You can access it locally by default
    # web.vm.network :public_network
    web.vm.network :private_network, ip: "192.168.56.101", dns: "8.8.8.8"
    # web.vm.network :forwarded_port, guest: 80, host: 8080

    web.vm.synced_folder "~/dev/pixieset/", "/home/pixieset/public/pixieset.com/public/pixieset",
      owner: "www-data", group: "www-data"
    web.vm.synced_folder "~/dev/ansible-pixieset/", "/ansible",
      owner: "root", group: "root"
    web.vm.synced_folder "~/.aws/", "/var/www/.aws", create: true,
      owner: "www-data", group: "www-data"
    web.vm.synced_folder "~/.
    aws/", "/home/vagrant/.aws", create: true

    # web.vm.provider :docker do |docker, override|
    #   docker.ports = ["8080:80"]
    # end

    # web.vm.provider :virtualbox do |v|
    #   v.customize ["modifyvm", :id, "--memory", 1536]
    #   v.customize ["modifyvm", :id, "--name", "web"]
    #   v.customize ["guestproperty", "set", :id, "/VirtualBox/GuestAdd/VBoxService/--timesync-set-threshold", 2000]
    # end

    web.vm.provision "ansible_local" do |ansible|
      ansible.playbook = "/ansible/dev-web.yml"
      ansible.become = true
      ansible.install = true
      ansible.compatibility_mode = "2.0"
    end
  end

  # Web Server for Mobile Gallery App
  config.vm.define "mobile", autostart: false do |mobile|
    mobile.vm.box = "ubuntu/focal64"
    mobile.vm.hostname = 'mobile'
    mobile.vm.box_url = "ubuntu/focal64"
    # uncomment the line below if you want to make your server publicly accessible from LAN. You can access it locally by default
    # mobile.vm.network :public_network
    mobile.vm.network :private_network, ip: "192.168.56.107", dns: "8.8.8.8"

    mobile.vm.synced_folder "~/dev/mobile-web-app", "/home/pixieset/public/mobile-web-app",
      owner: "www-data", group: "www-data"
    mobile.vm.synced_folder "~/dev/ansible-pixieset/", "/ansible",
      owner: "root", group: "root"
    mobile.vm.synced_folder "~/.aws/", "/var/www/.aws", create: true,
      owner: "www-data", group: "www-data"
    mobile.vm.synced_folder "~/.aws/", "/home/vagrant/.aws", create: true

    mobile.vm.provider :virtualbox do |v|
      v.customize ["modifyvm", :id, "--memory", 512]
      v.customize ["modifyvm", :id, "--name", "mobile"]
      v.customize ["guestproperty", "set", :id, "/VirtualBox/GuestAdd/VBoxService/--timesync-set-threshold", 2000]
    end
    mobile.vm.provision "ansible_local" do |ansible|
      ansible.playbook = "/ansible/dev-web-mobile.yml"
      ansible.become = true
      ansible.install = true
      ansible.compatibility_mode = "2.0"
    end
  end

  # Web Server for Portfolio Website
  config.vm.define "portfolio", autostart: false do |portfolio|
    portfolio.vm.box = "ubuntu/focal64"
    portfolio.vm.hostname = 'portfolio'
    portfolio.vm.box_url = "ubuntu/focal64"
    # uncomment the line below if you want to make your server publicly accessible from LAN. You can access it locally by default
    # portfolio.vm.network :public_network
    portfolio.vm.network :private_network, ip: "192.168.56.106", dns: "8.8.8.8"

    portfolio.vm.synced_folder "~/dev/portfolio/src", "/home/pixieset/public/portfolio",
      owner: "www-data", group: "www-data"
    portfolio.vm.synced_folder "~/dev/ansible-pixieset/", "/ansible",
      owner: "root", group: "root"
    portfolio.vm.synced_folder "~/.aws/", "/var/www/.aws", create: true,
      owner: "www-data", group: "www-data"
    portfolio.vm.synced_folder "~/.aws/", "/home/vagrant/.aws", create: true

    portfolio.vm.provider :virtualbox do |v|
      v.customize ["modifyvm", :id, "--memory", 512]
      v.customize ["modifyvm", :id, "--name", "portfolio"]
      v.customize ["guestproperty", "set", :id, "/VirtualBox/GuestAdd/VBoxService/--timesync-set-threshold", 2000]
    end
    portfolio.vm.provision "ansible_local" do |ansible|
      ansible.playbook = "/ansible/dev-web-portfolio.yml"
      ansible.become = true
      ansible.install = true
      ansible.compatibility_mode = "2.0"
    end
  end

  # Web Server for Studio Manager
  config.vm.define "studio", autostart: false do |studio|
    studio.vm.box = "ubuntu/focal64"
    studio.vm.hostname = 'studio'
    studio.vm.box_url = "ubuntu/focal64"
    # uncomment the line below if you want to make your server publicly accessible from LAN. You can access it locally by default
    # studio.vm.network :public_network
    studio.vm.network :private_network, ip: "192.168.56.111", dns: "8.8.8.8"

    studio.vm.synced_folder "~/dev/studio-manager/src", "/home/pixieset/public/studio-manager",
      owner: "www-data", group: "www-data"
    studio.vm.synced_folder "~/dev/ansible-pixieset/", "/ansible",
      owner: "root", group: "root"
    studio.vm.synced_folder "~/.aws/", "/var/www/.aws", create: true,
      owner: "www-data", group: "www-data"
    studio.vm.synced_folder "~/.aws/", "/home/vagrant/.aws", create: true

    studio.vm.provider :virtualbox do |v|
      v.customize ["modifyvm", :id, "--memory", 512]
      v.customize ["modifyvm", :id, "--name", "studio"]
      v.customize ["guestproperty", "set", :id, "/VirtualBox/GuestAdd/VBoxService/--timesync-set-threshold", 2000]
    end
    studio.vm.provision "ansible_local" do |ansible|
      ansible.playbook = "/ansible/dev-web-studiomanager.yml"
      ansible.become = true
      ansible.install = true
      ansible.compatibility_mode = "2.0"
    end
  end

  # CertManager
  config.vm.define "certmanager", autostart: false do |certmanager|
    certmanager.vm.box = "ubuntu/xenial64"
    certmanager.vm.hostname = 'certmanager'
    certmanager.vm.box_url = "ubuntu/xenial64"
    certmanager.vm.network :private_network, ip: "192.168.56.105"

    # uid 1080 = certbot Ansible will set this during provisioning stage.
    # I cannot use username 'certbot' to referance it because it does not exist during the first boot up but I can use uids
    certmanager.vm.synced_folder "~/dev/pixieset/", "/home/pixieset/public/pixieset.com/public/pixieset",
      owner: 1080, group: 1080
    certmanager.vm.synced_folder "~/dev/ansible-pixieset/", "/ansible",
      owner: "root", group: "root"
    certmanager.vm.synced_folder "~/.aws/", "/var/www/.aws", create: true,
      owner: 1080, group: 1080
    certmanager.vm.synced_folder "~/.aws/", "/home/certbot/.aws", create: true

    certmanager.vm.provider :virtualbox do |v|
      v.customize ["modifyvm", :id, "--memory", 512]
      v.customize ["modifyvm", :id, "--name", "certmanager"]
      # to-do: Create 2nd disk for CertManager to mimic production setup:
      # v.customize ['createhd', '--filename', 'certmanager-2nd-disk.vdi', '--size', 20 * 1024]
      # v.customize ['storageattach', :id, '--storagectl', 'SATAController', '--port', 1, '--device', 0, '--type', 'hdd', '--medium', 'certmanager-second-disk.vdi']
    end
    certmanager.vm.provision "ansible_local" do |ansible|
      ansible.playbook = "/ansible/dev-certmanager.yml"
      ansible.become = true
      ansible.install = true
      ansible.compatibility_mode = "2.0"
    end
  end

  # Terminator - SSL terminator machine
  config.vm.define "terminator", autostart: false do |terminator|
    terminator.vm.box = "ubuntu/focal64"
    terminator.vm.hostname = 'terminator'
    terminator.vm.box_url = "ubuntu/focal64"
    terminator.vm.network :private_network, ip: "192.168.56.104"

    terminator.vm.synced_folder "~/dev/ansible-pixieset/", "/ansible",
      owner: "root", group: "root"

    terminator.vm.provider :virtualbox do |v|
      v.customize ["modifyvm", :id, "--memory", 512]
      v.customize ["modifyvm", :id, "--name", "terminator"]
    end
    terminator.vm.provision "ansible_local" do |ansible|
      ansible.playbook = "/ansible/dev-terminator.yml"
      ansible.become = true
      ansible.install = true
      ansible.compatibility_mode = "2.0"
    end
  end

  # Compression Worker
  config.vm.define "compressionworker", autostart: false do |compressionworker|
    compressionworker.vm.box = "ubuntu/focal64"
    compressionworker.vm.hostname = 'compressionworker'
    compressionworker.vm.box_url = "ubuntu/focal64"
    compressionworker.vm.network :private_network, ip: "192.168.56.108"

    compressionworker.vm.synced_folder "~/dev/compressionworker/src", "/home/pixieset/public/compressionworker",
      owner: "www-data", group: "www-data"
    compressionworker.vm.synced_folder "~/dev/ansible-pixieset/", "/ansible",
      owner: "root", group: "root"
    compressionworker.vm.synced_folder "~/.aws/", "/var/www/.aws", create: true,
      owner: "www-data", group: "www-data"
    compressionworker.vm.synced_folder "~/.aws/", "/home/vagrant/.aws", create: true

    compressionworker.vm.provider :virtualbox do |v|
      v.customize ["modifyvm", :id, "--memory", 768]
      v.customize ["modifyvm", :id, "--name", "compressionworker"]
      v.customize ["guestproperty", "set", :id, "/VirtualBox/GuestAdd/VBoxService/--timesync-set-threshold", 2000]
    end
    compressionworker.vm.provision "ansible_local" do |ansible|
      ansible.playbook = "/ansible/dev-compressionworker.yml"
      ansible.become = true
      ansible.install = true
      ansible.compatibility_mode = "2.0"
    end
  end

  # Centralized Services
  config.vm.define "centralizedservices" do |centralizedservices|
    # centralizedservices.vm.box = "ubuntu/focal64"
    centralizedservices.vm.hostname = 'centralizedservices'
    # centralizedservices.vm.box_url = "ubuntu/focal64"
    centralizedservices.vm.network :private_network, ip: "192.168.56.109"

    centralizedservices.vm.synced_folder "~/dev/centralized-services/src", "/home/pixieset/public/centralized-services",
      owner: "www-data", group: "www-data"
    centralizedservices.vm.synced_folder "~/dev/ansible-pixieset", "/ansible",
      owner: "root", group: "root"
    centralizedservices.vm.synced_folder "~/.aws/", "/var/www/.aws", create: true,
      owner: "www-data", group: "www-data"
    centralizedservices.vm.synced_folder "~/.aws/", "/home/vagrant/.aws", create: true

    # centralizedservices.vm.provider :virtualbox do |v|
    #   v.customize ["modifyvm", :id, "--memory", 512]
    #   v.customize ["modifyvm", :id, "--name", "centralizedservices"]
    #   v.customize ["guestproperty", "set", :id, "/VirtualBox/GuestAdd/VBoxService/--timesync-set-threshold", 2000]
    # end
    centralizedservices.vm.provision "ansible_local" do |ansible|
      ansible.playbook = "/ansible/dev-centralizedservices.yml"
      ansible.become = true
      ansible.install = true
      ansible.compatibility_mode = "2.0"
    end
  end
# end of the configuration
end